diff --git a/Applications/PluginGenerator/PluginGenerator.cpp b/Applications/PluginGenerator/PluginGenerator.cpp
index 6bfa50e1f8..3f13d8aebf 100644
--- a/Applications/PluginGenerator/PluginGenerator.cpp
+++ b/Applications/PluginGenerator/PluginGenerator.cpp
@@ -1,547 +1,547 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "ctkCommandLineParser.h"
 #include <PluginGeneratorConfig.h>
 
 #include <QBuffer>
 #include <QCoreApplication>
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QTextStream>
 
 //#include <QtNetwork/QNetworkReply>
 //#include <QtNetwork/QNetworkRequest>
 
 #include <cctype>
 #include <cstdlib>
 #include <iostream>
 #include <limits>
 
 int compareVersions(const QString &v1, const QString &v2)
 {
   QList<int> t1;
   foreach (QString t, v1.split('.'))
   {
     t1.append(t.toInt());
   }
 
   QList<int> t2;
   foreach (QString t, v2.split('.'))
   {
     t2.append(t.toInt());
   }
 
   // pad with 0
   if (t1.size() < t2.size())
   {
     for (int i = 0; i < t2.size() - t1.size(); ++i)
       t1.append(0);
   }
   else
   {
     for (int i = 0; i < t1.size() - t2.size(); ++i)
       t2.append(0);
   }
 
   for (int i = 0; i < t1.size(); ++i)
   {
     if (t1.at(i) < t2.at(i))
       return -1;
     else if (t1.at(i) > t2.at(i))
       return 1;
   }
   return 0;
 }
 
 /*int checkUpdates(QTextStream &out)
 {
   out << "Checking for updates... ";
   out.flush();
   QNetworkAccessManager manager;
   QNetworkReply *reply =
-    manager.get(QNetworkRequest(QUrl("http://www.mitk.org/wiki/PluginGeneratorUpdate?action=raw")));
+    manager.get(QNetworkRequest(QUrl("https://www.mitk.org/wiki/PluginGeneratorUpdate?action=raw")));
 
   QEventLoop eventLoop;
   reply->connect(reply, SIGNAL(finished()), &eventLoop, SLOT(quit()));
   eventLoop.exec();
 
   QByteArray data = reply->readAll();
 
   if (data.isEmpty())
   {
     qCritical() << "A network error occured:" << reply->errorString();
     return EXIT_FAILURE;
   }
   delete reply;
 
   QBuffer buffer(&data);
   buffer.open(QIODevice::ReadOnly);
   bool versionFound = false;
   while (buffer.canReadLine())
   {
     QString line = buffer.readLine();
     if (!versionFound)
     {
       line = line.trimmed();
       if (line.isEmpty())
         continue;
 
       if (compareVersions(PLUGIN_GENERATOR_VERSION, line) < 0)
       {
         versionFound = true;
         out << "New version " << line << " available.\n";
       }
       else
       {
         // no update available
         out << "No update available.\n";
         out.flush();
         return EXIT_SUCCESS;
       }
     }
     else
     {
       out << line;
     }
   }
 
   if (!versionFound)
   {
     qCritical() << "Update information not readable.";
     return EXIT_FAILURE;
   }
 
   out << '\n';
   out.flush();
 
   return EXIT_SUCCESS;
 }*/
 
 bool readAnswer(char defaultAnswer)
 {
   std::string line;
   std::cin >> std::noskipws >> line;
 
   // consume the new line character
   std::cin.clear();
   std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
   char answer = defaultAnswer;
   if (!line.empty() && line[0] != '\n')
   {
     answer = std::tolower(line[0]);
   }
 
   if (answer == 'y')
     return true;
   if (answer == 'n')
     return false;
   if (defaultAnswer == 'y')
     return true;
   return false;
 }
 
 void createFilePathMapping(const QString &templateName,
                            const QString &baseInDir,
                            const QString &baseOutDir,
                            QHash<QString, QString> &fileNameMapping)
 {
   QFileInfo info(templateName);
   if (info.isDir())
   {
     QStringList subEntries = QDir(templateName).entryList();
     foreach (QString subEntry, subEntries)
     {
       createFilePathMapping(templateName + "/" + subEntry, baseInDir, baseOutDir, fileNameMapping);
     }
     return;
   }
 
   fileNameMapping[templateName] = QString(templateName).replace(baseInDir, baseOutDir);
 }
 
 QHash<QString, QString> createTemplateFileMapping(const QString &qrcBase,
                                                   const QString &baseOutDir,
                                                   const QHash<QString, QString> &fileNameMapping)
 {
   QHash<QString, QString> filePathMapping;
   createFilePathMapping(qrcBase, qrcBase, baseOutDir, filePathMapping);
 
   QMutableHashIterator<QString, QString> i(filePathMapping);
   while (i.hasNext())
   {
     i.next();
     QHashIterator<QString, QString> j(fileNameMapping);
     while (j.hasNext())
     {
       j.next();
       i.setValue(i.value().replace(j.key(), j.value()));
     }
   }
 
   return filePathMapping;
 }
 
 bool generateFiles(const QHash<QString, QString> &parameters, const QHash<QString, QString> &filePathMapping)
 {
   QHashIterator<QString, QString> paths(filePathMapping);
   while (paths.hasNext())
   {
     paths.next();
     QFile templ(paths.key());
     templ.open(QIODevice::ReadOnly);
     QByteArray templContent = templ.readAll();
 
     QHashIterator<QString, QString> i(parameters);
     while (i.hasNext())
     {
       i.next();
       templContent.replace(i.key(), QByteArray(i.value().toLatin1()));
     }
 
     QFile outTempl(paths.value());
     QDir dir(QFileInfo(outTempl).dir());
     if (!dir.exists())
     {
       if (!dir.mkpath(dir.absolutePath()))
       {
         qCritical() << "Could not create directory" << dir.absolutePath();
         return EXIT_FAILURE;
       }
     }
 
     if (!outTempl.open(QIODevice::WriteOnly))
     {
       qCritical() << outTempl.errorString();
       return false;
     }
     outTempl.write(templContent);
   }
 
   return true;
 }
 
 int main(int argc, char **argv)
 {
   QString appName("MitkPluginGenerator");
 
   QCoreApplication app(argc, argv);
   app.setApplicationName(appName);
   app.setOrganizationName("DKFZ");
 
   ctkCommandLineParser parser;
   // Use Unix-style argument names
   parser.setArgumentPrefix("--", "-");
   parser.setStrictModeEnabled(true);
 
   // Add command line argument names
   parser.addArgument("help", "h", QVariant::Bool, "  Show this help text");
   parser.addArgument("out-dir", "o", QVariant::String, "  Output directory", QDir::tempPath());
   parser.addArgument(
     "license", "l", QVariant::String, "  Path to a file containing license information", ":/COPYRIGHT_HEADER");
   parser.addArgument("vendor", "v", QVariant::String, "  The vendor of the generated code", "German Cancer Research Center (DKFZ)");
   parser.addArgument("quiet", "q", QVariant::Bool, "  Do not print additional information");
   parser.addArgument("confirm-all", "y", QVariant::Bool, "  Answer all questions with 'yes'");
   //parser.addArgument("check-update", "u", QVariant::Bool, "  Check for updates and exit");
   //parser.addArgument("no-networking", "n", QVariant::Bool, "  Disable all network requests");
 
   parser.beginGroup("Plug-in options");
   parser.addArgument("plugin-symbolic-name", "ps", QVariant::String, "* The plugin's symbolic name");
   parser.setExactMatchRegularExpression("-ps", "^[a-zA-Z]+\\.[a-zA-Z0-9._]+[^\\.]$", "Symbolic name invalid");
   parser.addArgument("plugin-name", "pn", QVariant::String, "  The plug-in's human readable name");
 
   parser.beginGroup("Plug-in View options");
   parser.addArgument("view-class", "vc", QVariant::String, "  The View's' class name");
   parser.addArgument("view-name", "vn", QVariant::String, "* The View's human readable name");
 
   parser.beginGroup("Project options");
   parser.addArgument(
     "project-copyright", "", QVariant::String, "  Path to a file containing copyright information", ":/LICENSE");
   parser.addArgument("project-name", "", QVariant::String, "  The project name");
   parser.setExactMatchRegularExpression("--project-name", "^[a-zA-Z_\\-]+$", "Project name invalid");
   parser.addArgument("project-app-name", "", QVariant::String, "  The application name");
   parser.setExactMatchRegularExpression("--project-app-name", "^[a-zA-Z_\\-]+$", "Project application name invalid");
   parser.endGroup();
 
   // Parse the command line arguments
   bool ok = false;
   QHash<QString, QVariant> parsedArgs = parser.parseArguments(QCoreApplication::arguments(), &ok);
   if (!ok)
   {
     QTextStream(stderr, QIODevice::WriteOnly) << "Error parsing arguments: " << parser.errorString() << "\nType '"
                                               << appName << " -h' for help\n";
     return EXIT_FAILURE;
   }
 
   QTextStream out(stdout, QIODevice::WriteOnly);
 
   // Show a help message
   if (parsedArgs.contains("help"))
   {
     out << "A CTK plug-in generator for MITK (version " PLUGIN_GENERATOR_VERSION ")\n\n"
         << parser.helpText() << "\n[* - options are required]\n";
     return EXIT_SUCCESS;
   }
 
   /*bool noNetwork = parsedArgs.contains("no-networking");
 
   if (parsedArgs.contains("check-update"))
   {
     if (noNetwork)
     {
       out << "Network support disabled. Cannot check for updates.\n";
       out.flush();
     }
     else
     {
       return checkUpdates(out);
     }
   }
   else
   {
     // always check for updates if no-networking is not given
     if (!noNetwork)
     {
       checkUpdates(out);
     }
   }*/
 
   // Check arguments
 
   // Project options
   QString projectName = parsedArgs["project-name"].toString();
   QString projectAppName = parsedArgs["project-app-name"].toString();
   QString copyrightPath = QDir::fromNativeSeparators(parsedArgs["project-copyright"].toString());
 
   bool createProject = !projectName.isEmpty();
   if (createProject && projectAppName.isEmpty())
   {
     projectAppName = projectName;
   }
 
   QString pluginSymbolicName = parsedArgs["plugin-symbolic-name"].toString();
   if (pluginSymbolicName.isEmpty())
   {
     qCritical() << "Required argument 'plugin-symbolic-name' missing.";
     qCritical("%s%s%s", "Type '", qPrintable(appName), " -h' for help");
     return EXIT_FAILURE;
   }
 
   QString pluginTarget(pluginSymbolicName);
   pluginTarget.replace('.', '_');
 
   QString activatorClass = pluginTarget + "_Activator";
 
   QString outDir = QDir::fromNativeSeparators(parsedArgs["out-dir"].toString());
   QString licensePath = QDir::fromNativeSeparators(parsedArgs["license"].toString());
   QString pluginExportDirective = pluginSymbolicName.split('.').last().toUpper() + "_EXPORT";
 
   QString pluginName = parsedArgs["plugin-name"].toString();
   if (pluginName.isEmpty())
   {
     QStringList toks = pluginSymbolicName.split('.');
     pluginName = toks.last();
     pluginName[0] = pluginName[0].toUpper();
   }
 
   QString vendor = parsedArgs["vendor"].toString();
 
   QString viewName = parsedArgs["view-name"].toString();
   if (viewName.isEmpty())
   {
     qCritical() << "Required argument 'view-name' missing.";
     qCritical("%s%s%s", "Type '", qPrintable(appName), " -h' for help");
     return EXIT_FAILURE;
   }
 
   QStringList toks = viewName.split(QRegExp("\\s"), QString::SkipEmptyParts);
   QString viewClass = parsedArgs["view-class"].toString();
   if (viewClass.isEmpty())
   {
     foreach (QString tok, toks)
     {
       QString tmp = tok;
       tmp[0] = tmp[0].toUpper();
       viewClass += tmp;
     }
   }
 
   QString viewId;
   if (viewId.isEmpty())
   {
     viewId = "org.mitk.views.";
     foreach (QString tok, toks)
     {
       viewId += tok.toLower();
     }
   }
 
   bool quiet = parsedArgs.contains("quiet");
   bool autoConfirm = parsedArgs.contains("confirm-all");
 
   if (!outDir.endsWith('/'))
     outDir += '/';
   if (createProject)
     outDir += projectName;
   else
     outDir += pluginSymbolicName;
 
   // Print the collected information
   if (!quiet)
   {
     if (createProject)
     {
       out << "Using the following information to create a project:\n\n"
           << "  Project Name:        " << projectName << '\n'
           << "  Application Name:    " << projectAppName << '\n'
           << "  Copyright File:      " << QDir::toNativeSeparators(copyrightPath) << '\n';
     }
     else
     {
       out << "Using the following information to create a plug-in:\n\n";
     }
 
     out << "  License File:        " << QDir::toNativeSeparators(licensePath) << '\n'
         << "  Plugin-SymbolicName: " << pluginSymbolicName << '\n'
         << "  Plugin-Name:         " << pluginName << '\n'
         << "  Plugin-Vendor:       " << vendor << '\n'
         << "  View Name:           " << viewName << '\n'
         << "  View Id:             " << viewId << '\n'
         << "  View Class:          " << viewClass << '\n'
         << '\n'
         << "Create in: " << outDir << '\n'
         << '\n';
 
     if (!autoConfirm)
       out << "Continue [Y/n]? ";
 
     out.flush();
 
     if (!autoConfirm && !readAnswer('y'))
     {
       out << "Aborting.\n";
       return EXIT_SUCCESS;
     }
   }
 
   // Check the output directory
   if (!QDir(outDir).exists())
   {
     if (!autoConfirm)
     {
       out << "Directory '" << outDir << "' does not exist. Create it [Y/n]? ";
       out.flush();
     }
 
     if (autoConfirm || readAnswer('y'))
     {
       if (!QDir().mkpath(outDir))
       {
         qCritical() << "Could not create directory:" << outDir;
         return EXIT_FAILURE;
       }
     }
     else
     {
       out << "Aborting.\n";
       return EXIT_SUCCESS;
     }
   }
 
   if (!QDir(outDir).entryList(QDir::AllEntries | QDir::NoDotAndDotDot).isEmpty())
   {
     if (!autoConfirm)
     {
       out << "Directory '" << outDir << "' is not empty. Continue [y/N]? ";
       out.flush();
     }
 
     if (!autoConfirm && !readAnswer('n'))
     {
       out << "Aborting.\n";
       return EXIT_SUCCESS;
     }
   }
 
   // Extract the license text
   QFile licenseFile(licensePath);
   if (!licenseFile.open(QIODevice::ReadOnly))
   {
     qCritical() << "Cannot open file" << licenseFile.fileName();
     return EXIT_FAILURE;
   }
   QString licenseText = licenseFile.readAll();
   licenseFile.close();
 
   QHash<QString, QString> parameters;
   if (createProject)
   {
     // Extract the copyright
     QFile copyrightFile(copyrightPath);
     if (!copyrightFile.open(QIODevice::ReadOnly))
     {
       qCritical() << "Cannot open file" << copyrightFile.fileName();
       return EXIT_FAILURE;
     }
     QString copyrighText = copyrightFile.readAll();
     copyrightFile.close();
 
     parameters["$(copyright)"] = copyrighText;
     parameters["$(project-name)"] = projectName;
     parameters["$(project-app-name)"] = projectAppName;
     parameters["$(project-plugins)"] = QString("Plugins/") + pluginSymbolicName + ":ON";
 
     QStringList toks = pluginTarget.split("_");
     QString projectPluginBase = toks[0] + "_" + toks[1];
     parameters["$(project-plugin-base)"] = projectPluginBase;
   }
   parameters["$(license)"] = licenseText;
   parameters["$(plugin-name)"] = pluginName;
   parameters["$(plugin-symbolic-name)"] = pluginSymbolicName;
   parameters["$(vendor)"] = vendor;
   parameters["$(plugin-target)"] = pluginTarget;
   parameters["$(plugin-export-directive)"] = pluginExportDirective;
   parameters["$(view-id)"] = viewId;
   parameters["$(view-name)"] = viewName;
   parameters["$(view-file-name)"] = viewClass;
   parameters["$(view-class-name)"] = viewClass;
   parameters["$(activator-file-name)"] = activatorClass;
   parameters["$(activator-class-name)"] = activatorClass;
 
   if (createProject)
   {
     QHash<QString, QString> projectFileNameMapping;
     projectFileNameMapping["TemplateApp"] = projectAppName;
 
     QHash<QString, QString> filePathMapping =
       createTemplateFileMapping(":/ProjectTemplate", outDir, projectFileNameMapping);
     generateFiles(parameters, filePathMapping);
   }
 
   QHash<QString, QString> pluginFileNameMapping;
   pluginFileNameMapping["QmitkTemplateView"] = viewClass;
   pluginFileNameMapping["mitkPluginActivator"] = activatorClass;
 
   if (createProject)
   {
     if (!outDir.endsWith('/'))
       outDir += '/';
     outDir += "Plugins/" + pluginSymbolicName;
   }
   QHash<QString, QString> filePathMapping =
     createTemplateFileMapping(":/PluginTemplate", outDir, pluginFileNameMapping);
   generateFiles(parameters, filePathMapping);
 
   return EXIT_SUCCESS;
 }
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt b/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
index f7afae7f5f..162805f0d2 100644
--- a/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
+++ b/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
@@ -1,329 +1,325 @@
 cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
 
 # Change project and application name to your own
 set(MY_PROJECT_NAME $(project-name))
 set(MY_APP_NAME $(project-app-name))
 
 #-----------------------------------------------------------------------------
 # Set the language standard (MITK requires C++17)
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED 1)
 set(CMAKE_CXX_EXTENSIONS 0)
 
 #-----------------------------------------------------------------------------
 # 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 'Debug' as none was specified.")
   set(CMAKE_BUILD_TYPE Debug 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()
 
 #-----------------------------------------------------------------------------
 # Superbuild Option - Enabled by default
 #-----------------------------------------------------------------------------
 
 option(${MY_PROJECT_NAME}_USE_SUPERBUILD "Build ${MY_PROJECT_NAME} and the projects it depends on via SuperBuild.cmake." ON)
 
 if(${MY_PROJECT_NAME}_USE_SUPERBUILD)
   project(${MY_PROJECT_NAME}-superbuild)
   set(${MY_PROJECT_NAME}_SOURCE_DIR ${PROJECT_SOURCE_DIR})
   set(${MY_PROJECT_NAME}_BINARY_DIR ${PROJECT_BINARY_DIR})
 else()
   project(${MY_PROJECT_NAME})
 endif()
 
-#-----------------------------------------------------------------------------
-# See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
-#-----------------------------------------------------------------------------
-
 set(project_policies
   CMP0001 # NEW: CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
   CMP0002 # NEW: Logical target names must be globally unique.
   CMP0003 # NEW: Libraries linked via full path no longer produce linker search paths.
   CMP0004 # NEW: Libraries linked may NOT have leading or trailing whitespace.
   CMP0005 # NEW: Preprocessor definition values are now escaped automatically.
   CMP0006 # NEW: Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
   CMP0007 # NEW: List command no longer ignores empty elements.
   CMP0008 # NEW: Libraries linked by full-path must have a valid library file name.
   CMP0009 # NEW: FILE GLOB_RECURSE calls should not follow symlinks by default.
   CMP0010 # NEW: Bad variable reference syntax is an error.
   CMP0011 # NEW: Included scripts do automatic cmake_policy PUSH and POP.
   CMP0012 # NEW: if() recognizes numbers and boolean constants.
   CMP0013 # NEW: Duplicate binary directories are not allowed.
   CMP0014 # NEW: Input directories must have CMakeLists.txt
   CMP0020 # NEW: Automatically link Qt executables to qtmain target on Windows.
   CMP0028 # NEW: Double colon in target name means ALIAS or IMPORTED target.
   )
 foreach(policy ${project_policies})
   if(POLICY ${policy})
     cmake_policy(SET ${policy} NEW)
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #------------------------------------------------------------------------------
 
 set(CMAKE_MODULE_PATH
   ${${MY_PROJECT_NAME}_SOURCE_DIR}/CMake
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 include(CTest)
 include(MacroEmptyExternalProject)
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   set(output_dir ${${MY_PROJECT_NAME}_BINARY_DIR}/bin)
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${output_dir} CACHE INTERNAL "Single output directory for building all libraries.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Additional Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 option(BUILD_SHARED_LIBS "Build ${MY_PROJECT_NAME} with shared libraries" ON)
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 option(BUILD_TESTING "Test the project" ON)
 
 option(${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS "Build all ${MY_PROJECT_NAME} plugins" OFF)
 
 mark_as_advanced(${MY_PROJECT_NAME}_INSTALL_RPATH_RELATIVE
                  ${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS
                  )
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(${MY_PROJECT_NAME}_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
   return()
 endif()
 
 #*****************************************************************************
 #**************************** END OF SUPERBUILD ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # Prerequesites
 #-----------------------------------------------------------------------------
 
 set(${PROJECT_NAME}_MODULES_PACKAGE_DEPENDS_DIR "${PROJECT_SOURCE_DIR}/CMake/PackageDepends")
 set(MODULES_PACKAGE_DEPENDS_DIRS ${${PROJECT_NAME}_MODULES_PACKAGE_DEPENDS_DIR})
 
 find_package(MITK 2018.04.99 REQUIRED)
 
 if(COMMAND mitkFunctionCheckMitkCompatibility)
   mitkFunctionCheckMitkCompatibility(VERSIONS MITK_VERSION_PLUGIN_SYSTEM 1 REQUIRED)
 else()
   message(SEND_ERROR "Your MITK version is too old. Please use Git hash b86bf28 or newer")
 endif()
 
 link_directories(${MITK_LINK_DIRECTORIES})
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 set(CMAKE_MODULE_PATH
   ${MITK_SOURCE_DIR}/CMake
   ${CMAKE_MODULE_PATH}
   )
 
 include(mitkFunctionCheckCompilerFlags)
 include(mitkFunctionGetGccVersion)
 include(mitkFunctionGetVersion)
 
 #-----------------------------------------------------------------------------
 # Set project specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 set(${PROJECT_NAME}_VERSION_MAJOR "0")
 set(${PROJECT_NAME}_VERSION_MINOR "1")
 set(${PROJECT_NAME}_VERSION_PATCH "1")
 set(${PROJECT_NAME}_VERSION_STRING "${${PROJECT_NAME}_VERSION_MAJOR}.${${PROJECT_NAME}_VERSION_MINOR}.${${PROJECT_NAME}_VERSION_PATCH}")
 
 # Ask the user if a console window should be shown with the applications
 option(${PROJECT_NAME}_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting GUI Applications" ON)
 mark_as_advanced(${PROJECT_NAME}_SHOW_CONSOLE_WINDOW)
 
 if(NOT UNIX)
   set(MITK_WIN32_FORCE_STATIC "STATIC")
 endif()
 
 #-----------------------------------------------------------------------------
 # Get project version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${PROJECT_SOURCE_DIR} ${PROJECT_NAME})
 
 #-----------------------------------------------------------------------------
 # Installation preparation
 #
 # These should be set before any MITK install macros are used
 #-----------------------------------------------------------------------------
 
 # on macOS all CTK plugins get copied into every
 # application bundle (.app directory) specified here
 set(MACOSX_BUNDLE_NAMES)
 if(APPLE)
   list(APPEND MACOSX_BUNDLE_NAMES ${MY_APP_NAME})
 endif(APPLE)
 
 #-----------------------------------------------------------------------------
 # Set symbol visibility Flags
 #-----------------------------------------------------------------------------
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   # The MITK module build system does not yet support default hidden visibility
   set(VISIBILITY_CXX_FLAGS ) # "-fvisibility=hidden -fvisibility-inlines-hidden")
 endif()
 
 #-----------------------------------------------------------------------------
 # Set coverage Flags
 #-----------------------------------------------------------------------------
 
 if(WITH_COVERAGE)
   if(CMAKE_COMPILER_IS_GNUCXX)
     set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG")
     set(COVERAGE_CXX_FLAGS ${coverage_flags})
     set(COVERAGE_C_FLAGS ${coverage_flags})
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Project C/CXX Flags
 #-----------------------------------------------------------------------------
 
 set(${PROJECT_NAME}_C_FLAGS "${MITK_C_FLAGS} ${COVERAGE_C_FLAGS}")
 set(${PROJECT_NAME}_C_FLAGS_DEBUG ${MITK_C_FLAGS_DEBUG})
 set(${PROJECT_NAME}_C_FLAGS_RELEASE ${MITK_C_FLAGS_RELEASE})
 set(${PROJECT_NAME}_CXX_FLAGS "${MITK_CXX_FLAGS} ${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS}")
 set(${PROJECT_NAME}_CXX_FLAGS_DEBUG ${MITK_CXX_FLAGS_DEBUG})
 set(${PROJECT_NAME}_CXX_FLAGS_RELEASE ${MITK_CXX_FLAGS_RELEASE})
 
 set(${PROJECT_NAME}_EXE_LINKER_FLAGS ${MITK_EXE_LINKER_FLAGS})
 set(${PROJECT_NAME}_SHARED_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
 set(${PROJECT_NAME}_MODULE_LINKER_FLAGS ${MITK_MODULE_LINKER_FLAGS})
 
 #-----------------------------------------------------------------------------
 # Set C/CXX Flags
 #-----------------------------------------------------------------------------
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${${PROJECT_NAME}_C_FLAGS}")
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${${PROJECT_NAME}_C_FLAGS_DEBUG}")
 set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${${PROJECT_NAME}_C_FLAGS_RELEASE}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${${PROJECT_NAME}_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${${PROJECT_NAME}_CXX_FLAGS_DEBUG}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${${PROJECT_NAME}_CXX_FLAGS_RELEASE}")
 
 set(CMAKE_EXE_LINKER_FLAGS ${${PROJECT_NAME}_EXE_LINKER_FLAGS})
 set(CMAKE_SHARED_LINKER_FLAGS ${${PROJECT_NAME}_SHARED_LINKER_FLAGS})
 set(CMAKE_MODULE_LINKER_FLAGS ${${PROJECT_NAME}_MODULE_LINKER_FLAGS})
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   # Configuration for the CMake-generated test driver
   set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include <stdexcept>")
   set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "
     try
       {")
   set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "
       }
       catch (const std::exception& e)
       {
         fprintf(stderr, \"%s\\n\", e.what());
         return EXIT_FAILURE;
       }
       catch (...)
       {
         printf(\"Exception caught in the test driver\\n\");
         return EXIT_FAILURE;
       }")
 endif()
 
 #-----------------------------------------------------------------------------
 # ${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR
 #-----------------------------------------------------------------------------
 
 # If ${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR isn't defined, it means this project is
 # *NOT* build using Superbuild. In that specific case, ${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR
 # should default to PROJECT_BINARY_DIR
 if(NOT DEFINED ${PROJECT_NAME}_SUPERBUILD_BINARY_DIR)
   set(${PROJECT_NAME}_SUPERBUILD_BINARY_DIR ${PROJECT_BINARY_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK modules
 #-----------------------------------------------------------------------------
 
 #add_subdirectory(Modules)
 
 #-----------------------------------------------------------------------------
 # CTK plugins
 #-----------------------------------------------------------------------------
 
 # The CMake code in this section *must* be in the top-level CMakeLists.txt file
 
 macro(GetMyTargetLibraries all_target_libraries varname)
   set(re_ctkplugin "^$(project-plugin-base)_[a-zA-Z0-9_]+$")
   set(_tmp_list)
   list(APPEND _tmp_list ${all_target_libraries})
   ctkMacroListFilter(_tmp_list re_ctkplugin OUTPUT_VARIABLE ${varname})
 endmacro()
 
 include(${CMAKE_CURRENT_SOURCE_DIR}/Plugins/Plugins.cmake)
 ctkMacroSetupPlugins(${PROJECT_PLUGINS}
                      BUILD_OPTION_PREFIX ${MY_PROJECT_NAME}_
                      BUILD_ALL ${${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS})
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Apps/$(project-app-name))
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 # set MITK cpack variables
 include(mitkSetupCPack)
 
 # Customize CPack variables for this project
 include(CPackSetup)
 
 list(APPEND CPACK_CREATE_DESKTOP_LINKS "${MY_APP_NAME}")
 
 configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
                ${PROJECT_BINARY_DIR}/${PROJECT_NAME}CPackOptions.cmake @ONLY)
 set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}CPackOptions.cmake")
 
 # include CPack model once all variables are set
 include(CPack)
 
 # Additional installation rules
 include(mitkInstallRules)
 
 #-----------------------------------------------------------------------------
 # Last configuration steps
 #-----------------------------------------------------------------------------
diff --git a/Applications/PluginGenerator/ctkCommandLineParser.cpp b/Applications/PluginGenerator/ctkCommandLineParser.cpp
index d8214ea76d..52d3c45068 100644
--- a/Applications/PluginGenerator/ctkCommandLineParser.cpp
+++ b/Applications/PluginGenerator/ctkCommandLineParser.cpp
@@ -1,874 +1,874 @@
 /*=========================================================================
 
   Library:   CTK
 
   Copyright (c) Kitware Inc.
 
   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
+      https://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.
 
 =========================================================================*/
 
 // STL includes
 #include <stdexcept>
 
 // Qt includes
 #include <QDebug>
 #include <QHash>
 #include <QPointer>
 #include <QSettings>
 #include <QStringList>
 #include <QTextStream>
 
 // CTK includes
 #include "ctkCommandLineParser.h"
 
 namespace
 {
   // --------------------------------------------------------------------------
   class CommandLineParserArgumentDescription
   {
   public:
     CommandLineParserArgumentDescription(const QString &longArg,
                                          const QString &longArgPrefix,
                                          const QString &shortArg,
                                          const QString &shortArgPrefix,
                                          QVariant::Type type,
                                          const QString &argHelp,
                                          const QVariant &defaultValue,
                                          bool ignoreRest,
                                          bool deprecated)
       : LongArg(longArg),
         LongArgPrefix(longArgPrefix),
         ShortArg(shortArg),
         ShortArgPrefix(shortArgPrefix),
         ArgHelp(argHelp),
         IgnoreRest(ignoreRest),
         NumberOfParametersToProcess(0),
         Deprecated(deprecated),
         DefaultValue(defaultValue),
         Value(type),
         ValueType(type)
     {
       if (defaultValue.isValid())
       {
         Value = defaultValue;
       }
 
       switch (type)
       {
         case QVariant::String:
         {
           NumberOfParametersToProcess = 1;
           RegularExpression = ".*";
         }
         break;
         case QVariant::Bool:
         {
           NumberOfParametersToProcess = 0;
           RegularExpression = "";
         }
         break;
         case QVariant::StringList:
         {
           NumberOfParametersToProcess = -1;
           RegularExpression = ".*";
         }
         break;
         case QVariant::Int:
         {
           NumberOfParametersToProcess = 1;
           RegularExpression = "-?[0-9]+";
           ExactMatchFailedMessage = "A negative or positive integer is expected.";
         }
         break;
         default:
           ExactMatchFailedMessage = QString("Type %1 not supported.").arg(static_cast<int>(type));
       }
     }
 
     ~CommandLineParserArgumentDescription() {}
     bool addParameter(const QString &value);
 
     QString helpText(int fieldWidth, const char charPad, const QString &settingsValue = "");
 
     QString LongArg;
     QString LongArgPrefix;
     QString ShortArg;
     QString ShortArgPrefix;
     QString ArgHelp;
     bool IgnoreRest;
     int NumberOfParametersToProcess;
     QString RegularExpression;
     QString ExactMatchFailedMessage;
     bool Deprecated;
 
     QVariant DefaultValue;
     QVariant Value;
     QVariant::Type ValueType;
   };
 
   // --------------------------------------------------------------------------
   bool CommandLineParserArgumentDescription::addParameter(const QString &value)
   {
     if (!RegularExpression.isEmpty())
     {
       // Validate value
       QRegExp regexp(this->RegularExpression);
       if (!regexp.exactMatch(value))
       {
         return false;
       }
     }
 
     switch (Value.type())
     {
       case QVariant::String:
       {
         Value.setValue(value);
       }
       break;
       case QVariant::Bool:
       {
         Value.setValue(!QString::compare(value, "true", Qt::CaseInsensitive));
       }
       break;
       case QVariant::StringList:
       {
         if (Value.isNull())
         {
           QStringList list;
           list << value;
           Value.setValue(list);
         }
         else
         {
           QStringList list = Value.toStringList();
           list << value;
           Value.setValue(list);
         }
       }
       break;
       case QVariant::Int:
       {
         Value.setValue(value.toInt());
       }
       break;
       default:
         return false;
     }
 
     return true;
   }
 
   // --------------------------------------------------------------------------
   QString CommandLineParserArgumentDescription::helpText(int fieldWidth,
                                                          const char charPad,
                                                          const QString &settingsValue)
   {
     QString text;
     QTextStream stream(&text);
     stream.setFieldAlignment(QTextStream::AlignLeft);
     stream.setPadChar(charPad);
 
     QString shortAndLongArg;
     if (!this->ShortArg.isEmpty())
     {
       shortAndLongArg += QString("  %1%2").arg(this->ShortArgPrefix).arg(this->ShortArg);
     }
 
     if (!this->LongArg.isEmpty())
     {
       if (this->ShortArg.isEmpty())
       {
         shortAndLongArg.append("  ");
       }
       else
       {
         shortAndLongArg.append(", ");
       }
 
       shortAndLongArg += QString("%1%2").arg(this->LongArgPrefix).arg(this->LongArg);
     }
 
     if (!this->ArgHelp.isEmpty())
     {
       stream.setFieldWidth(fieldWidth);
     }
 
     stream << shortAndLongArg;
     stream.setFieldWidth(0);
     stream << this->ArgHelp;
     if (!settingsValue.isNull())
     {
       stream << " (default: " << settingsValue << ")";
     }
     else if (!this->DefaultValue.isNull())
     {
       stream << " (default: " << this->DefaultValue.toString() << ")";
     }
     stream << "\n";
     return text;
   }
 }
 
 // --------------------------------------------------------------------------
 // ctkCommandLineParser::ctkInternal class
 
 // --------------------------------------------------------------------------
 class ctkCommandLineParser::ctkInternal
 {
 public:
   ctkInternal(QSettings *settings)
     : Debug(false), FieldWidth(0), UseQSettings(false), Settings(settings), MergeSettings(true), StrictMode(false)
   {
   }
 
   ~ctkInternal() { qDeleteAll(ArgumentDescriptionList); }
   CommandLineParserArgumentDescription *argumentDescription(const QString &argument);
 
   QList<CommandLineParserArgumentDescription *> ArgumentDescriptionList;
   QHash<QString, CommandLineParserArgumentDescription *> ArgNameToArgumentDescriptionMap;
   QMap<QString, QList<CommandLineParserArgumentDescription *>> GroupToArgumentDescriptionListMap;
 
   QStringList UnparsedArguments;
   QStringList ProcessedArguments;
   QString ErrorString;
   bool Debug;
   int FieldWidth;
   QString LongPrefix;
   QString ShortPrefix;
   QString CurrentGroup;
   bool UseQSettings;
   QPointer<QSettings> Settings;
   QString DisableQSettingsLongArg;
   QString DisableQSettingsShortArg;
   bool MergeSettings;
   bool StrictMode;
 };
 
 // --------------------------------------------------------------------------
 // ctkCommandLineParser::ctkInternal methods
 
 // --------------------------------------------------------------------------
 CommandLineParserArgumentDescription *ctkCommandLineParser::ctkInternal::argumentDescription(const QString &argument)
 {
   QString unprefixedArg = argument;
   if (!LongPrefix.isEmpty() && argument.startsWith(LongPrefix))
   {
     // Case when (ShortPrefix + UnPrefixedArgument) matches LongPrefix
     if (argument == LongPrefix && !ShortPrefix.isEmpty() && argument.startsWith(ShortPrefix))
     {
       unprefixedArg = argument.mid(ShortPrefix.length());
     }
     else
     {
       unprefixedArg = argument.mid(LongPrefix.length());
     }
   }
   else if (!ShortPrefix.isEmpty() && argument.startsWith(ShortPrefix))
   {
     unprefixedArg = argument.mid(ShortPrefix.length());
   }
   else if (!LongPrefix.isEmpty() && !ShortPrefix.isEmpty())
   {
     return nullptr;
   }
 
   if (this->ArgNameToArgumentDescriptionMap.contains(unprefixedArg))
   {
     return this->ArgNameToArgumentDescriptionMap[unprefixedArg];
   }
   return nullptr;
 }
 
 // --------------------------------------------------------------------------
 // ctkCommandLineParser methods
 
 // --------------------------------------------------------------------------
 ctkCommandLineParser::ctkCommandLineParser(QObject *newParent) : Superclass(newParent)
 {
   this->Internal = new ctkInternal(nullptr);
 }
 
 // --------------------------------------------------------------------------
 ctkCommandLineParser::ctkCommandLineParser(QSettings *settings, QObject *newParent) : Superclass(newParent)
 {
   this->Internal = new ctkInternal(settings);
 }
 
 // --------------------------------------------------------------------------
 ctkCommandLineParser::~ctkCommandLineParser()
 {
   delete this->Internal;
 }
 
 // --------------------------------------------------------------------------
 QHash<QString, QVariant> ctkCommandLineParser::parseArguments(const QStringList &arguments, bool *ok)
 {
   // Reset
   this->Internal->UnparsedArguments.clear();
   this->Internal->ProcessedArguments.clear();
   this->Internal->ErrorString.clear();
   foreach (CommandLineParserArgumentDescription *desc, this->Internal->ArgumentDescriptionList)
   {
     desc->Value = QVariant(desc->ValueType);
     if (desc->DefaultValue.isValid())
     {
       desc->Value = desc->DefaultValue;
     }
   }
 
   bool error = false;
   bool ignoreRest = false;
   bool useSettings = this->Internal->UseQSettings;
   CommandLineParserArgumentDescription *currentArgDesc = nullptr;
   QList<CommandLineParserArgumentDescription *> parsedArgDescriptions;
   for (int i = 1; i < arguments.size(); ++i)
   {
     QString argument = arguments.at(i);
     if (this->Internal->Debug)
     {
       qDebug() << "Processing" << argument;
     }
 
     // should argument be ignored ?
     if (ignoreRest)
     {
       if (this->Internal->Debug)
       {
         qDebug() << "  Skipping: IgnoreRest flag was been set";
       }
       this->Internal->UnparsedArguments << argument;
       continue;
     }
 
     // Skip if the argument does not start with the defined prefix
     if (!(argument.startsWith(this->Internal->LongPrefix) || argument.startsWith(this->Internal->ShortPrefix)))
     {
       if (this->Internal->StrictMode)
       {
         this->Internal->ErrorString = QString("Unknown argument %1").arg(argument);
         error = true;
         break;
       }
       if (this->Internal->Debug)
       {
         qDebug() << "  Skipping: It does not start with the defined prefix";
       }
       this->Internal->UnparsedArguments << argument;
       continue;
     }
 
     // Skip if argument has already been parsed ...
     if (this->Internal->ProcessedArguments.contains(argument))
     {
       if (this->Internal->StrictMode)
       {
         this->Internal->ErrorString = QString("Argument %1 already processed !").arg(argument);
         error = true;
         break;
       }
       if (this->Internal->Debug)
       {
         qDebug() << "  Skipping: Already processed !";
       }
       continue;
     }
 
     // Retrieve corresponding argument description
     currentArgDesc = this->Internal->argumentDescription(argument);
 
     // Is there a corresponding argument description ?
     if (currentArgDesc)
     {
       // If the argument is deprecated, print the help text but continue processing
       if (currentArgDesc->Deprecated)
       {
         qWarning().nospace() << "Deprecated argument " << argument << ": " << currentArgDesc->ArgHelp;
       }
       else
       {
         parsedArgDescriptions.push_back(currentArgDesc);
       }
 
       // Is the argument the special "disable QSettings" argument?
       if ((!currentArgDesc->LongArg.isEmpty() && currentArgDesc->LongArg == this->Internal->DisableQSettingsLongArg) ||
           (!currentArgDesc->ShortArg.isEmpty() && currentArgDesc->ShortArg == this->Internal->DisableQSettingsShortArg))
       {
         useSettings = false;
       }
 
       this->Internal->ProcessedArguments << currentArgDesc->ShortArg << currentArgDesc->LongArg;
       int numberOfParametersToProcess = currentArgDesc->NumberOfParametersToProcess;
       ignoreRest = currentArgDesc->IgnoreRest;
       if (this->Internal->Debug && ignoreRest)
       {
         qDebug() << "  IgnoreRest flag is True";
       }
 
       // Is the number of parameters associated with the argument being processed known ?
       if (numberOfParametersToProcess == 0)
       {
         currentArgDesc->addParameter("true");
       }
       else if (numberOfParametersToProcess > 0)
       {
         QString missingParameterError = "Argument %1 has %2 value(s) associated whereas exacly %3 are expected.";
         for (int j = 1; j <= numberOfParametersToProcess; ++j)
         {
           if (i + j >= arguments.size())
           {
             this->Internal->ErrorString =
               missingParameterError.arg(argument).arg(j - 1).arg(numberOfParametersToProcess);
             if (this->Internal->Debug)
             {
               qDebug() << this->Internal->ErrorString;
             }
             if (ok)
             {
               *ok = false;
             }
             return QHash<QString, QVariant>();
           }
           QString parameter = arguments.at(i + j);
           if (this->Internal->Debug)
           {
             qDebug() << "  Processing parameter" << j << ", value:" << parameter;
           }
           if (this->argumentAdded(parameter))
           {
             this->Internal->ErrorString =
               missingParameterError.arg(argument).arg(j - 1).arg(numberOfParametersToProcess);
             if (this->Internal->Debug)
             {
               qDebug() << this->Internal->ErrorString;
             }
             if (ok)
             {
               *ok = false;
             }
             return QHash<QString, QVariant>();
           }
           if (!currentArgDesc->addParameter(parameter))
           {
             this->Internal->ErrorString = QString("Value(s) associated with argument %1 are incorrect. %2")
                                             .arg(argument)
                                             .arg(currentArgDesc->ExactMatchFailedMessage);
 
             if (this->Internal->Debug)
             {
               qDebug() << this->Internal->ErrorString;
             }
             if (ok)
             {
               *ok = false;
             }
             return QHash<QString, QVariant>();
           }
         }
         // Update main loop increment
         i = i + numberOfParametersToProcess;
       }
       else if (numberOfParametersToProcess == -1)
       {
         if (this->Internal->Debug)
         {
           qDebug() << "  Proccessing StringList ...";
         }
         int j = 1;
         while (j + i < arguments.size())
         {
           if (this->argumentAdded(arguments.at(j + i)))
           {
             if (this->Internal->Debug)
             {
               qDebug() << "  No more parameter for" << argument;
             }
             break;
           }
           QString parameter = arguments.at(j + i);
           if (this->Internal->Debug)
           {
             qDebug() << "  Processing parameter" << j << ", value:" << parameter;
           }
           if (!currentArgDesc->addParameter(parameter))
           {
             this->Internal->ErrorString = QString("Value(s) associated with argument %1 are incorrect. %2")
                                             .arg(argument)
                                             .arg(currentArgDesc->ExactMatchFailedMessage);
 
             if (this->Internal->Debug)
             {
               qDebug() << this->Internal->ErrorString;
             }
             if (ok)
             {
               *ok = false;
             }
             return QHash<QString, QVariant>();
           }
           j++;
         }
         // Update main loop increment
         i = i + j;
       }
     }
     else
     {
       if (this->Internal->StrictMode)
       {
         this->Internal->ErrorString = QString("Unknown argument %1").arg(argument);
         error = true;
         break;
       }
       if (this->Internal->Debug)
       {
         qDebug() << "  Skipping: Unknown argument";
       }
       this->Internal->UnparsedArguments << argument;
     }
   }
 
   if (ok)
   {
     *ok = !error;
   }
 
   QSettings *settings = nullptr;
   if (this->Internal->UseQSettings && useSettings)
   {
     if (this->Internal->Settings)
     {
       settings = this->Internal->Settings;
     }
     else
     {
       // Use a default constructed QSettings instance
       settings = new QSettings();
     }
   }
 
   QHash<QString, QVariant> parsedArguments;
   QListIterator<CommandLineParserArgumentDescription *> it(this->Internal->ArgumentDescriptionList);
   while (it.hasNext())
   {
     QString key;
     CommandLineParserArgumentDescription *desc = it.next();
     if (!desc->LongArg.isEmpty())
     {
       key = desc->LongArg;
     }
     else
     {
       key = desc->ShortArg;
     }
 
     if (parsedArgDescriptions.contains(desc))
     {
       // The argument was supplied on the command line, so use the given value
 
       if (this->Internal->MergeSettings && settings)
       {
         // Merge with QSettings
         QVariant settingsVal = settings->value(key);
 
         if (desc->ValueType == QVariant::StringList && settingsVal.canConvert(QVariant::StringList))
         {
           QStringList stringList = desc->Value.toStringList();
           stringList.append(settingsVal.toStringList());
           parsedArguments.insert(key, stringList);
         }
         else
         {
           // do a normal insert
           parsedArguments.insert(key, desc->Value);
         }
       }
       else
       {
         // No merging, just insert all user values
         parsedArguments.insert(key, desc->Value);
       }
     }
     else
     {
       if (settings)
       {
         // If there is a valid QSettings entry for the argument, use the value
         QVariant settingsVal = settings->value(key, desc->Value);
         if (!settingsVal.isNull())
         {
           parsedArguments.insert(key, settingsVal);
         }
       }
       else
       {
         // Just insert the arguments with valid default values
         if (!desc->Value.isNull())
         {
           parsedArguments.insert(key, desc->Value);
         }
       }
     }
   }
 
   // If we created a default QSettings instance, delete it
   if (settings && !this->Internal->Settings)
   {
     delete settings;
   }
 
   return parsedArguments;
 }
 
 // -------------------------------------------------------------------------
 QHash<QString, QVariant> ctkCommandLineParser::parseArguments(int argc, char **argv, bool *ok)
 {
   QStringList arguments;
 
   // Create a QStringList of arguments
   for (int i = 0; i < argc; ++i)
   {
     arguments << argv[i];
   }
 
   return this->parseArguments(arguments, ok);
 }
 
 // -------------------------------------------------------------------------
 QString ctkCommandLineParser::errorString() const
 {
   return this->Internal->ErrorString;
 }
 
 // -------------------------------------------------------------------------
 const QStringList &ctkCommandLineParser::unparsedArguments() const
 {
   return this->Internal->UnparsedArguments;
 }
 
 // --------------------------------------------------------------------------
 void ctkCommandLineParser::addArgument(const QString &longarg,
                                        const QString &shortarg,
                                        QVariant::Type type,
                                        const QString &argHelp,
                                        const QVariant &defaultValue,
                                        bool ignoreRest,
                                        bool deprecated)
 {
   Q_ASSERT_X(!(longarg.isEmpty() && shortarg.isEmpty()), "addArgument", "both long and short argument names are empty");
   if (longarg.isEmpty() && shortarg.isEmpty())
   {
     return;
   }
 
   Q_ASSERT_X(!defaultValue.isValid() || defaultValue.type() == type, "addArgument", "defaultValue type does not match");
   if (defaultValue.isValid() && defaultValue.type() != type)
     throw std::logic_error("The QVariant type of defaultValue does not match the specified type");
 
   /* Make sure it's not already added */
   bool added = this->Internal->ArgNameToArgumentDescriptionMap.contains(longarg);
   Q_ASSERT_X(!added, "addArgument", "long argument already added");
   if (added)
   {
     return;
   }
 
   added = this->Internal->ArgNameToArgumentDescriptionMap.contains(shortarg);
   Q_ASSERT_X(!added, "addArgument", "short argument already added");
   if (added)
   {
     return;
   }
 
   auto argDesc = new CommandLineParserArgumentDescription(longarg,
                                                           this->Internal->LongPrefix,
                                                           shortarg,
                                                           this->Internal->ShortPrefix,
                                                           type,
                                                           argHelp,
                                                           defaultValue,
                                                           ignoreRest,
                                                           deprecated);
 
   int argWidth = 0;
   if (!longarg.isEmpty())
   {
     this->Internal->ArgNameToArgumentDescriptionMap[longarg] = argDesc;
     argWidth += longarg.length() + this->Internal->LongPrefix.length();
   }
   if (!shortarg.isEmpty())
   {
     this->Internal->ArgNameToArgumentDescriptionMap[shortarg] = argDesc;
     argWidth += shortarg.length() + this->Internal->ShortPrefix.length() + 2;
   }
   argWidth += 5;
 
   // Set the field width for the arguments
   if (argWidth > this->Internal->FieldWidth)
   {
     this->Internal->FieldWidth = argWidth;
   }
 
   this->Internal->ArgumentDescriptionList << argDesc;
   this->Internal->GroupToArgumentDescriptionListMap[this->Internal->CurrentGroup] << argDesc;
 }
 
 // --------------------------------------------------------------------------
 void ctkCommandLineParser::addDeprecatedArgument(const QString &longarg,
                                                  const QString &shortarg,
                                                  const QString &argHelp)
 {
   addArgument(longarg, shortarg, QVariant::StringList, argHelp, QVariant(), false, true);
 }
 
 // --------------------------------------------------------------------------
 bool ctkCommandLineParser::setExactMatchRegularExpression(const QString &argument,
                                                           const QString &expression,
                                                           const QString &exactMatchFailedMessage)
 {
   CommandLineParserArgumentDescription *argDesc = this->Internal->argumentDescription(argument);
   if (!argDesc)
   {
     return false;
   }
 
   if (argDesc->Value.type() == QVariant::Bool)
   {
     return false;
   }
   argDesc->RegularExpression = expression;
   argDesc->ExactMatchFailedMessage = exactMatchFailedMessage;
   return true;
 }
 
 // --------------------------------------------------------------------------
 int ctkCommandLineParser::fieldWidth() const
 {
   return this->Internal->FieldWidth;
 }
 
 // --------------------------------------------------------------------------
 void ctkCommandLineParser::beginGroup(const QString &description)
 {
   this->Internal->CurrentGroup = description;
 }
 
 // --------------------------------------------------------------------------
 void ctkCommandLineParser::endGroup()
 {
   this->Internal->CurrentGroup.clear();
 }
 
 // --------------------------------------------------------------------------
 void ctkCommandLineParser::enableSettings(const QString &disableLongArg, const QString &disableShortArg)
 {
   this->Internal->UseQSettings = true;
   this->Internal->DisableQSettingsLongArg = disableLongArg;
   this->Internal->DisableQSettingsShortArg = disableShortArg;
 }
 
 // --------------------------------------------------------------------------
 void ctkCommandLineParser::mergeSettings(bool merge)
 {
   this->Internal->MergeSettings = merge;
 }
 
 // --------------------------------------------------------------------------
 bool ctkCommandLineParser::settingsEnabled() const
 {
   return this->Internal->UseQSettings;
 }
 
 // --------------------------------------------------------------------------
 QString ctkCommandLineParser::helpText(const char charPad) const
 {
   QString text;
   QTextStream stream(&text);
 
   QList<CommandLineParserArgumentDescription *> deprecatedArgs;
 
   // Loop over grouped argument descriptions
   QMapIterator<QString, QList<CommandLineParserArgumentDescription *>> it(
     this->Internal->GroupToArgumentDescriptionListMap);
   while (it.hasNext())
   {
     it.next();
     if (!it.key().isEmpty())
     {
       stream << "\n" << it.key() << "\n";
     }
     foreach (CommandLineParserArgumentDescription *argDesc, it.value())
     {
       if (argDesc->Deprecated)
       {
         deprecatedArgs << argDesc;
       }
       else
       {
         // Extract associated value from settings if any
         QString settingsValue;
         if (this->Internal->Settings)
         {
           QString key;
           if (!argDesc->LongArg.isEmpty())
           {
             key = argDesc->LongArg;
           }
           else
           {
             key = argDesc->ShortArg;
           }
           settingsValue = this->Internal->Settings->value(key).toString();
         }
         stream << argDesc->helpText(this->Internal->FieldWidth, charPad, settingsValue);
       }
     }
   }
 
   if (!deprecatedArgs.empty())
   {
     stream << "\nDeprecated arguments:\n";
     foreach (CommandLineParserArgumentDescription *argDesc, deprecatedArgs)
     {
       stream << argDesc->helpText(this->Internal->FieldWidth, charPad);
     }
   }
 
   return text;
 }
 
 // --------------------------------------------------------------------------
 bool ctkCommandLineParser::argumentAdded(const QString &argument) const
 {
   return this->Internal->ArgNameToArgumentDescriptionMap.contains(argument);
 }
 
 // --------------------------------------------------------------------------
 bool ctkCommandLineParser::argumentParsed(const QString &argument) const
 {
   return this->Internal->ProcessedArguments.contains(argument);
 }
 
 // --------------------------------------------------------------------------
 void ctkCommandLineParser::setArgumentPrefix(const QString &longPrefix, const QString &shortPrefix)
 {
   this->Internal->LongPrefix = longPrefix;
   this->Internal->ShortPrefix = shortPrefix;
 }
 
 // --------------------------------------------------------------------------
 void ctkCommandLineParser::setStrictModeEnabled(bool strictMode)
 {
   this->Internal->StrictMode = strictMode;
 }
diff --git a/Applications/PluginGenerator/ctkCommandLineParser.h b/Applications/PluginGenerator/ctkCommandLineParser.h
index daee3816fe..da1de78e8f 100644
--- a/Applications/PluginGenerator/ctkCommandLineParser.h
+++ b/Applications/PluginGenerator/ctkCommandLineParser.h
@@ -1,418 +1,418 @@
 /*=========================================================================
 
   Library:   CTK
 
   Copyright (c) Kitware Inc.
 
   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
+      https://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 __ctkCommandLineParser_h
 #define __ctkCommandLineParser_h
 
 // Qt includes
 #include <QString>
 #include <QStringList>
 #include <QVariant>
 
 class QSettings;
 
 /**
  * \ingroup Core
  *
  * The CTK command line parser.
  *
  * Use this class to add information about the command line arguments
  * your program understands and to easily parse them from a given list
  * of strings.
  *
  * This parser provides the following features:
  *
  * <ul>
  * <li>Add arguments by supplying a long name and/or a short name.
  *     Arguments are validated using a regular expression. They can have
  *     a default value and a help string.</li>
  * <li>Deprecated arguments.</li>
  * <li>Custom regular expressions for argument validation.</li>
  * <li>Set different argument name prefixes for native platform look and feel.</li>
  * <li>QSettings support. Default values for arguments can be read from
  *     a QSettings object.</li>
  * <li>Create a help text for the command line arguments with support for
  *     grouping arguments.</li>
  * </ul>
  *
  * Here is an example how to use this class inside a main function:
  *
  * \code
  * #include <ctkCommandLineParser.h>
  * #include <QCoreApplication>
  * #include <QTextStream>
  *
  * int main(int argc, char** argv)
  * {
  *   QCoreApplication app(argc, argv);
  *   // This is used by QSettings
  *   QCoreApplication::setOrganizationName("MyOrg");
  *   QCoreApplication::setApplicationName("MyApp");
  *
  *   ctkCommandLineParser parser;
  *   // Use Unix-style argument names
  *   parser.setArgumentPrefix("--", "-");
  *   // Enable QSettings support
  *   parser.enableSettings("disable-settings");
  *
  *   // Add command line argument names
  *   parser.addArgument("disable-settings", "", QVariant::Bool, "Do not use QSettings");
  *   parser.addArgument("help", "h", QVariant::Bool, "Show this help text");
  *   parser.addArgument("search-paths", "s", QVariant::StringList, "A list of paths to search");
  *
  *   // Parse the command line arguments
  *   bool ok = false;
  *   QHash<QString, QVariant> parsedArgs = parser.parseArguments(QCoreApplication::arguments(), &ok);
  *   if (!ok)
  *   {
  *     QTextStream(stderr, QIODevice::WriteOnly) << "Error parsing arguments: "
  *                                               << parser.errorString() << "\n";
  *     return EXIT_FAILURE;
  *   }
  *
  *   // Show a help message
  *   if (parsedArgs.contains("help") || parsedArgs.contains("h"))
  *   {
  *     QTextStream(stdout, QIODevice::WriteOnly) << parser.helpText();
  *     return EXIT_SUCCESS;
  *   }
  *
  *   // Do something
  *
  *   return EXIT_SUCCESS;
  * }
  * \endcode
  */
 class ctkCommandLineParser : public QObject
 {
   Q_OBJECT
   Q_PROPERTY(QString errorString READ errorString)
   Q_PROPERTY(QStringList unparsedArguments READ unparsedArguments)
   Q_PROPERTY(bool settingsEnabled READ settingsEnabled)
 
 public:
   typedef QObject Superclass;
 
   /**
    * Constructs a parser instance.
    *
    * If QSettings support is enabled by a call to <code>enableSettings()</code>
    * a default constructed QSettings instance will be used when parsing
    * the command line arguments. Make sure to call <code>QCoreApplication::setOrganizationName()</code>
    * and <code>QCoreApplication::setApplicationName()</code> before using default
    * constructed QSettings objects.
    *
    * @param newParent The QObject parent.
    */
   ctkCommandLineParser(QObject *newParent = nullptr);
 
   /**
    * Constructs a parser instance.
    *
    * If QSettings support is enabled by a call to <code>enableSettings()</code>
    * the provided QSettings instance will be used. If the QSettings instance is
    * zero, a default constructed QSettings instance will be used when parsing
    * the command line arguments. Using a default constructed instance is usually
    * what you want, if you have called <code>QCoreApplication::setOrganizationName()</code>
    * and <code>QCoreApplication::setApplicationName()</code>.
    *
    * @param settings A QSettings instance which should be used.
    * @param newParent The QObject parent.
    *
    *
    */
   ctkCommandLineParser(QSettings *settings, QObject *newParent = nullptr);
 
   ~ctkCommandLineParser() override;
 
   /**
    * Parse a given list of command line arguments.
    *
    * This method parses a list of QString elements considering the known arguments
    * added by calls to <code>addArgument()</code>. If any one of the argument
    * values does not match the corresponding regular expression,
    * <code>ok</code> is set to false and an empty QHash object is returned.
    *
    * The keys in the returned QHash object correspond to the long argument string,
    * if it is not empty. Otherwise, the short argument string is used as key. The
    * QVariant values can safely be converted to the type specified in the
    * <code>addArgument()</code> method call.
    *
    * @param arguments A QStringList containing command line arguments. Usually
    *        given by <code>QCoreApplication::arguments()</code>.
    * @param ok A pointer to a boolean variable. Will be set to <code>true</code>
    *        if all regular expressions matched, <code>false</code> otherwise.
    * @return A QHash object mapping the long argument (if empty, the short one)
    *         to a QVariant containing the value.
    */
   QHash<QString, QVariant> parseArguments(const QStringList &arguments, bool *ok = nullptr);
 
   /**
     * Convenient method allowing to parse a given list of command line arguments.
     * @see parseArguments(const QStringList &, bool*)
     */
   QHash<QString, QVariant> parseArguments(int argc, char **argv, bool *ok = nullptr);
 
   /**
    * Returns a detailed error description if a call to <code>parseArguments()</code>
    * failed.
    *
    * @return The error description, empty if no error occured.
    * @see parseArguments(const QStringList&, bool*)
    */
   QString errorString() const;
 
   /**
    * This method returns all unparsed arguments, i.e. all arguments
    * for which no long or short name has been registered via a call
    * to <code>addArgument()</code>.
    *
    * @see addArgument()
    *
    * @return A list containing unparsed arguments.
    */
   const QStringList &unparsedArguments() const;
 
   /**
    * Checks if the given argument has been added via a call
    * to <code>addArgument()</code>.
    *
    * @see addArgument()
    *
    * @param argument The argument to be checked.
    * @return <code>true</code> if the argument was added, <code>false</code>
    *         otherwise.
    */
   Q_INVOKABLE bool argumentAdded(const QString &argument) const;
 
   /**
    * Checks if the given argument has been parsed successfully by a previous
    * call to <code>parseArguments()</code>.
    *
    * @param argument The argument to be checked.
    * @return <code>true</code> if the argument was parsed, <code>false</code>
    *         otherwise.
    */
   Q_INVOKABLE bool argumentParsed(const QString &argument) const;
 
   /**
    * Adds a command line argument. An argument can have a long name
    * (like --long-argument-name), a short name (like -l), or both. The type
    * of the argument can be specified by using the <code>type</code> parameter.
    * The following types are supported:
    *
    * <table>
    * <tr><td><b>Type</b></td><td><b># of parameters</b></td><td><b>Default regular expr</b></td>
    *        <td><b>Example</b></td></tr>
    * <tr><td>QVariant::String</td><td>1</td><td>.*</td><td>--test-string StringParameter</td></tr>
    * <tr><td>QVariant::Bool</td><td>0</td><td>does not apply</td><td>--enable-something</td></tr>
    * <tr><td>QVariant::StringList</td><td>-1</td><td>.*</td><td>--test-list string1 string2</td></tr>
    * <tr><td>QVariant::Int</td><td>1</td><td>-?[0-9]+</td><td>--test-int -5</td></tr>
    * </table>
    *
    * The regular expressions are used to validate the parameters of command line
    * arguments. You can restrict the valid set of parameters by calling
    * <code>setExactMatchRegularExpression()</code> for your argument.
    *
    * Optionally, a help string and a default value can be provided for the argument. If
    * the QVariant type of the default value does not match <code>type</code>, an
    * exception is thrown. Arguments with default values are always returned by
    * <code>parseArguments()</code>.
    *
    * You can also declare an argument deprecated, by setting <code>deprecated</code>
    * to <code>true</code>. Alternatively you can add a deprecated argument by calling
    * <code>addDeprecatedArgument()</code>.
    *
    * If the long or short argument has already been added, or if both are empty strings,
    * the method call has no effect.
    *
    * @param longarg The long argument name.
    * @param shortarg The short argument name.
    * @param type The argument type (see the list above for supported types).
    * @param argHelp A help string describing the argument.
    * @param defaultValue A default value for the argument.
    * @param ignoreRest All arguments after the current one will be ignored.
    * @param deprecated Declares the argument deprecated.
    *
    * @see setExactMatchRegularExpression()
    * @see addDeprecatedArgument()
    * @throws std::logic_error If the QVariant type of <code>defaultValue</code>
    *         does not match <code>type</code>, a <code>std::logic_error</code> is thrown.
    */
   void addArgument(const QString &longarg,
                    const QString &shortarg,
                    QVariant::Type type,
                    const QString &argHelp = QString(),
                    const QVariant &defaultValue = QVariant(),
                    bool ignoreRest = false,
                    bool deprecated = false);
 
   /**
    * Adds a deprecated command line argument. If a deprecated argument is provided
    * on the command line, <code>argHelp</code> is displayed in the console and
    * processing continues with the next argument.
    *
    * Deprecated arguments are grouped separately at the end of the help text
    * returned by <code>helpText()</code>.
    *
    * @param longarg The long argument name.
    * @param shortarg The short argument name.
    * @param argHelp A help string describing alternatives to the deprecated argument.
    */
   void addDeprecatedArgument(const QString &longarg, const QString &shortarg, const QString &argHelp);
 
   /**
    * Sets a custom regular expression for validating argument parameters. The method
    * <code>errorString()</code> can be used the get the last error description.
    *
    * @param argument The previously added long or short argument name.
    * @param expression A regular expression which the arugment parameters must match.
    * @param exactMatchFailedMessage An error message explaining why the parameter did
    *        not match.
    *
    * @return <code>true</code> if the argument was found and the regular expression was set,
    *         <code>false</code> otherwise.
    *
    * @see errorString()
    */
   bool setExactMatchRegularExpression(const QString &argument,
                                       const QString &expression,
                                       const QString &exactMatchFailedMessage);
 
   /**
    * The field width for the argument names without the help text.
    *
    * @return The argument names field width in the help text.
    */
   int fieldWidth() const;
 
   /**
    * Creates a help text containing properly formatted argument names and help strings
    * provided by calls to <code>addArgument()</code>. The arguments can be grouped by
    * using <code>beginGroup()</code> and <code>endGroup()</code>.
    *
    * @param charPad The padding character.
    * @return The formatted help text.
    */
   QString helpText(const char charPad = ' ') const;
 
   /**
    * Sets the argument prefix for long and short argument names. This can be used
    * to create native command line arguments without changing the calls to
    * <code>addArgument()</code>. For example on Unix-based systems, long argument
    * names start with "--" and short names with "-", while on Windows argument names
    * always start with "/".
    *
    * Note that all methods in ctkCommandLineParser which take an argument name
    * expect the name as it was supplied to <code>addArgument</code>.
    *
    * Example usage:
    *
    * \code
    * ctkCommandLineParser parser;
    * parser.setArgumentPrefix("--", "-");
    * parser.addArgument("long-argument", "l", QVariant::String);
    * QStringList args;
    * args << "program name" << "--long-argument Hi";
    * parser.parseArguments(args);
    * \endcode
    *
    * @param longPrefix The prefix for long argument names.
    * @param shortPrefix The prefix for short argument names.
    */
   void setArgumentPrefix(const QString &longPrefix, const QString &shortPrefix);
 
   /**
    * Begins a new group for documenting arguments. All newly added arguments via
    * <code>addArgument()</code> will be put in the new group. You can close the
    * current group by calling <code>endGroup()</code> or be opening a new group.
    *
    * Note that groups cannot be nested and all arguments which do not belong to
    * a group will be listed at the top of the text created by <code>helpText()</code>.
    *
    * @param description The description of the group
    */
   void beginGroup(const QString &description);
 
   /**
    * Ends the current group.
    *
    * @see beginGroup(const QString&)
    */
   void endGroup();
 
   /**
    * Enables QSettings support in ctkCommandLineParser. If an argument name is found
    * in the QSettings instance with a valid QVariant, the value is considered as
    * a default value and overwrites default values registered with
    * <code>addArgument()</code>. User supplied values on the command line overwrite
    * values in the QSettings instance, except for arguments with multiple parameters
    * which are merged with QSettings values. Call <code>mergeSettings(false)</code>
    * to disable merging.
    *
    * See <code>ctkCommandLineParser(QSettings*)</code> for information about how to
    * supply a QSettings instance.
    *
    * Additionally, a long and short argument name can be specified which will disable
    * QSettings support if supplied on the command line. The argument name must be
    * registered as a regular argument via <code>addArgument()</code>.
    *
    * @param disableLongArg Long argument name.
    * @param disableShortArg Short argument name.
    *
    * @see ctkCommandLineParser(QSettings*)
    */
   void enableSettings(const QString &disableLongArg = "", const QString &disableShortArg = "");
 
   /**
    * Controlls the merging behavior of user values and QSettings values.
    *
    * If merging is on (the default), user supplied values for an argument
    * which can take more than one parameter are merged with values stored
    * in the QSettings instance. If merging is off, the user values overwrite
    * the QSettings values.
    *
    * @param merge <code>true</code> enables QSettings merging, <code>false</code>
    *        disables it.
    */
   void mergeSettings(bool merge);
 
   /**
    * Can be used to check if QSettings support has been enabled by a call to
    * <code>enableSettings()</code>.
    *
    * @return <code>true</code> if QSettings support is enabled, <code>false</code>
    *         otherwise.
    */
   bool settingsEnabled() const;
 
   /**
     * Can be used to teach the parser to stop parsing the arguments and return False when
     * an unknown argument is encountered. By default <code>StrictMode</code> is disabled.
     *
     * @see parseArguments(const QStringList &, bool*)
     */
   void setStrictModeEnabled(bool strictMode);
 
 private:
   class ctkInternal;
   ctkInternal *Internal;
 };
 #endif
diff --git a/CMake/MacroParseArguments.cmake b/CMake/MacroParseArguments.cmake
index aed343d65f..fc8ee579af 100644
--- a/CMake/MacroParseArguments.cmake
+++ b/CMake/MacroParseArguments.cmake
@@ -1,81 +1,81 @@
 # macro(MACRO_PARSE_ARGUMENTS prefix arg_names option_names)
 #
-#   From http://www.cmake.org/Wiki/CMakeMacroParseArguments:
+#   From https://gitlab.kitware.com/cmake/community/-/wikis/contrib/macros/ParseArguments:
 #
 #   The MACRO_PARSE_ARGUMENTS macro will take the arguments of another macro and
 #   define several variables:
 #
 #     1) The first argument to is a prefix to put on all variables it creates.
 #     2) The second argument is a quoted list of names,
 #     3) and the third argument is a quoted list of options.
 #
 #   The rest of MACRO_PARSE_ARGUMENTS are arguments from another macro to be
 #   parsed.
 #
 #   MACRO_PARSE_ARGUMENTS(prefix arg_names options arg1 arg2...)
 #
 #   For each item in options, MACRO_PARSE_ARGUMENTS will create a variable
 #   with that name, prefixed with prefix_. So, for example, if prefix is
 #   MY_MACRO and options is OPTION1;OPTION2, then PARSE_ARGUMENTS will create
 #   the variables MY_MACRO_OPTION1 and MY_MACRO_OPTION2. These variables will
 #   be set to true if the option exists in the command line or false otherwise.
 #
 #   For each item in arg_names, MACRO_PARSE_ARGUMENTS will create a variable
 #   with that name, prefixed with prefix_. Each variable will be filled with the
 #   arguments that occur after the given arg_name is encountered up to the next
 #   arg_name or the end of the arguments. All options are removed from these
 #   lists.
 #
 #   MACRO_PARSE_ARGUMENTS also creates a prefix_DEFAULT_ARGS variable containing
 #   the list of all arguments up to the first arg_name encountered.
 
 if(NOT COMMAND MACRO_PARSE_ARGUMENTS)
 
 macro(MACRO_PARSE_ARGUMENTS prefix arg_names option_names)
 
    message(WARNING "The MACRO_PARSE_ARGUMENTS macro is deprecated. Use cmake_parse_arguments instead.")
 
    set(DEFAULT_ARGS)
 
    foreach(arg_name ${arg_names})
       set(${prefix}_${arg_name})
    endforeach(arg_name)
 
    foreach(option ${option_names})
       set(${prefix}_${option} FALSE)
    endforeach(option)
 
    set(current_arg_name DEFAULT_ARGS)
    set(current_arg_list)
 
    foreach(arg ${ARGN})
 
       set(larg_names ${arg_names})
       list(FIND larg_names "${arg}" is_arg_name)
 
       if(is_arg_name GREATER -1)
 
          set(${prefix}_${current_arg_name} ${current_arg_list})
          set(current_arg_name "${arg}")
          set(current_arg_list)
 
       else(is_arg_name GREATER -1)
 
          set(loption_names ${option_names})
          list(FIND loption_names "${arg}" is_option)
 
          if(is_option GREATER -1)
             set(${prefix}_${arg} TRUE)
          else(is_option GREATER -1)
             set(current_arg_list ${current_arg_list} "${arg}")
          endif(is_option GREATER -1)
 
       endif(is_arg_name GREATER -1)
 
    endforeach(arg ${ARGN})
 
    set(${prefix}_${current_arg_name} ${current_arg_list})
 
 endmacro(MACRO_PARSE_ARGUMENTS)
 
 endif(NOT COMMAND MACRO_PARSE_ARGUMENTS)
diff --git a/CMake/NSIS.template.in b/CMake/NSIS.template.in
index 47f5d675ff..619bfcd3f8 100644
--- a/CMake/NSIS.template.in
+++ b/CMake/NSIS.template.in
@@ -1,1014 +1,1014 @@
 ; CPack install script designed for a nmake build
 
 ;--------------------------------
 ; You must define these values
 
   !define VERSION "@CPACK_PACKAGE_VERSION@"
   !define PATCH  "@CPACK_PACKAGE_VERSION_PATCH@"
   !define INST_DIR "@CPACK_TEMPORARY_DIRECTORY@"
 
 ;--------------------------------
 ;Variables
 
   Var MUI_TEMP
   Var STARTMENU_FOLDER
   Var SV_ALLUSERS
   Var START_MENU
   Var DO_NOT_ADD_TO_PATH
   Var ADD_TO_PATH_ALL_USERS
   Var ADD_TO_PATH_CURRENT_USER
   Var INSTALL_DESKTOP
   Var IS_DEFAULT_INSTALLDIR
 ;--------------------------------
 ;Include Modern UI
 
   !include "MUI.nsh"
 
   ;Default installation folder
   InstallDir "@CPACK_NSIS_INSTALL_ROOT@\@CPACK_PACKAGE_INSTALL_DIRECTORY@"
 
   ;Allow for very long title on the welcome page
   !define MUI_WELCOMEPAGE_TITLE_3LINES
 
 ;--------------------------------
 ;General
 
   ;Name and file
   Name "@CPACK_NSIS_PACKAGE_NAME@"
   OutFile "@CPACK_TOPLEVEL_DIRECTORY@/@CPACK_OUTPUT_FILE_NAME@"
 
   ;Set compression
   SetCompressor @CPACK_NSIS_COMPRESSOR@
 
   RequestExecutionLevel user
 
 @CPACK_NSIS_DEFINES@
 
   !include Sections.nsh
 
 ;--- Component support macros: ---
 ; The code for the add/remove functionality is from:
-;   http://nsis.sourceforge.net/Add/Remove_Functionality
+;   https://nsis.sourceforge.io/Add/Remove_Functionality
 ; It has been modified slightly and extended to provide
 ; inter-component dependencies.
 Var AR_SecFlags
 Var AR_RegFlags
 @CPACK_NSIS_SECTION_SELECTED_VARS@
 
 ; Loads the "selected" flag for the section named SecName into the
 ; variable VarName.
 !macro LoadSectionSelectedIntoVar SecName VarName
  SectionGetFlags ${${SecName}} $${VarName}
  IntOp $${VarName} $${VarName} & ${SF_SELECTED}  ;Turn off all other bits
 !macroend
 
 ; Loads the value of a variable... can we get around this?
 !macro LoadVar VarName
   IntOp $R0 0 + $${VarName}
 !macroend
 
 ; Sets the value of a variable
 !macro StoreVar VarName IntValue
   IntOp $${VarName} 0 + ${IntValue}
 !macroend
 
 !macro InitSection SecName
   ;  This macro reads component installed flag from the registry and
   ;changes checked state of the section on the components page.
   ;Input: section index constant name specified in Section command.
 
   ClearErrors
   ;Reading component status from registry
   ReadRegDWORD $AR_RegFlags HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@\Components\${SecName}" "Installed"
   IfErrors "default_${SecName}"
     ;Status will stay default if registry value not found
     ;(component was never installed)
   IntOp $AR_RegFlags $AR_RegFlags & ${SF_SELECTED} ;Turn off all other bits
   SectionGetFlags ${${SecName}} $AR_SecFlags  ;Reading default section flags
   IntOp $AR_SecFlags $AR_SecFlags & 0xFFFE  ;Turn lowest (enabled) bit off
   IntOp $AR_SecFlags $AR_RegFlags | $AR_SecFlags      ;Change lowest bit
 
   ; Note whether this component was installed before
   !insertmacro StoreVar ${SecName}_was_installed $AR_RegFlags
   IntOp $R0 $AR_RegFlags & $AR_RegFlags
 
   ;Writing modified flags
   SectionSetFlags ${${SecName}} $AR_SecFlags
 
  "default_${SecName}:"
  !insertmacro LoadSectionSelectedIntoVar ${SecName} ${SecName}_selected
 !macroend
 
 !macro FinishSection SecName
   ;  This macro reads section flag set by user and removes the section
   ;if it is not selected.
   ;Then it writes component installed flag to registry
   ;Input: section index constant name specified in Section command.
 
   SectionGetFlags ${${SecName}} $AR_SecFlags  ;Reading section flags
   ;Checking lowest bit:
   IntOp $AR_SecFlags $AR_SecFlags & ${SF_SELECTED}
   IntCmp $AR_SecFlags 1 "leave_${SecName}"
     ;Section is not selected:
     ;Calling Section uninstall macro and writing zero installed flag
     !insertmacro "Remove_${${SecName}}"
     WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@\Components\${SecName}" \
   "Installed" 0
     Goto "exit_${SecName}"
 
  "leave_${SecName}:"
     ;Section is selected:
     WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@\Components\${SecName}" \
   "Installed" 1
 
  "exit_${SecName}:"
 !macroend
 
 ; NSIS example code to only include some code if a file exists at compile time (whereas IfFileExists works at runtime)
-; See http://nsis.sourceforge.net/Check_if_a_file_exists_at_compile_time for documentation
+; See https://nsis.sourceforge.io/Check_if_a_file_exists_at_compile_time for documentation
 !macro !defineifexist _VAR_NAME _FILE_NAME
   !tempfile _TEMPFILE
   !system 'if exist "${_FILE_NAME}" echo !define ${_VAR_NAME} > "${_TEMPFILE}"'
   !include '${_TEMPFILE}'
   !delfile '${_TEMPFILE}'
   !undef _TEMPFILE
 !macroend
 !define !defineifexist "!insertmacro !defineifexist"
 
 ; Determine whether the selection of SecName changed
 !macro MaybeSelectionChanged SecName
   !insertmacro LoadVar ${SecName}_selected
   SectionGetFlags ${${SecName}} $R1
   IntOp $R1 $R1 & ${SF_SELECTED} ;Turn off all other bits
 
   ; See if the status has changed:
   IntCmp $R0 $R1 "${SecName}_unchanged"
   !insertmacro LoadSectionSelectedIntoVar ${SecName} ${SecName}_selected
 
   IntCmp $R1 ${SF_SELECTED} "${SecName}_was_selected"
   !insertmacro "Deselect_required_by_${SecName}"
   goto "${SecName}_unchanged"
 
   "${SecName}_was_selected:"
   !insertmacro "Select_${SecName}_depends"
 
   "${SecName}_unchanged:"
 !macroend
 ;--- End of Add/Remove macros ---
 
 ;--------------------------------
 ;Interface Settings
 
   !define MUI_HEADERIMAGE
   !define MUI_ABORTWARNING
 
 ;--------------------------------
 ; path functions
 
 !verbose 3
 !include "WinMessages.NSH"
 !verbose 4
 
 ;----------------------------------------
 ; based upon a script of "Written by KiCHiK 2003-01-18 05:57:02"
 ;----------------------------------------
 !verbose 3
 !include "WinMessages.NSH"
 !verbose 4
 ;====================================================
 ; get_NT_environment
 ;     Returns: the selected environment
 ;     Output : head of the stack
 ;====================================================
 !macro select_NT_profile UN
 Function ${UN}select_NT_profile
    StrCmp $ADD_TO_PATH_ALL_USERS "1" 0 environment_single
       DetailPrint "Selected environment for all users"
       Push "all"
       Return
    environment_single:
       DetailPrint "Selected environment for current user only."
       Push "current"
       Return
 FunctionEnd
 !macroend
 !insertmacro select_NT_profile ""
 !insertmacro select_NT_profile "un."
 ;----------------------------------------------------
 !define NT_current_env 'HKCU "Environment"'
 !define NT_all_env     'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
 
 !ifndef WriteEnvStr_RegKey
   !ifdef ALL_USERS
     !define WriteEnvStr_RegKey \
        'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
   !else
     !define WriteEnvStr_RegKey 'HKCU "Environment"'
   !endif
 !endif
 
 ; AddToPath - Adds the given dir to the search path.
 ;        Input - head of the stack
 ;        Note - Win9x systems requires reboot
 
 Function AddToPath
   Exch $0
   Push $1
   Push $2
   Push $3
 
   # don't add if the path doesn't exist
   IfFileExists "$0\*.*" "" AddToPath_done
 
   ReadEnvStr $1 PATH
   ; if the path is too long for a NSIS variable NSIS will return a 0
   ; length string.  If we find that, then warn and skip any path
   ; modification as it will trash the existing path.
   StrLen $2 $1
   IntCmp $2 0 CheckPathLength_ShowPathWarning CheckPathLength_Done CheckPathLength_Done
     CheckPathLength_ShowPathWarning:
     DetailPrint "Warning: Could not modify PATH variable - current PATH is too long.\n\
 This does not impact the functionality of MITK itself, but you will not be able to start\
 it from anywhere via command line."
     ; The message box is probably too much of an escalation, most users won't care or notice
     ;Messagebox MB_OK|MB_ICONEXCLAMATION "Warning! PATH too long installer unable to modify PATH!"
     Goto AddToPath_done
   CheckPathLength_Done:
   Push "$1;"
   Push "$0;"
   Call StrStr
   Pop $2
   StrCmp $2 "" "" AddToPath_done
   Push "$1;"
   Push "$0\;"
   Call StrStr
   Pop $2
   StrCmp $2 "" "" AddToPath_done
   GetFullPathName /SHORT $3 $0
   Push "$1;"
   Push "$3;"
   Call StrStr
   Pop $2
   StrCmp $2 "" "" AddToPath_done
   Push "$1;"
   Push "$3\;"
   Call StrStr
   Pop $2
   StrCmp $2 "" "" AddToPath_done
 
   Call IsNT
   Pop $1
   StrCmp $1 1 AddToPath_NT
     ; Not on NT
     StrCpy $1 $WINDIR 2
     FileOpen $1 "$1\autoexec.bat" a
     FileSeek $1 -1 END
     FileReadByte $1 $2
     IntCmp $2 26 0 +2 +2 # DOS EOF
       FileSeek $1 -1 END # write over EOF
     FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
     FileClose $1
     SetRebootFlag true
     Goto AddToPath_done
 
   AddToPath_NT:
     StrCmp $ADD_TO_PATH_ALL_USERS "1" ReadAllKey
       ReadRegStr $1 ${NT_current_env} "PATH"
       Goto DoTrim
     ReadAllKey:
       ReadRegStr $1 ${NT_all_env} "PATH"
     DoTrim:
     StrCmp $1 "" AddToPath_NTdoIt
       Push $1
       Call Trim
       Pop $1
       StrCpy $0 "$1;$0"
     AddToPath_NTdoIt:
       StrCmp $ADD_TO_PATH_ALL_USERS "1" WriteAllKey
         WriteRegExpandStr ${NT_current_env} "PATH" $0
         Goto DoSend
       WriteAllKey:
         WriteRegExpandStr ${NT_all_env} "PATH" $0
       DoSend:
       SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
 
   AddToPath_done:
     Pop $3
     Pop $2
     Pop $1
     Pop $0
 FunctionEnd
 
 
 ; RemoveFromPath - Remove a given dir from the path
 ;     Input: head of the stack
 
 Function un.RemoveFromPath
   Exch $0
   Push $1
   Push $2
   Push $3
   Push $4
   Push $5
   Push $6
 
   IntFmt $6 "%c" 26 # DOS EOF
 
   Call un.IsNT
   Pop $1
   StrCmp $1 1 unRemoveFromPath_NT
     ; Not on NT
     StrCpy $1 $WINDIR 2
     FileOpen $1 "$1\autoexec.bat" r
     GetTempFileName $4
     FileOpen $2 $4 w
     GetFullPathName /SHORT $0 $0
     StrCpy $0 "SET PATH=%PATH%;$0"
     Goto unRemoveFromPath_dosLoop
 
     unRemoveFromPath_dosLoop:
       FileRead $1 $3
       StrCpy $5 $3 1 -1 # read last char
       StrCmp $5 $6 0 +2 # if DOS EOF
         StrCpy $3 $3 -1 # remove DOS EOF so we can compare
       StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
       StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
       StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
       StrCmp $3 "" unRemoveFromPath_dosLoopEnd
       FileWrite $2 $3
       Goto unRemoveFromPath_dosLoop
       unRemoveFromPath_dosLoopRemoveLine:
         SetRebootFlag true
         Goto unRemoveFromPath_dosLoop
 
     unRemoveFromPath_dosLoopEnd:
       FileClose $2
       FileClose $1
       StrCpy $1 $WINDIR 2
       Delete "$1\autoexec.bat"
       CopyFiles /SILENT $4 "$1\autoexec.bat"
       Delete $4
       Goto unRemoveFromPath_done
 
   unRemoveFromPath_NT:
     StrCmp $ADD_TO_PATH_ALL_USERS "1" unReadAllKey
       ReadRegStr $1 ${NT_current_env} "PATH"
       Goto unDoTrim
     unReadAllKey:
       ReadRegStr $1 ${NT_all_env} "PATH"
     unDoTrim:
     StrCpy $5 $1 1 -1 # copy last char
     StrCmp $5 ";" +2 # if last char != ;
       StrCpy $1 "$1;" # append ;
     Push $1
     Push "$0;"
     Call un.StrStr ; Find `$0;` in $1
     Pop $2 ; pos of our dir
     StrCmp $2 "" unRemoveFromPath_done
       ; else, it is in path
       # $0 - path to add
       # $1 - path var
       StrLen $3 "$0;"
       StrLen $4 $2
       StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
       StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
       StrCpy $3 $5$6
 
       StrCpy $5 $3 1 -1 # copy last char
       StrCmp $5 ";" 0 +2 # if last char == ;
         StrCpy $3 $3 -1 # remove last char
 
       StrCmp $ADD_TO_PATH_ALL_USERS "1" unWriteAllKey
         WriteRegExpandStr ${NT_current_env} "PATH" $3
         Goto unDoSend
       unWriteAllKey:
         WriteRegExpandStr ${NT_all_env} "PATH" $3
       unDoSend:
       SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
 
   unRemoveFromPath_done:
     Pop $6
     Pop $5
     Pop $4
     Pop $3
     Pop $2
     Pop $1
     Pop $0
 FunctionEnd
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; Uninstall stuff
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ###########################################
 #            Utility Functions            #
 ###########################################
 
 ;====================================================
 ; IsNT - Returns 1 if the current system is NT, 0
 ;        otherwise.
 ;     Output: head of the stack
 ;====================================================
 ; IsNT
 ; no input
 ; output, top of the stack = 1 if NT or 0 if not
 ;
 ; Usage:
 ;   Call IsNT
 ;   Pop $R0
 ;  ($R0 at this point is 1 or 0)
 
 !macro IsNT un
 Function ${un}IsNT
   Push $0
   ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
   StrCmp $0 "" 0 IsNT_yes
   ; we are not NT.
   Pop $0
   Push 0
   Return
 
   IsNT_yes:
     ; NT!!!
     Pop $0
     Push 1
 FunctionEnd
 !macroend
 !insertmacro IsNT ""
 !insertmacro IsNT "un."
 
 ; StrStr
 ; input, top of stack = string to search for
 ;        top of stack-1 = string to search in
 ; output, top of stack (replaces with the portion of the string remaining)
 ; modifies no other variables.
 ;
 ; Usage:
 ;   Push "this is a long ass string"
 ;   Push "ass"
 ;   Call StrStr
 ;   Pop $R0
 ;  ($R0 at this point is "ass string")
 
 !macro StrStr un
 Function ${un}StrStr
 Exch $R1 ; st=haystack,old$R1, $R1=needle
   Exch    ; st=old$R1,haystack
   Exch $R2 ; st=old$R1,old$R2, $R2=haystack
   Push $R3
   Push $R4
   Push $R5
   StrLen $R3 $R1
   StrCpy $R4 0
   ; $R1=needle
   ; $R2=haystack
   ; $R3=len(needle)
   ; $R4=cnt
   ; $R5=tmp
   loop:
     StrCpy $R5 $R2 $R3 $R4
     StrCmp $R5 $R1 done
     StrCmp $R5 "" done
     IntOp $R4 $R4 + 1
     Goto loop
 done:
   StrCpy $R1 $R2 "" $R4
   Pop $R5
   Pop $R4
   Pop $R3
   Pop $R2
   Exch $R1
 FunctionEnd
 !macroend
 !insertmacro StrStr ""
 !insertmacro StrStr "un."
 
 Function Trim ; Added by Pelaca
   Exch $R1
   Push $R2
 Loop:
   StrCpy $R2 "$R1" 1 -1
   StrCmp "$R2" " " RTrim
   StrCmp "$R2" "$\n" RTrim
   StrCmp "$R2" "$\r" RTrim
   StrCmp "$R2" ";" RTrim
   GoTo Done
 RTrim:
   StrCpy $R1 "$R1" -1
   Goto Loop
 Done:
   Pop $R2
   Exch $R1
 FunctionEnd
 
 Function ConditionalAddToRegisty
   Pop $0
   Pop $1
   StrCmp "$0" "" ConditionalAddToRegisty_EmptyString
     WriteRegStr SHCTX "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@" \
     "$1" "$0"
     ;MessageBox MB_OK "Set Registry: '$1' to '$0'"
     DetailPrint "Set install registry entry: '$1' to '$0'"
   ConditionalAddToRegisty_EmptyString:
 FunctionEnd
 
 ;--------------------------------
 
 !ifdef CPACK_USES_DOWNLOAD
 Function DownloadFile
     IfFileExists $INSTDIR\* +2
     CreateDirectory $INSTDIR
     Pop $0
 
     ; Skip if already downloaded
     IfFileExists $INSTDIR\$0 0 +2
     Return
 
     StrCpy $1 "@CPACK_DOWNLOAD_SITE@"
 
   try_again:
     NSISdl::download "$1/$0" "$INSTDIR\$0"
 
     Pop $1
     StrCmp $1 "success" success
     StrCmp $1 "Cancelled" cancel
     MessageBox MB_OK "Download failed: $1"
   cancel:
     Return
   success:
 FunctionEnd
 !endif
 
 ;--------------------------------
 ; Installation types
 @CPACK_NSIS_INSTALLATION_TYPES@
 
 ;--------------------------------
 ; Component sections
 @CPACK_NSIS_COMPONENT_SECTIONS@
 
 ;--------------------------------
 ; Define some macro setting for the gui
 @CPACK_NSIS_INSTALLER_MUI_ICON_CODE@
 @CPACK_NSIS_INSTALLER_ICON_CODE@
 @CPACK_NSIS_INSTALLER_MUI_COMPONENTS_DESC@
 @CPACK_NSIS_INSTALLER_MUI_FINISHPAGE_RUN_CODE@
 
 ;--------------------------------
 ;Pages
   !insertmacro MUI_PAGE_WELCOME
 
   !insertmacro MUI_PAGE_LICENSE "@CPACK_RESOURCE_FILE_LICENSE@"
   Page custom InstallOptionsPage
   !insertmacro MUI_PAGE_DIRECTORY
 
   ;Start Menu Folder Page Configuration
   !define MUI_STARTMENUPAGE_REGISTRY_ROOT "SHCTX"
   !define MUI_STARTMENUPAGE_REGISTRY_KEY "Software\@CPACK_PACKAGE_VENDOR@\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@"
   !define MUI_STARTMENUPAGE_REGISTRY_VALUENAME "Start Menu Folder"
   !insertmacro MUI_PAGE_STARTMENU Application $STARTMENU_FOLDER
 
   @CPACK_NSIS_PAGE_COMPONENTS@
 
   !insertmacro MUI_PAGE_INSTFILES
   !insertmacro MUI_PAGE_FINISH
 
   !insertmacro MUI_UNPAGE_CONFIRM
   !insertmacro MUI_UNPAGE_INSTFILES
 
 ;--------------------------------
 ;Languages
 
   !insertmacro MUI_LANGUAGE "English" ;first language is the default language
   !insertmacro MUI_LANGUAGE "Albanian"
   !insertmacro MUI_LANGUAGE "Arabic"
   !insertmacro MUI_LANGUAGE "Basque"
   !insertmacro MUI_LANGUAGE "Belarusian"
   !insertmacro MUI_LANGUAGE "Bosnian"
   !insertmacro MUI_LANGUAGE "Breton"
   !insertmacro MUI_LANGUAGE "Bulgarian"
   !insertmacro MUI_LANGUAGE "Croatian"
   !insertmacro MUI_LANGUAGE "Czech"
   !insertmacro MUI_LANGUAGE "Danish"
   !insertmacro MUI_LANGUAGE "Dutch"
   !insertmacro MUI_LANGUAGE "Estonian"
   !insertmacro MUI_LANGUAGE "Farsi"
   !insertmacro MUI_LANGUAGE "Finnish"
   !insertmacro MUI_LANGUAGE "French"
   !insertmacro MUI_LANGUAGE "German"
   !insertmacro MUI_LANGUAGE "Greek"
   !insertmacro MUI_LANGUAGE "Hebrew"
   !insertmacro MUI_LANGUAGE "Hungarian"
   !insertmacro MUI_LANGUAGE "Icelandic"
   !insertmacro MUI_LANGUAGE "Indonesian"
   !insertmacro MUI_LANGUAGE "Irish"
   !insertmacro MUI_LANGUAGE "Italian"
   !insertmacro MUI_LANGUAGE "Japanese"
   !insertmacro MUI_LANGUAGE "Korean"
   !insertmacro MUI_LANGUAGE "Kurdish"
   !insertmacro MUI_LANGUAGE "Latvian"
   !insertmacro MUI_LANGUAGE "Lithuanian"
   !insertmacro MUI_LANGUAGE "Luxembourgish"
   !insertmacro MUI_LANGUAGE "Macedonian"
   !insertmacro MUI_LANGUAGE "Malay"
   !insertmacro MUI_LANGUAGE "Mongolian"
   !insertmacro MUI_LANGUAGE "Norwegian"
   !insertmacro MUI_LANGUAGE "Polish"
   !insertmacro MUI_LANGUAGE "Portuguese"
   !insertmacro MUI_LANGUAGE "PortugueseBR"
   !insertmacro MUI_LANGUAGE "Romanian"
   !insertmacro MUI_LANGUAGE "Russian"
   !insertmacro MUI_LANGUAGE "Serbian"
   !insertmacro MUI_LANGUAGE "SerbianLatin"
   !insertmacro MUI_LANGUAGE "SimpChinese"
   !insertmacro MUI_LANGUAGE "Slovak"
   !insertmacro MUI_LANGUAGE "Slovenian"
   !insertmacro MUI_LANGUAGE "Spanish"
   !insertmacro MUI_LANGUAGE "Swedish"
   !insertmacro MUI_LANGUAGE "Thai"
   !insertmacro MUI_LANGUAGE "TradChinese"
   !insertmacro MUI_LANGUAGE "Turkish"
   !insertmacro MUI_LANGUAGE "Ukrainian"
   !insertmacro MUI_LANGUAGE "Welsh"
 
 
 ;--------------------------------
 ;Reserve Files
 
   ;These files should be inserted before other files in the data block
   ;Keep these lines before any File command
   ;Only for solid compression (by default, solid compression is enabled for BZIP2 and LZMA)
 
   ReserveFile "NSIS.InstallOptions.ini"
   !insertmacro MUI_RESERVEFILE_INSTALLOPTIONS
 
 ;--------------------------------
 ;Installer Sections
 
 Section "-Core installation"
   ;Use the entire tree produced by the INSTALL target.  Keep the
   ;list of directories here in sync with the RMDir commands below.
   SetOutPath "$INSTDIR"
   @CPACK_NSIS_FULL_INSTALL@
 
   ;Store installation folder
   WriteRegStr SHCTX "Software\@CPACK_PACKAGE_VENDOR@\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" "" $INSTDIR
 
   ;Create uninstaller
   WriteUninstaller "$INSTDIR\Uninstall.exe"
   Push "DisplayName"
   Push "@CPACK_NSIS_DISPLAY_NAME@"
   Call ConditionalAddToRegisty
   Push "DisplayVersion"
   Push "@CPACK_PACKAGE_VERSION@"
   Call ConditionalAddToRegisty
   Push "Publisher"
   Push "@CPACK_PACKAGE_VENDOR@"
   Call ConditionalAddToRegisty
   Push "UninstallString"
   Push "$INSTDIR\Uninstall.exe"
   Call ConditionalAddToRegisty
   Push "NoRepair"
   Push "1"
   Call ConditionalAddToRegisty
 
   !ifdef CPACK_NSIS_ADD_REMOVE
   ;Create add/remove functionality
   Push "ModifyPath"
   Push "$INSTDIR\AddRemove.exe"
   Call ConditionalAddToRegisty
   !else
   Push "NoModify"
   Push "1"
   Call ConditionalAddToRegisty
   !endif
 
   ; Optional registration
   Push "DisplayIcon"
   Push "$INSTDIR\@CPACK_NSIS_INSTALLED_ICON_NAME@"
   Call ConditionalAddToRegisty
   Push "HelpLink"
   Push "@CPACK_NSIS_HELP_LINK@"
   Call ConditionalAddToRegisty
   Push "URLInfoAbout"
   Push "@CPACK_NSIS_URL_INFO_ABOUT@"
   Call ConditionalAddToRegisty
   Push "Contact"
   Push "@CPACK_NSIS_CONTACT@"
   Call ConditionalAddToRegisty
   !insertmacro MUI_INSTALLOPTIONS_READ $INSTALL_DESKTOP "NSIS.InstallOptions.ini" "Field 5" "State"
   !insertmacro MUI_STARTMENU_WRITE_BEGIN Application
 
   ;Create shortcuts
   CreateDirectory "$SMPROGRAMS\$STARTMENU_FOLDER"
 @CPACK_NSIS_CREATE_ICONS@
 @CPACK_NSIS_CREATE_ICONS_EXTRA@
   CreateShortCut "$SMPROGRAMS\$STARTMENU_FOLDER\Uninstall.lnk" "$INSTDIR\Uninstall.exe"
 
   ;Read a value from an InstallOptions INI file
   !insertmacro MUI_INSTALLOPTIONS_READ $DO_NOT_ADD_TO_PATH "NSIS.InstallOptions.ini" "Field 2" "State"
   !insertmacro MUI_INSTALLOPTIONS_READ $ADD_TO_PATH_ALL_USERS "NSIS.InstallOptions.ini" "Field 3" "State"
   !insertmacro MUI_INSTALLOPTIONS_READ $ADD_TO_PATH_CURRENT_USER "NSIS.InstallOptions.ini" "Field 4" "State"
 
   ; Write special uninstall registry entries
   Push "StartMenu"
   Push "$STARTMENU_FOLDER"
   Call ConditionalAddToRegisty
   Push "DoNotAddToPath"
   Push "$DO_NOT_ADD_TO_PATH"
   Call ConditionalAddToRegisty
   Push "AddToPathAllUsers"
   Push "$ADD_TO_PATH_ALL_USERS"
   Call ConditionalAddToRegisty
   Push "AddToPathCurrentUser"
   Push "$ADD_TO_PATH_CURRENT_USER"
   Call ConditionalAddToRegisty
   Push "InstallToDesktop"
   Push "$INSTALL_DESKTOP"
   Call ConditionalAddToRegisty
 
   !insertmacro MUI_STARTMENU_WRITE_END
 
 @CPACK_NSIS_EXTRA_INSTALL_COMMANDS@
 
 SectionEnd
 
 Section "-Add to path"
   Push $INSTDIR\bin
   StrCmp "@CPACK_NSIS_MODIFY_PATH@" "ON" 0 doNotAddToPath
   StrCmp $DO_NOT_ADD_TO_PATH "1" doNotAddToPath 0
     Call AddToPath
   doNotAddToPath:
 SectionEnd
 
 ;--------------------------------
 ; Create custom pages
 Function InstallOptionsPage
   !insertmacro MUI_HEADER_TEXT "Install Options" "Choose options for installing @CPACK_NSIS_PACKAGE_NAME@"
   !insertmacro MUI_INSTALLOPTIONS_DISPLAY "NSIS.InstallOptions.ini"
 
 FunctionEnd
 
 ; Author: Lilla (lilla@earthlink.net) 2003-06-13
 ; function IsUserAdmin uses plugin \NSIS\PlusgIns\UserInfo.dll
 ; This function is based upon code in \NSIS\Contrib\UserInfo\UserInfo.nsi
 ; This function was tested under NSIS 2 beta 4 (latest CVS as of this writing).
 ;
 ; Usage:
 ;   Call IsUserAdmin
 ;   Pop $R0   ; at this point $R0 is "true" or "false"
 ;
 Function IsUserAdmin
 Push $R0
 Push $R1
 Push $R2
 
 ClearErrors
 UserInfo::GetName
 IfErrors Win9x
 Pop $R1
 UserInfo::GetAccountType
 Pop $R2
 
 StrCmp $R2 "Admin" 0 Continue
 ; Observation: I get here when running Win98SE. (Lilla)
 ; The functions UserInfo.dll looks for are there on Win98 too,
 ; but just don't work. So UserInfo.dll, knowing that admin isn't required
 ; on Win98, returns admin anyway. (per kichik)
 ; MessageBox MB_OK 'User "$R1" is in the Administrators group'
 StrCpy $R0 "true"
 Goto Done
 
 Continue:
 ; You should still check for an empty string because the functions
 ; UserInfo.dll looks for may not be present on Windows 95. (per kichik)
 StrCmp $R2 "" Win9x
 StrCpy $R0 "false"
 ;MessageBox MB_OK 'User "$R1" is in the "$R2" group'
 Goto Done
 
 Win9x:
 ; comment/message below is by UserInfo.nsi author:
 ; This one means you don't need to care about admin or
 ; not admin because Windows 9x doesn't either
 ;MessageBox MB_OK "Error! This DLL can't run under Windows 9x!"
 StrCpy $R0 "true"
 
 Done:
 ;MessageBox MB_OK 'User= "$R1"  AccountType= "$R2"  IsUserAdmin= "$R0"'
 
 Pop $R2
 Pop $R1
 Exch $R0
 FunctionEnd
 
 ;--------------------------------
 ; determine admin versus local install
 Function un.onInit
 
   ClearErrors
   UserInfo::GetName
   IfErrors noLM
   Pop $0
   UserInfo::GetAccountType
   Pop $1
   StrCmp $1 "Admin" 0 +3
     SetShellVarContext all
     ;MessageBox MB_OK 'User "$0" is in the Admin group'
     Goto done
   StrCmp $1 "Power" 0 +3
     SetShellVarContext all
     ;MessageBox MB_OK 'User "$0" is in the Power Users group'
     Goto done
 
   noLM:
     ;Get installation folder from registry if available
 
   done:
 
 FunctionEnd
 
 ;--- Add/Remove callback functions: ---
 !macro SectionList MacroName
   ;This macro used to perform operation on multiple sections.
   ;List all of your components in following manner here.
 @CPACK_NSIS_COMPONENT_SECTION_LIST@
 !macroend
 
 Section -FinishComponents
   ;Removes unselected components and writes component status to registry
   !insertmacro SectionList "FinishSection"
 
 !ifdef CPACK_NSIS_ADD_REMOVE
   ; Get the name of the installer executable
   System::Call 'kernel32::GetModuleFileNameA(i 0, t .R0, i 1024) i r1'
   StrCpy $R3 $R0
 
   ; Strip off the last 13 characters, to see if we have AddRemove.exe
   StrLen $R1 $R0
   IntOp $R1 $R0 - 13
   StrCpy $R2 $R0 13 $R1
   StrCmp $R2 "AddRemove.exe" addremove_installed
 
   ; We're not running AddRemove.exe, so install it
   CopyFiles $R3 $INSTDIR\AddRemove.exe
 
   addremove_installed:
 !endif
 SectionEnd
 ;--- End of Add/Remove callback functions ---
 
 ;--------------------------------
 ; Component dependencies
 Function .onSelChange
   !insertmacro SectionList MaybeSelectionChanged
 FunctionEnd
 
 ;--------------------------------
 ;Uninstaller Section
 
 Section "Uninstall"
   ReadRegStr $START_MENU SHCTX \
    "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@" "StartMenu"
   ;MessageBox MB_OK "Start menu is in: $START_MENU"
   ReadRegStr $DO_NOT_ADD_TO_PATH SHCTX \
     "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@" "DoNotAddToPath"
   ReadRegStr $ADD_TO_PATH_ALL_USERS SHCTX \
     "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@" "AddToPathAllUsers"
   ReadRegStr $ADD_TO_PATH_CURRENT_USER SHCTX \
     "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@" "AddToPathCurrentUser"
   ;MessageBox MB_OK "Add to path: $DO_NOT_ADD_TO_PATH all users: $ADD_TO_PATH_ALL_USERS"
   ReadRegStr $INSTALL_DESKTOP SHCTX \
     "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@" "InstallToDesktop"
   ;MessageBox MB_OK "Install to desktop: $INSTALL_DESKTOP "
 
 @CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS@
 
   ;Remove files we installed.
   ;Keep the list of directories here in sync with the File commands above.
 @CPACK_NSIS_DELETE_FILES@
 @CPACK_NSIS_DELETE_DIRECTORIES@
 
 !ifdef CPACK_NSIS_ADD_REMOVE
   ;Remove the add/remove program
   Delete "$INSTDIR\AddRemove.exe"
 !endif
 
   ;Remove the uninstaller itself.
   Delete "$INSTDIR\Uninstall.exe"
   DeleteRegKey SHCTX "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_NAME@"
 
   ;Remove the installation directory if it is empty.
   RMDir "$INSTDIR"
 
   ; Remove the registry entries.
   DeleteRegKey SHCTX "Software\@CPACK_PACKAGE_VENDOR@\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@"
 
   ; Removes all optional components
   !insertmacro SectionList "RemoveSection"
 
   !insertmacro MUI_STARTMENU_GETFOLDER Application $MUI_TEMP
 
   Delete "$SMPROGRAMS\$MUI_TEMP\Uninstall.lnk"
 @CPACK_NSIS_DELETE_ICONS@
 @CPACK_NSIS_DELETE_ICONS_EXTRA@
 
   ;Delete empty start menu parent diretories
   StrCpy $MUI_TEMP "$SMPROGRAMS\$MUI_TEMP"
 
   startMenuDeleteLoop:
     ClearErrors
     RMDir $MUI_TEMP
     GetFullPathName $MUI_TEMP "$MUI_TEMP\.."
 
     IfErrors startMenuDeleteLoopDone
 
     StrCmp "$MUI_TEMP" "$SMPROGRAMS" startMenuDeleteLoopDone startMenuDeleteLoop
   startMenuDeleteLoopDone:
 
   ; If the user changed the shortcut, then untinstall may not work. This should
   ; try to fix it.
   StrCpy $MUI_TEMP "$START_MENU"
   Delete "$SMPROGRAMS\$MUI_TEMP\Uninstall.lnk"
 @CPACK_NSIS_DELETE_ICONS_EXTRA@
 
   ;Delete empty start menu parent diretories
   StrCpy $MUI_TEMP "$SMPROGRAMS\$MUI_TEMP"
 
   secondStartMenuDeleteLoop:
     ClearErrors
     RMDir $MUI_TEMP
     GetFullPathName $MUI_TEMP "$MUI_TEMP\.."
 
     IfErrors secondStartMenuDeleteLoopDone
 
     StrCmp "$MUI_TEMP" "$SMPROGRAMS" secondStartMenuDeleteLoopDone secondStartMenuDeleteLoop
   secondStartMenuDeleteLoopDone:
 
   DeleteRegKey /ifempty SHCTX "Software\@CPACK_PACKAGE_VENDOR@\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@"
 
   Push $INSTDIR\bin
   StrCmp $DO_NOT_ADD_TO_PATH_ "1" doNotRemoveFromPath 0
     Call un.RemoveFromPath
   doNotRemoveFromPath:
 SectionEnd
 
 ;--------------------------------
 ; determine admin versus local install
 ; Is install for "AllUsers" or "JustMe"?
 ; Default to "JustMe" - set to "AllUsers" if admin or on Win9x
 ; This function is used for the very first "custom page" of the installer.
 ; This custom page does not show up visibly, but it executes prior to the
 ; first visible page and sets up $INSTDIR properly...
 ; Choose different default installation folder based on SV_ALLUSERS...
 ; "Program Files" for AllUsers, "My Documents" for JustMe...
 
 Function .onInit
   ; Reads components status for registry
   !insertmacro SectionList "InitSection"
 
   ; check to see if /D has been used to change
   ; the install directory by comparing it to the
   ; install directory that is expected to be the
   ; default
   StrCpy $IS_DEFAULT_INSTALLDIR 0
   StrCmp "$INSTDIR" "@CPACK_NSIS_INSTALL_ROOT@\@CPACK_PACKAGE_INSTALL_DIRECTORY@" 0 +2
     StrCpy $IS_DEFAULT_INSTALLDIR 1
 
   StrCpy $SV_ALLUSERS "JustMe"
   ; if default install dir then change the default
   ; if it is installed for JustMe
   StrCmp "$IS_DEFAULT_INSTALLDIR" "1" 0 +2
     StrCpy $INSTDIR "$DOCUMENTS\@CPACK_PACKAGE_INSTALL_DIRECTORY@"
 
   ClearErrors
   UserInfo::GetName
   IfErrors noLM
   Pop $0
   UserInfo::GetAccountType
   Pop $1
   StrCmp $1 "Admin" 0 +3
     SetShellVarContext all
     ;MessageBox MB_OK 'User "$0" is in the Admin group'
     StrCpy $SV_ALLUSERS "AllUsers"
     Goto done
   StrCmp $1 "Power" 0 +3
     SetShellVarContext all
     ;MessageBox MB_OK 'User "$0" is in the Power Users group'
     StrCpy $SV_ALLUSERS "AllUsers"
     Goto done
 
   noLM:
     StrCpy $SV_ALLUSERS "AllUsers"
     ;Get installation folder from registry if available
 
   done:
   StrCmp $SV_ALLUSERS "AllUsers" 0 +3
     StrCmp "$IS_DEFAULT_INSTALLDIR" "1" 0 +2
       StrCpy $INSTDIR "@CPACK_NSIS_INSTALL_ROOT@\@CPACK_PACKAGE_INSTALL_DIRECTORY@"
 
   StrCmp "@CPACK_NSIS_MODIFY_PATH@" "ON" 0 noOptionsPage
     !insertmacro MUI_INSTALLOPTIONS_EXTRACT "NSIS.InstallOptions.ini"
 
   noOptionsPage:
 FunctionEnd
diff --git a/CMake/mitkFunctionCMakeDoxygenFilterCompile.cmake b/CMake/mitkFunctionCMakeDoxygenFilterCompile.cmake
index 373f666f94..fc8e691b55 100644
--- a/CMake/mitkFunctionCMakeDoxygenFilterCompile.cmake
+++ b/CMake/mitkFunctionCMakeDoxygenFilterCompile.cmake
@@ -1,87 +1,87 @@
 #!
 #! \brief Download and compile a CMake doxygen input filter
 #!
 #! \param OUT <out-file> (optional) Supply an absolute filename for
 #!                       the generated executable.
 #! \param NAMESPACE <namespace> (optional) Supply a C++ namespace in
 #!                              which the generated function declrarations
 #!                              should be wrapped.
 #!
 #! \return This function sets the <code>CMakeDoxygenFilter_EXECUTABLE</code>
 #!         variable to the absolute path of the generated input filter executable
 #!         in the parent scope. If <out-file> is specified, they will be the same.
 #!
-#! This CMake function compiles the http://github.com/saschazelzer/CMakeDoxygenFilter
+#! This CMake function compiles the https://github.com/saschazelzer/CMakeDoxygenFilter
 #! project into a doxygen input filter executable. See
-#! http://github.com/saschazelzer/CMakeDoxygenFilter/blob/master/README for more details.
+#! https://github.com/saschazelzer/CMakeDoxygenFilter/blob/master/README for more details.
 #!
 function(mitkFunctionCMakeDoxygenFilterCompile)
 
   #-------------------- parse function arguments -------------------
 
   set(DEFAULT_ARGS)
   set(prefix "FILTER")
   set(arg_names "OUT;NAMESPACE")
   set(option_names "")
 
   foreach(arg_name ${arg_names})
     set(${prefix}_${arg_name})
   endforeach(arg_name)
 
   foreach(option ${option_names})
     set(${prefix}_${option} FALSE)
   endforeach(option)
 
   set(current_arg_name DEFAULT_ARGS)
   set(current_arg_list)
 
   foreach(arg ${ARGN})
     set(larg_names ${arg_names})
     list(FIND larg_names "${arg}" is_arg_name)
     if(is_arg_name GREATER -1)
       set(${prefix}_${current_arg_name} ${current_arg_list})
       set(current_arg_name "${arg}")
       set(current_arg_list)
     else(is_arg_name GREATER -1)
       set(loption_names ${option_names})
       list(FIND loption_names "${arg}" is_option)
       if(is_option GREATER -1)
         set(${prefix}_${arg} TRUE)
       else(is_option GREATER -1)
         set(current_arg_list ${current_arg_list} "${arg}")
       endif(is_option GREATER -1)
     endif(is_arg_name GREATER -1)
   endforeach(arg ${ARGN})
 
   set(${prefix}_${current_arg_name} ${current_arg_list})
 
   #------------------- finished parsing arguments ----------------------
 
   if(FILTER_OUT)
     set(copy_file "${FILTER_OUT}")
   else()
     set(copy_file "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CMakeDoxygenFilter${CMAKE_EXECUTABLE_SUFFIX}")
   endif()
 
   set(compile_defs "")
   if(FILTER_NAMESPACE)
     set(compile_defs "${compile_defs} -DUSE_NAMESPACE=${FILTER_NAMESPACE}")
   endif()
 
   set(cmake_doxygen_filter_src "${CMAKE_CURRENT_SOURCE_DIR}/CMakeDoxygenFilter.cpp")
 
   try_compile(result_var
               "${CMAKE_CURRENT_BINARY_DIR}"
               "${cmake_doxygen_filter_src}"
               COMPILE_DEFINITIONS ${compile_defs}
               OUTPUT_VARIABLE compile_output
               COPY_FILE ${copy_file}
              )
 
   if(NOT result_var)
     message(FATAL_ERROR "error: Faild to compile ${cmake_doxygen_filter_src} (result: ${result_var})\n${compile_output}")
   endif()
 
   set(CMakeDoxygenFilter_EXECUTABLE "${copy_file}" PARENT_SCOPE)
 
 endfunction()
diff --git a/CMake/mitkFunctionCreateModule.cmake b/CMake/mitkFunctionCreateModule.cmake
index 40e48ef56e..b0a777b921 100644
--- a/CMake/mitkFunctionCreateModule.cmake
+++ b/CMake/mitkFunctionCreateModule.cmake
@@ -1,650 +1,647 @@
 ##################################################################
 #
 # mitk_create_module
 #
 #! Creates a module for the automatic module dependency system within MITK.
 #!
 #! Example:
 #!
 #! \code
 #! mitk_create_module(
 #!     DEPENDS PUBLIC MitkCore
 #!     PACKAGE_DEPENDS
 #!       PRIVATE Qt5|Xml+Networking
 #!       PUBLIC  ITK|Watersheds
 #! \endcode
 #!
 #! The <moduleName> parameter specifies the name of the module which is used
 #! to create a logical target name. The parameter is optional in case the
 #! MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME variable evaluates to TRUE. The
 #! module name will then be derived from the directory name in which this
 #! function is called.
 #!
 #! If set, the following variables will be used to validate the module name:
 #!
 #!   MITK_MODULE_NAME_REGEX_MATCH The module name must match this regular expression.
 #!   MITK_MODULE_NAME_REGEX_NOT_MATCH The module name must not match this regular expression.
 #!
 #! If the MITK_MODULE_NAME_PREFIX variable is set, the module name will be prefixed
 #! with its contents.
 #!
 #! A modules source files are specified in a separate CMake file usually
 #! called files.cmake, located in the module root directory. The
 #! mitk_create_module() macro evaluates the following CMake variables
 #! from the files.cmake file:
 #!
 #! - CPP_FILES A list of .cpp files
 #! - H_FILES A list of .h files without a corresponding .cpp file
 #! - TXX_FILES A list of .txx files
 #! - RESOURCE_FILES A list of files (resources) which are embedded into the module
 #! - MOC_H_FILES A list of Qt header files which should be processed by the MOC
 #! - UI_FILES A list of .ui Qt UI files
 #! - QRC_FILES A list of .qrc Qt resource files
 #! - DOX_FILES A list of .dox Doxygen files
 #!
 #! List of variables available after the function is called:
 #! - MODULE_NAME
 #! - MODULE_TARGET
 #! - MODULE_IS_ENABLED
 #!
 #! \sa mitk_create_executable
 #!
 #! Parameters (all optional):
 #!
 #! \param <moduleName> The module name (also used as target name)
 #! \param FILES_CMAKE File name of a CMake file setting source list variables
 #!        (defaults to files.cmake)
 #! \param VERSION Module version number, e.g. "1.2.0"
 #! \param AUTOLOAD_WITH A module target name identifying the module which will
 #!        trigger the automatic loading of this module
 #! \param DEPRECATED_SINCE Marks this modules as deprecated since <arg>
 #! \param DESCRIPTION A description for this module
 #!
 #! Multi-value Parameters (all optional):
 #!
 
 #! \param INCLUDE_DIRS Include directories for this module:
 #!        \verbatim
 #! [[PUBLIC|PRIVATE|INTERFACE] <dir1>...]...
 #! \endverbatim
 #!        The default scope for include directories is PUBLIC.
 #! \param DEPENDS List of module dependencies:
 #!        \verbatim
 #! [[PUBLIC|PRIVATE|INTERFACE] <module1>...]...
 #! \endverbatim
 #!        The default scope for module dependencies is PUBLIC.
 #! \param PACKAGE_DEPENDS List of public packages dependencies (e.g. Qt, VTK, etc.).
 #!        Package dependencies have the following syntax:
 #!        \verbatim
 #! [PUBLIC|PRIVATE|INTERFACE] PACKAGE[|COMPONENT1[+COMPONENT2]...]
 #! \endverbatim
 #!        The default scope for package dependencies is PRIVATE.
 #! \param ADDITIONAL_LIBS List of additional private libraries linked to this module.
 #!        The folder containing the library will be added to the global list of library search paths.
 #! \param CPP_FILES List of source files for this module. If the list is non-empty,
 #!        the module does not need to provide a files.cmake file or FILES_CMAKE argument.
 #! \param H_FILES List of public header files for this module. It is recommended to use
 #!        a files.cmake file instead.
 #!
 #! Options (optional)
 #!
 #! \param FORCE_STATIC Force building this module as a static library
 #! \param GCC_DEFAULT_VISIBILITY Do not use gcc visibility flags - all
 #!        symbols will be exported
 #! \param NO_INIT Do not create CppMicroServices initialization code
 #! \param NO_FEATURE_INFO Do not create a feature info by calling add_feature_info()
 #! \param WARNINGS_NO_ERRORS Do not treat compiler warnings as errors
 #
 ##################################################################
 function(mitk_create_module)
 
   set(_macro_params
       VERSION                # module version number, e.g. "1.2.0"
       EXPORT_DEFINE          # export macro name for public symbols of this module (DEPRECATED)
       AUTOLOAD_WITH          # a module target name identifying the module which will trigger the
                              # automatic loading of this module
       FILES_CMAKE            # file name of a CMake file setting source list variables
                              # (defaults to files.cmake)
       DEPRECATED_SINCE       # marks this modules as deprecated
       DESCRIPTION            # a description for this module
      )
 
   set(_macro_multiparams
       SUBPROJECTS            # list of CDash labels (deprecated)
       INCLUDE_DIRS           # include directories: [PUBLIC|PRIVATE|INTERFACE] <list>
       INTERNAL_INCLUDE_DIRS  # include dirs internal to this module (DEPRECATED)
       DEPENDS                # list of modules this module depends on: [PUBLIC|PRIVATE|INTERFACE] <list>
       DEPENDS_INTERNAL       # list of modules this module internally depends on (DEPRECATED)
       PACKAGE_DEPENDS        # list of "packages this module depends on (e.g. Qt, VTK, etc.): [PUBLIC|PRIVATE|INTERFACE] <package-list>
       TARGET_DEPENDS         # list of CMake targets this module should depend on: [PUBLIC|PRIVATE|INTERFACE] <list>
       ADDITIONAL_LIBS        # list of addidtional private libraries linked to this module.
       CPP_FILES              # list of cpp files
       H_FILES                # list of header files: [PUBLIC|PRIVATE] <list>
      )
 
   set(_macro_options
       FORCE_STATIC           # force building this module as a static library
       HEADERS_ONLY           # this module is a headers-only library
       GCC_DEFAULT_VISIBILITY # do not use gcc visibility flags - all symbols will be exported
       NO_DEFAULT_INCLUDE_DIRS # do not add default include directories like "include" or "."
       NO_INIT                # do not create CppMicroServices initialization code
       NO_FEATURE_INFO        # do not create a feature info by calling add_feature_info()
       WARNINGS_NO_ERRORS     # do not treat compiler warnings as errors
       EXECUTABLE             # create an executable; do not use directly, use mitk_create_executable() instead
       C_MODULE               # compile all source files as C sources
       CXX_MODULE             # compile all source files as C++ sources
      )
 
   cmake_parse_arguments(MODULE "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
 
   set(MODULE_NAME ${MODULE_UNPARSED_ARGUMENTS})
 
   # -----------------------------------------------------------------
   # Sanity checks
 
   if(NOT MODULE_NAME)
     if(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME)
       get_filename_component(MODULE_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
     else()
       message(SEND_ERROR "The module name must not be empty")
     endif()
   endif()
 
   set(_deprecated_args INTERNAL_INCLUDE_DIRS DEPENDS_INTERNAL EXPORT_DEFINE HEADERS_ONLY)
   foreach(_deprecated_arg ${_deprecated_args})
     if(MODULE_${_deprecated_arg})
       message(WARNING "The ${_deprecated_arg} argument is deprecated")
     endif()
   endforeach()
 
   set(_module_type module)
   set(_Module_type Module)
   if(MODULE_EXECUTABLE)
     set(_module_type executable)
     set(_Module_type Executable)
   endif()
 
   if(MITK_MODULE_NAME_REGEX_MATCH)
     if(NOT ${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_MATCH})
       message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" does not match the regular expression \"${MITK_MODULE_NAME_REGEX_MATCH}\".")
     endif()
   endif()
   if(MITK_MODULE_NAME_REGEX_NOT_MATCH)
     if(${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_NOT_MATCH})
       message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" must not match the regular expression \"${MITK_MODULE_NAME_REGEX_NOT_MATCH}\".")
     endif()
   endif()
 
   if(MITK_MODULE_NAME_PREFIX AND NOT MODULE_NAME MATCHES "^${MITK_MODULE_NAME_PREFIX}.*$")
     set(MODULE_NAME "${MITK_MODULE_NAME_PREFIX}${MODULE_NAME}")
   endif()
 
   if(NOT MODULE_FILES_CMAKE)
     set(MODULE_FILES_CMAKE files.cmake)
   endif()
   if(NOT IS_ABSOLUTE ${MODULE_FILES_CMAKE})
     set(MODULE_FILES_CMAKE ${CMAKE_CURRENT_SOURCE_DIR}/${MODULE_FILES_CMAKE})
   endif()
 
   # -----------------------------------------------------------------
   # Check if module should be build
 
   set(MODULE_TARGET ${MODULE_NAME})
 
   # assume worst case
   set(MODULE_IS_ENABLED 0)
   # first we check if we have an explicit module build list
   if(MITK_MODULES_TO_BUILD)
     list(FIND MITK_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX)
     if(_MOD_INDEX EQUAL -1)
       set(MODULE_IS_EXCLUDED 1)
     endif()
   endif()
 
   if(NOT MODULE_IS_EXCLUDED)
     # first of all we check for the dependencies
     _mitk_parse_package_args(${MODULE_PACKAGE_DEPENDS})
     mitk_check_module_dependencies(MODULES ${MODULE_DEPENDS}
                                    PACKAGES ${PACKAGE_NAMES}
                                    MISSING_DEPENDENCIES_VAR _MISSING_DEP
                                    PACKAGE_DEPENDENCIES_VAR PACKAGE_NAMES)
 
     if(_MISSING_DEP)
       if(MODULE_NO_FEATURE_INFO)
         message("${_Module_type} ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}")
       endif()
       set(MODULE_IS_ENABLED 0)
     else()
       foreach(dep ${MODULE_DEPENDS})
           if(TARGET ${dep})
             get_target_property(AUTLOAD_DEP ${dep} MITK_AUTOLOAD_DIRECTORY)
             if (AUTLOAD_DEP)
               message(SEND_ERROR "Module \"${MODULE_NAME}\" has an invalid dependency on autoload module \"${dep}\". Check MITK_CREATE_MODULE usage for \"${MODULE_NAME}\".")
             endif()
           endif()
       endforeach(dep)
 
       set(MODULE_IS_ENABLED 1)
       # now check for every package if it is enabled. This overlaps a bit with
       # MITK_CHECK_MODULE ...
       foreach(_package ${PACKAGE_NAMES})
         if((DEFINED MITK_USE_${_package}) AND NOT (MITK_USE_${_package}))
           message("${_Module_type} ${MODULE_NAME} won't be built. Turn on MITK_USE_${_package} if you want to use it.")
           set(MODULE_IS_ENABLED 0)
           break()
         endif()
       endforeach()
     endif()
   endif()
 
   # -----------------------------------------------------------------
   # Start creating the module
 
   if(MODULE_IS_ENABLED)
 
     # clear variables defined in files.cmake
     set(RESOURCE_FILES )
     set(CPP_FILES )
     set(H_FILES )
     set(TXX_FILES )
     set(DOX_FILES )
     set(UI_FILES )
     set(MOC_H_FILES )
     set(QRC_FILES )
 
     # clear other variables
     set(Q${KITNAME}_GENERATED_CPP )
     set(Q${KITNAME}_GENERATED_MOC_CPP )
     set(Q${KITNAME}_GENERATED_QRC_CPP )
     set(Q${KITNAME}_GENERATED_UI_CPP )
 
     # check and set-up auto-loading
     if(MODULE_AUTOLOAD_WITH)
       if(NOT TARGET "${MODULE_AUTOLOAD_WITH}")
         message(SEND_ERROR "The module target \"${MODULE_AUTOLOAD_WITH}\" specified as the auto-loading module for \"${MODULE_NAME}\" does not exist")
       endif()
     endif()
     set(_module_autoload_meta_target "${CMAKE_PROJECT_NAME}-autoload")
     # create a meta-target if it does not already exist
     if(NOT TARGET ${_module_autoload_meta_target})
       add_custom_target(${_module_autoload_meta_target})
       set_property(TARGET ${_module_autoload_meta_target} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Modules/Autoload")
     endif()
 
     if(NOT MODULE_EXPORT_DEFINE)
       set(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT)
     endif()
 
     if(MITK_GENERATE_MODULE_DOT)
       message("MODULEDOTNAME ${MODULE_NAME}")
       foreach(dep ${MODULE_DEPENDS})
         message("MODULEDOT \"${MODULE_NAME}\" -> \"${dep}\" ; ")
       endforeach(dep)
     endif(MITK_GENERATE_MODULE_DOT)
 
     if (EXISTS ${MODULE_FILES_CMAKE})
       include(${MODULE_FILES_CMAKE})
     endif()
 
     if(MODULE_CPP_FILES)
       list(APPEND CPP_FILES ${MODULE_CPP_FILES})
     endif()
 
     if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src")
       # Preprend the "src" directory to the cpp file list
       set(_cpp_files ${CPP_FILES})
       set(CPP_FILES )
       foreach(_cpp_file ${_cpp_files})
         list(APPEND CPP_FILES "src/${_cpp_file}")
       endforeach()
     endif()
 
     if(CPP_FILES OR RESOURCE_FILES OR UI_FILES OR MOC_H_FILES OR QRC_FILES)
       set(MODULE_HEADERS_ONLY 0)
       if(MODULE_C_MODULE)
         set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE C)
       elseif(MODULE_CXX_MODULE)
         set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE CXX)
       endif()
     else()
       set(MODULE_HEADERS_ONLY 1)
       if(MODULE_AUTOLOAD_WITH)
         message(SEND_ERROR "A headers only module cannot be auto-loaded")
       endif()
     endif()
 
     set(module_c_flags )
     set(module_c_flags_debug )
     set(module_c_flags_release )
     set(module_cxx_flags )
     set(module_cxx_flags_debug )
     set(module_cxx_flags_release )
 
     if(MODULE_GCC_DEFAULT_VISIBILITY OR NOT CMAKE_COMPILER_IS_GNUCXX)
       # We only support hidden visibility for gcc for now. Clang still has troubles with
       # correctly marking template declarations and explicit template instantiations as exported.
-      # See http://comments.gmane.org/gmane.comp.compilers.clang.scm/50028
-      # and http://llvm.org/bugs/show_bug.cgi?id=10113
       set(CMAKE_CXX_VISIBILITY_PRESET default)
       set(CMAKE_VISIBILITY_INLINES_HIDDEN 0)
     else()
       set(CMAKE_CXX_VISIBILITY_PRESET hidden)
       set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
     endif()
 
     if(NOT MODULE_WARNINGS_NO_ERRORS)
       if(MSVC_VERSION)
         mitkFunctionCheckCAndCXXCompilerFlags("/WX" module_c_flags module_cxx_flags)
 	# this would turn on unused parameter warnings, but unfortunately MSVC cannot
 	# distinguish yet between internal and external headers so this would be triggered
 	# a lot by external code. There is support for it on the way so this line could be
 	# reactivated after https://gitlab.kitware.com/cmake/cmake/issues/17904 has been fixed.
         # mitkFunctionCheckCAndCXXCompilerFlags("/w34100" module_c_flags module_cxx_flags)
       else()
         mitkFunctionCheckCAndCXXCompilerFlags(-Werror module_c_flags module_cxx_flags)
 
         # The flag "c++0x-static-nonintegral-init" has been renamed in newer Clang
-        # versions to "static-member-init", see
-        # http://clang-developers.42468.n3.nabble.com/Wc-0x-static-nonintegral-init-gone-td3999651.html
+        # versions to "static-member-init"
         #
         # Also, older Clang and seemingly all gcc versions do not warn if unknown
         # "-no-*" flags are used, so CMake will happily append any -Wno-* flag to the
         # command line. This may get confusing if unrelated compiler errors happen and
         # the error output then additionally contains errors about unknown flags (which
         # is not the case if there were no compile errors).
         #
         # So instead of using -Wno-* we use -Wno-error=*, which will be properly rejected by
         # the compiler and if applicable, prints the specific warning as a real warning and
         # not as an error (although -Werror was given).
 
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=c++0x-static-nonintegral-init" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=static-member-init" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=unknown-warning" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=gnu" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=class-memaccess" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=inconsistent-missing-override" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=deprecated-copy" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=cast-function-type" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=deprecated-declarations" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=type-limits" module_c_flags module_cxx_flags)
       endif()
     endif()
 
     if(MODULE_FORCE_STATIC)
       set(_STATIC STATIC)
     else()
       set(_STATIC )
     endif(MODULE_FORCE_STATIC)
 
     if(NOT MODULE_HEADERS_ONLY)
       if(NOT MODULE_NO_INIT OR RESOURCE_FILES)
         find_package(CppMicroServices QUIET NO_MODULE REQUIRED)
       endif()
       if(NOT MODULE_NO_INIT)
         usFunctionGenerateModuleInit(CPP_FILES)
       endif()
 
       set(binary_res_files )
       set(source_res_files )
       if(RESOURCE_FILES)
         if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/resource")
           set(res_dir resource)
         elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Resources")
           set(res_dir Resources)
         else()
           message(SEND_ERROR "Resources specified but ${CMAKE_CURRENT_SOURCE_DIR}/resource directory not found.")
         endif()
         foreach(res_file ${RESOURCE_FILES})
           if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}/${res_file})
             list(APPEND binary_res_files "${res_file}")
           else()
             list(APPEND source_res_files "${res_file}")
           endif()
         endforeach()
 
         # Add a source level dependencies on resource files
         usFunctionGetResourceSource(TARGET ${MODULE_TARGET} OUT CPP_FILES)
       endif()
     endif()
 
     if(MITK_USE_Qt5)
       if(UI_FILES)
         qt5_wrap_ui(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES})
       endif()
       if(MOC_H_FILES)
         qt5_wrap_cpp(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES} OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
       endif()
       if(QRC_FILES)
         qt5_add_resources(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES})
       endif()
     endif()
 
     set(Q${KITNAME}_GENERATED_CPP ${Q${KITNAME}_GENERATED_CPP} ${Q${KITNAME}_GENERATED_UI_CPP} ${Q${KITNAME}_GENERATED_MOC_CPP} ${Q${KITNAME}_GENERATED_QRC_CPP})
 
     mitkFunctionOrganizeSources(
       SOURCE ${CPP_FILES}
       HEADER ${H_FILES}
       TXX ${TXX_FILES}
       DOC ${DOX_FILES}
       UI ${UI_FILES}
       QRC ${QRC_FILES}
       MOC ${Q${KITNAME}_GENERATED_MOC_CPP}
       GEN_QRC ${Q${KITNAME}_GENERATED_QRC_CPP}
       GEN_UI ${Q${KITNAME}_GENERATED_UI_CPP}
       )
 
     set(coverage_sources
         ${CPP_FILES} ${H_FILES} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES}
         ${TOOL_CPPS} ${TOOL_GUI_CPPS})
 
     # ---------------------------------------------------------------
     # Create the actual module target
 
     if(MODULE_HEADERS_ONLY)
       add_library(${MODULE_TARGET} INTERFACE)
       # INTERFACE_LIBRARY targets may only have whitelisted properties. The property "FOLDER" is not allowed.
       # set_property(TARGET ${MODULE_TARGET} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Modules")
     else()
       if(MODULE_EXECUTABLE)
         if(MITK_SHOW_CONSOLE_WINDOW)
           set(_SHOW_CONSOLE_OPTION "")
         else()
           set(_SHOW_CONSOLE_OPTION WIN32)
         endif()
         add_executable(${MODULE_TARGET} ${_SHOW_CONSOLE_OPTION}
                        ${MODULE_CPP_FILES} ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
                        ${DOX_FILES} ${UI_FILES} ${QRC_FILES} ${WINDOWS_ICON_RESOURCE_FILE})
         if(WIN32 AND MITK_UTF8)
           mitk_add_manifest(${MODULE_TARGET})
         endif()
         set_property(TARGET ${MODULE_TARGET} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Modules/Executables")
         set(_us_module_name main)
       else()
         add_library(${MODULE_TARGET} ${_STATIC}
                     ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
                     ${DOX_FILES} ${UI_FILES} ${QRC_FILES})
         set_property(TARGET ${MODULE_TARGET} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Modules")
         set(_us_module_name ${MODULE_TARGET})
       endif()
 
       # Apply properties to the module target.
       target_compile_definitions(${MODULE_TARGET} PRIVATE US_MODULE_NAME=${_us_module_name})
       if(MODULE_C_MODULE)
         if(module_c_flags)
           string(REPLACE " " ";" module_c_flags "${module_c_flags}")
           target_compile_options(${MODULE_TARGET} PRIVATE ${module_c_flags})
         endif()
         if(module_c_flags_debug)
           string(REPLACE " " ";" module_c_flags_debug "${module_c_flags_debug}")
           target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_c_flags_debug}>)
         endif()
         if(module_c_flags_release)
           string(REPLACE " " ";" module_c_flags_release "${module_c_flags_release}")
           target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_c_flags_release}>)
         endif()
       else()
         if(module_cxx_flags)
           string(REPLACE " " ";" module_cxx_flags "${module_cxx_flags}")
           target_compile_options(${MODULE_TARGET} PRIVATE ${module_cxx_flags})
         endif()
         if(module_cxx_flags_debug)
           string(REPLACE " " ";" module_cxx_flags_debug "${module_cxx_flags_debug}")
           target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_cxx_flags_debug}>)
         endif()
         if(module_cxx_flags_release)
           string(REPLACE " " ";" module_cxx_flags_release "${module_cxx_flags_release}")
           target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_cxx_flags_release}>)
         endif()
       endif()
 
       set_property(TARGET ${MODULE_TARGET} PROPERTY US_MODULE_NAME ${_us_module_name})
 
       # Add additional library search directories to a global property which
       # can be evaluated by other CMake macros, e.g. our install scripts.
       if(MODULE_ADDITIONAL_LIBS)
         target_link_libraries(${MODULE_TARGET} PRIVATE ${MODULE_ADDITIONAL_LIBS})
         get_property(_mitk_additional_library_search_paths GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
         foreach(_lib_filepath ${MODULE_ADDITIONAL_LIBS})
           get_filename_component(_search_path "${_lib_filepath}" PATH)
           if(_search_path)
             list(APPEND _mitk_additional_library_search_paths "${_search_path}")
           endif()
         endforeach()
         if(_mitk_additional_library_search_paths)
           list(REMOVE_DUPLICATES _mitk_additional_library_search_paths)
           set_property(GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS ${_mitk_additional_library_search_paths})
         endif()
       endif()
 
       # add the target name to a global property which is used in the top-level
       # CMakeLists.txt file to export the target
       set_property(GLOBAL APPEND PROPERTY MITK_MODULE_TARGETS ${MODULE_TARGET})
       if(MODULE_AUTOLOAD_WITH)
         # for auto-loaded modules, adapt the output directory
         add_dependencies(${_module_autoload_meta_target} ${MODULE_TARGET})
         if(WIN32)
           set(_module_output_prop RUNTIME_OUTPUT_DIRECTORY)
         else()
           set(_module_output_prop LIBRARY_OUTPUT_DIRECTORY)
         endif()
         set(_module_output_dir ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
         get_target_property(_module_is_imported ${MODULE_AUTOLOAD_WITH} IMPORTED)
         if(NOT _module_is_imported)
           # if the auto-loading module is not imported, get its location
           # and put the auto-load module relative to it.
           get_target_property(_module_output_dir ${MODULE_AUTOLOAD_WITH} ${_module_output_prop})
           set_target_properties(${MODULE_TARGET} PROPERTIES
                                 ${_module_output_prop} ${_module_output_dir}/${MODULE_AUTOLOAD_WITH})
         else()
           set_target_properties(${MODULE_TARGET} PROPERTIES
                                 ${_module_output_prop} ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
         endif()
         set_target_properties(${MODULE_TARGET} PROPERTIES
                               MITK_AUTOLOAD_DIRECTORY ${MODULE_AUTOLOAD_WITH})
 
         # add the auto-load module name as a property
         set_property(TARGET ${MODULE_AUTOLOAD_WITH} APPEND PROPERTY MITK_AUTOLOAD_TARGETS ${MODULE_TARGET})
       endif()
 
       if(binary_res_files)
         usFunctionAddResources(TARGET ${MODULE_TARGET}
                                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}
                                FILES ${binary_res_files})
       endif()
       if(source_res_files)
         usFunctionAddResources(TARGET ${MODULE_TARGET}
                                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${res_dir}
                                FILES ${source_res_files})
       endif()
       if(binary_res_files OR source_res_files)
         usFunctionEmbedResources(TARGET ${MODULE_TARGET})
       endif()
 
       if(MODULE_DEPRECATED_SINCE)
         set_property(TARGET ${MODULE_TARGET} PROPERTY MITK_MODULE_DEPRECATED_SINCE ${MODULE_DEPRECATED_SINCE})
       endif()
 
       # create export macros
       if (NOT MODULE_EXECUTABLE)
         set(_export_macro_name )
         if(MITK_LEGACY_EXPORT_MACRO_NAME)
           set(_export_macro_names
             EXPORT_MACRO_NAME ${MODULE_EXPORT_DEFINE}
             NO_EXPORT_MACRO_NAME ${MODULE_NAME}_NO_EXPORT
             DEPRECATED_MACRO_NAME ${MODULE_NAME}_DEPRECATED
             NO_DEPRECATED_MACRO_NAME ${MODULE_NAME}_NO_DEPRECATED
           )
         endif()
         generate_export_header(${MODULE_NAME}
           ${_export_macro_names}
           EXPORT_FILE_NAME ${MODULE_NAME}Exports.h
         )
       endif()
 
       target_include_directories(${MODULE_TARGET} PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
 
     endif()
 
     # ---------------------------------------------------------------
     # Properties for both header-only and compiled modules
 
     if(MODULE_HEADERS_ONLY)
       set(_module_property_type INTERFACE)
     else()
       set(_module_property_type PUBLIC)
     endif()
 
     if(MODULE_TARGET_DEPENDS)
       target_link_libraries(${MODULE_TARGET} ${MODULE_TARGET_DEPENDS})
     endif()
 
     set(DEPENDS "${MODULE_DEPENDS}")
     if(NOT MODULE_NO_INIT AND NOT MODULE_HEADERS_ONLY)
       # Add a CppMicroServices dependency implicitly, since it is
       # needed for the generated "module initialization" code.
       set(DEPENDS "CppMicroServices;${DEPENDS}")
     endif()
     if(DEPENDS OR MODULE_PACKAGE_DEPENDS)
       mitk_use_modules(TARGET ${MODULE_TARGET}
                        MODULES ${DEPENDS}
                        PACKAGES ${MODULE_PACKAGE_DEPENDS}
                       )
     endif()
 
     # add include directories
     if(MODULE_INTERNAL_INCLUDE_DIRS)
       target_include_directories(${MODULE_TARGET} PRIVATE ${MODULE_INTERNAL_INCLUDE_DIRS})
     endif()
     if(NOT MODULE_NO_DEFAULT_INCLUDE_DIRS)
       if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/include)
         target_include_directories(${MODULE_TARGET} ${_module_property_type} include)
       else()
         target_include_directories(${MODULE_TARGET} ${_module_property_type} .)
       endif()
       if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/src)
         target_include_directories(${MODULE_TARGET} PRIVATE src)
       endif()
     endif()
     target_include_directories(${MODULE_TARGET} ${_module_property_type} ${MODULE_INCLUDE_DIRS})
 
   endif()
 
   # -----------------------------------------------------------------
   # Record missing dependency information
 
   if(_MISSING_DEP)
     if(MODULE_DESCRIPTION)
       set(MODULE_DESCRIPTION "${MODULE_DESCRIPTION} (missing dependencies: ${_MISSING_DEP})")
     else()
       set(MODULE_DESCRIPTION "(missing dependencies: ${_MISSING_DEP})")
     endif()
   endif()
   if(NOT MODULE_NO_FEATURE_INFO)
     add_feature_info(${MODULE_NAME} MODULE_IS_ENABLED "${MODULE_DESCRIPTION}")
   endif()
 
   set(MODULE_NAME ${MODULE_NAME} PARENT_SCOPE)
   set(MODULE_TARGET ${MODULE_TARGET} PARENT_SCOPE)
   set(MODULE_IS_ENABLED ${MODULE_IS_ENABLED} PARENT_SCOPE)
 
 endfunction()
diff --git a/CMake/mitkFunctionGetGccVersion.cmake b/CMake/mitkFunctionGetGccVersion.cmake
index 381341eac0..972a2596eb 100644
--- a/CMake/mitkFunctionGetGccVersion.cmake
+++ b/CMake/mitkFunctionGetGccVersion.cmake
@@ -1,38 +1,38 @@
 ###########################################################################
 #
 #  Library:   CTK
 #
 #  Copyright (c) Kitware Inc.
 #
 #  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.commontk.org/LICENSE
+#      https://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.
 #
 ###########################################################################
 
 #! \brief Get the gcc version
 function(mitkFunctionGetGccVersion path_to_gcc output_var)
   if(CMAKE_COMPILER_IS_GNUCXX)
     execute_process(
       COMMAND ${path_to_gcc} -dumpversion
       RESULT_VARIABLE result
       OUTPUT_VARIABLE output
       ERROR_VARIABLE error
       OUTPUT_STRIP_TRAILING_WHITESPACE
       ERROR_STRIP_TRAILING_WHITESPACE
       )
     if(result)
       message(FATAL_ERROR "Failed to obtain compiler version running [${path_to_gcc} -dumpversion]: ${error}")
     endif()
     set(${output_var} ${output} PARENT_SCOPE)
   endif()
 endfunction()
 
diff --git a/CMake/mitkTargetLinkLibrariesWithDynamicLookup.cmake b/CMake/mitkTargetLinkLibrariesWithDynamicLookup.cmake
index 941d25044e..52eea078a2 100644
--- a/CMake/mitkTargetLinkLibrariesWithDynamicLookup.cmake
+++ b/CMake/mitkTargetLinkLibrariesWithDynamicLookup.cmake
@@ -1,581 +1,581 @@
 #.rst:
 #
 # Public Functions
 # ^^^^^^^^^^^^^^^^
 #
 # The following functions are defined:
 #
 # .. cmake:command:: mitk_target_link_libraries_with_dynamic_lookup
 #
 # ::
 #
 #     mitk_target_link_libraries_with_dynamic_lookup(<Target> [<Libraries>])
 #
 #
 # Useful to "weakly" link a loadable module. For example, it should be used
 # when compiling a loadable module when the symbols should be resolve from
 # the run-time environment where the module is loaded, and not a specific
 # system library.
 #
 # Like proper linking, except that the given ``<Libraries>`` are not necessarily
 # linked. Instead, the ``<Target>`` is produced in a manner that allows for
 # symbols unresolved within it to be resolved at runtime, presumably by the
 # given ``<Libraries>``.  If such a target can be produced, the provided
 # ``<Libraries>`` are not actually linked.
 #
 # It links a library to a target such that the symbols are resolved at
 # run-time not link-time.
 #
 # The linker is checked to see if it supports undefined
 # symbols when linking a shared library. If it does then the library
 # is not linked when specified with this function.
 #
 # On platforms that do not support weak-linking, this function works just
 # like ``mitk_target_link_libraries``.
 #
 # .. note::
 #
 #     For OSX it uses ``undefined dynamic_lookup``. This is similar to using
 #     ``-shared`` on Linux where undefined symbols are ignored.
 #
-#     For more details, see `blog <http://blog.tim-smith.us/2015/09/python-extension-modules-os-x/>`_
+#     For more details, see `blog <https://blog.tim-smith.us/2015/09/python-extension-modules-os-x/>`_
 #     from Tim D. Smith.
 #
 #
 # .. cmake:command:: mitk_check_dynamic_lookup
 #
 # Check if the linker requires a command line flag to allow leaving symbols
 # unresolved when producing a target of type ``<TargetType>`` that is
 # weakly-linked against a dependency of type ``<LibType>``.
 #
 # ``<TargetType>``
 #   can be one of "STATIC", "SHARED", "MODULE", or "EXE".
 #
 # ``<LibType>``
 #   can be one of "STATIC", "SHARED", or "MODULE".
 #
 # Long signature:
 #
 # ::
 #
 #     mitk_check_dynamic_lookup(<TargetType>
 #                          <LibType>
 #                          <ResultVar>
 #                          [<LinkFlagsVar>])
 #
 #
 # Short signature:
 #
 # ::
 #
 #     mitk_check_dynamic_lookup(<ResultVar>) # <TargetType> set to "MODULE"
 #                                       # <LibType> set to "SHARED"
 #
 #
 # The result is cached between invocations and recomputed only when the value
 # of CMake's linker flag list changes; ``CMAKE_STATIC_LINKER_FLAGS`` if
 # ``<TargetType>`` is "STATIC", and ``CMAKE_SHARED_LINKER_FLAGS`` otherwise.
 #
 #
 # Defined variables:
 #
 # ``<ResultVar>``
 #   Whether the current C toolchain supports weak-linking for target binaries of
 #   type ``<TargetType>`` that are weakly-linked against a dependency target of
 #   type ``<LibType>``.
 #
 # ``<LinkFlagsVar>``
 #   List of flags to add to the linker command to produce a working target
 #   binary of type ``<TargetType>`` that is weakly-linked against a dependency
 #   target of type ``<LibType>``.
 #
 # ``HAS_DYNAMIC_LOOKUP_<TargetType>_<LibType>``
 #   Cached, global alias for ``<ResultVar>``
 #
 # ``DYNAMIC_LOOKUP_FLAGS_<TargetType>_<LibType>``
 #   Cached, global alias for ``<LinkFlagsVar>``
 #
 #
 # Private Functions
 # ^^^^^^^^^^^^^^^^^
 #
 # The following private functions are defined:
 #
 # .. warning:: These functions are not part of the scikit-build API. They
 #     exist purely as an implementation detail and may change from version
 #     to version without notice, or even be removed.
 #
 #     We mean it.
 #
 #
 # .. cmake:command:: _get_target_type
 #
 # ::
 #
 #     _get_target_type(<ResultVar> <Target>)
 #
 #
 # Shorthand for querying an abbreviated version of the target type
 # of the given ``<Target>``.
 #
 # ``<ResultVar>`` is set to:
 #
 # - "STATIC" for a STATIC_LIBRARY,
 # - "SHARED" for a SHARED_LIBRARY,
 # - "MODULE" for a MODULE_LIBRARY,
 # - and "EXE" for an EXECUTABLE.
 #
 # Defined variables:
 #
 # ``<ResultVar>``
 #   The abbreviated version of the ``<Target>``'s type.
 #
 #
 # .. cmake:command:: _test_weak_link_project
 #
 # ::
 #
 #     _test_weak_link_project(<TargetType>
 #                             <LibType>
 #                             <ResultVar>
 #                             <LinkFlagsVar>)
 #
 #
 # Attempt to compile and run a test project where a target of type
 # ``<TargetType>`` is weakly-linked against a dependency of type ``<LibType>``:
 #
 # - ``<TargetType>`` can be one of "STATIC", "SHARED", "MODULE", or "EXE".
 # - ``<LibType>`` can be one of "STATIC", "SHARED", or "MODULE".
 #
 # Defined variables:
 #
 # ``<ResultVar>``
 #   Whether the current C toolchain can produce a working target binary of type
 #   ``<TargetType>`` that is weakly-linked against a dependency target of type
 #   ``<LibType>``.
 #
 # ``<LinkFlagsVar>``
 #   List of flags to add to the linker command to produce a working target
 #   binary of type ``<TargetType>`` that is weakly-linked against a dependency
 #   target of type ``<LibType>``.
 #
 
 function(_get_target_type result_var target)
   set(target_type "SHARED_LIBRARY")
   if(TARGET ${target})
     get_property(target_type TARGET ${target} PROPERTY TYPE)
   endif()
 
   set(result "STATIC")
 
   if(target_type STREQUAL "STATIC_LIBRARY")
     set(result "STATIC")
   endif()
 
   if(target_type STREQUAL "SHARED_LIBRARY")
     set(result "SHARED")
   endif()
 
   if(target_type STREQUAL "MODULE_LIBRARY")
     set(result "MODULE")
   endif()
 
   if(target_type STREQUAL "EXECUTABLE")
     set(result "EXE")
   endif()
 
   set(${result_var} ${result} PARENT_SCOPE)
 endfunction()
 
 
 function(_test_weak_link_project
          target_type
          lib_type
          can_weak_link_var
          project_name)
 
   set(gnu_ld_ignore      "-Wl,--unresolved-symbols=ignore-all")
   set(osx_dynamic_lookup           "-undefined dynamic_lookup")
   set(no_flag                                               "")
 
   foreach(link_flag_spec gnu_ld_ignore osx_dynamic_lookup no_flag)
     set(link_flag "${${link_flag_spec}}")
 
     set(test_project_dir "${PROJECT_BINARY_DIR}/CMakeTmp")
     set(test_project_dir "${test_project_dir}/${project_name}")
     set(test_project_dir "${test_project_dir}/${link_flag_spec}")
     set(test_project_dir "${test_project_dir}/${target_type}")
     set(test_project_dir "${test_project_dir}/${lib_type}")
 
     set(test_project_src_dir "${test_project_dir}/src")
     set(test_project_bin_dir "${test_project_dir}/build")
 
     file(MAKE_DIRECTORY ${test_project_src_dir})
     file(MAKE_DIRECTORY ${test_project_bin_dir})
 
     set(mod_type "STATIC")
     set(link_mod_lib TRUE)
     set(link_exe_lib TRUE)
     set(link_exe_mod FALSE)
 
     if("${target_type}" STREQUAL "EXE")
       set(link_exe_lib FALSE)
       set(link_exe_mod TRUE)
     else()
       set(mod_type "${target_type}")
     endif()
 
     if("${mod_type}" STREQUAL "MODULE")
       set(link_mod_lib FALSE)
     endif()
 
 
     file(WRITE "${test_project_src_dir}/CMakeLists.txt" "
       cmake_minimum_required(VERSION ${CMAKE_VERSION})
       project(${project_name} C)
 
       include_directories(${test_project_src_dir})
 
       add_library(number ${lib_type} number.c)
       add_library(counter ${mod_type} counter.c)
     ")
 
     if("${mod_type}" STREQUAL "MODULE")
       file(APPEND "${test_project_src_dir}/CMakeLists.txt" "
         set_target_properties(counter PROPERTIES PREFIX \"\")
       ")
     endif()
 
     if(link_mod_lib)
       file(APPEND "${test_project_src_dir}/CMakeLists.txt" "
         target_link_libraries(counter number)
       ")
     elseif(NOT link_flag STREQUAL "")
       file(APPEND "${test_project_src_dir}/CMakeLists.txt" "
         set_target_properties(counter PROPERTIES LINK_FLAGS \"${link_flag}\")
       ")
     endif()
 
     file(APPEND "${test_project_src_dir}/CMakeLists.txt" "
       add_executable(main main.c)
     ")
 
     if(link_exe_lib)
       file(APPEND "${test_project_src_dir}/CMakeLists.txt" "
         target_link_libraries(main number)
       ")
     elseif(NOT link_flag STREQUAL "")
       file(APPEND "${test_project_src_dir}/CMakeLists.txt" "
         target_link_libraries(main \"${link_flag}\")
       ")
     endif()
 
     if(link_exe_mod)
       file(APPEND "${test_project_src_dir}/CMakeLists.txt" "
         target_link_libraries(main counter)
       ")
     else()
       file(APPEND "${test_project_src_dir}/CMakeLists.txt" "
         target_link_libraries(main \"${CMAKE_DL_LIBS}\")
       ")
     endif()
 
     file(WRITE "${test_project_src_dir}/number.c" "
       #include <number.h>
 
       static int _number;
       void set_number(int number) { _number = number; }
       int get_number() { return _number; }
     ")
 
     file(WRITE "${test_project_src_dir}/number.h" "
       #ifndef _NUMBER_H
       #define _NUMBER_H
       extern void set_number(int);
       extern int get_number(void);
       #endif
     ")
 
     file(WRITE "${test_project_src_dir}/counter.c" "
       #include <number.h>
       int count() {
         int result = get_number();
         set_number(result + 1);
         return result;
       }
     ")
 
     file(WRITE "${test_project_src_dir}/counter.h" "
       #ifndef _COUNTER_H
       #define _COUNTER_H
       extern int count(void);
       #endif
     ")
 
     file(WRITE "${test_project_src_dir}/main.c" "
       #include <stdlib.h>
       #include <stdio.h>
       #include <number.h>
     ")
 
     if(NOT link_exe_mod)
       file(APPEND "${test_project_src_dir}/main.c" "
         #include <dlfcn.h>
       ")
     endif()
 
     file(APPEND "${test_project_src_dir}/main.c" "
       int my_count() {
         int result = get_number();
         set_number(result + 1);
         return result;
       }
 
       int main(int argc, char **argv) {
         int result;
     ")
 
     if(NOT link_exe_mod)
       file(APPEND "${test_project_src_dir}/main.c" "
         void *counter_module;
         int (*count)(void);
 
         counter_module = dlopen(\"./counter.so\", RTLD_LAZY | RTLD_GLOBAL);
         if(!counter_module) goto error;
 
         count = dlsym(counter_module, \"count\");
         if(!count) goto error;
       ")
     endif()
 
     file(APPEND "${test_project_src_dir}/main.c" "
         result = count()    != 0 ? EXIT_FAILURE :
                  my_count() != 1 ? EXIT_FAILURE :
                  my_count() != 2 ? EXIT_FAILURE :
                  count()    != 3 ? EXIT_FAILURE :
                  count()    != 4 ? EXIT_FAILURE :
                  count()    != 5 ? EXIT_FAILURE :
                  my_count() != 6 ? EXIT_FAILURE : EXIT_SUCCESS;
     ")
 
     if(NOT link_exe_mod)
       file(APPEND "${test_project_src_dir}/main.c" "
         goto done;
         error:
           fprintf(stderr, \"Error occured:\\n    %s\\n\", dlerror());
           result = 1;
 
         done:
           if(counter_module) dlclose(counter_module);
       ")
     endif()
 
     file(APPEND "${test_project_src_dir}/main.c" "
           return result;
       }
     ")
 
     set(_rpath_arg)
     if(APPLE AND ${CMAKE_VERSION} VERSION_GREATER 2.8.11)
       set(_rpath_arg "-DCMAKE_MACOSX_RPATH='${CMAKE_MACOSX_RPATH}'")
     endif()
 
     try_compile(project_compiles
                 "${test_project_bin_dir}"
                 "${test_project_src_dir}"
                 "${project_name}"
                 CMAKE_FLAGS
                   "-DCMAKE_SHARED_LINKER_FLAGS='${CMAKE_SHARED_LINKER_FLAGS}'"
                   "-DCMAKE_ENABLE_EXPORTS=ON"
                   ${_rpath_arg}
                 OUTPUT_VARIABLE compile_output)
 
     set(project_works 1)
     set(run_output)
 
     if(project_compiles)
       execute_process(COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR}
                               "${test_project_bin_dir}/main"
                       WORKING_DIRECTORY "${test_project_bin_dir}"
                       RESULT_VARIABLE project_works
                       OUTPUT_VARIABLE run_output
                       ERROR_VARIABLE run_output)
     endif()
 
     set(test_description
         "Weak Link ${target_type} -> ${lib_type} (${link_flag_spec})")
 
     if(project_works EQUAL 0)
       set(project_works TRUE)
       message(STATUS "Performing Test ${test_description} - Success")
     else()
       set(project_works FALSE)
       message(STATUS "Performing Test ${test_description} - Failed")
       file(APPEND ${CMAKE_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/CMakeError.log
            "Performing Test ${test_description} failed with the "
            "following output:\n"
            "BUILD\n-----\n${compile_output}\nRUN\n---\n${run_output}\n")
     endif()
 
     set(${can_weak_link_var} ${project_works} PARENT_SCOPE)
     if(project_works)
       set(${project_name} ${link_flag} PARENT_SCOPE)
       break()
     endif()
   endforeach()
 endfunction()
 
 function(mitk_check_dynamic_lookup)
   # Two signatures are supported:
 
   if(ARGC EQUAL "1")
     #
     # mitk_check_dynamic_lookup(<ResultVar>)
     #
     set(target_type "MODULE")
     set(lib_type "SHARED")
     set(has_dynamic_lookup_var "${ARGV0}")
     set(link_flags_var "unused")
 
   elseif(ARGC GREATER "2")
     #
     # mitk_check_dynamic_lookup(<TargetType>
     #                      <LibType>
     #                      <ResultVar>
     #                      [<LinkFlagsVar>])
     #
     set(target_type "${ARGV0}")
     set(lib_type "${ARGV1}")
     set(has_dynamic_lookup_var "${ARGV2}")
     if(ARGC EQUAL "3")
       set(link_flags_var "unused")
     else()
       set(link_flags_var "${ARGV3}")
     endif()
   else()
     message(FATAL_ERROR "missing arguments")
   endif()
 
   _check_dynamic_lookup(
     ${target_type}
     ${lib_type}
     ${has_dynamic_lookup_var}
     ${link_flags_var}
     )
   set(${has_dynamic_lookup_var} ${${has_dynamic_lookup_var}} PARENT_SCOPE)
   if(NOT "x${link_flags_var}x" MATCHES "^xunusedx$")
     set(${link_flags_var} ${${link_flags_var}} PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_check_dynamic_lookup
          target_type
          lib_type
          has_dynamic_lookup_var
          link_flags_var
          )
 
   # hash the CMAKE_FLAGS passed and check cache to know if we need to rerun
   if("${target_type}" STREQUAL "STATIC")
     string(MD5 cmake_flags_hash "${CMAKE_STATIC_LINKER_FLAGS}")
   else()
     string(MD5 cmake_flags_hash "${CMAKE_SHARED_LINKER_FLAGS}")
   endif()
 
   set(cache_var "HAS_DYNAMIC_LOOKUP_${target_type}_${lib_type}")
   set(cache_hash_var "HAS_DYNAMIC_LOOKUP_${target_type}_${lib_type}_hash")
   set(result_var "DYNAMIC_LOOKUP_FLAGS_${target_type}_${lib_type}")
 
   if(     NOT DEFINED ${cache_hash_var}
        OR NOT "${${cache_hash_var}}" STREQUAL "${cmake_flags_hash}")
     unset(${cache_var} CACHE)
   endif()
 
   if(NOT DEFINED ${cache_var})
     set(skip_test FALSE)
 
    if(CMAKE_CROSSCOMPILING AND NOT CMAKE_CROSSCOMPILING_EMULATOR)
       set(skip_test TRUE)
     endif()
 
     if(skip_test)
       set(has_dynamic_lookup FALSE)
       set(link_flags)
     else()
       _test_weak_link_project(${target_type}
                               ${lib_type}
                               has_dynamic_lookup
                               link_flags)
     endif()
 
     set(caveat " (when linking ${target_type} against ${lib_type})")
 
     set(${cache_var} "${has_dynamic_lookup}"
         CACHE BOOL
         "linker supports dynamic lookup for undefined symbols${caveat}")
     mark_as_advanced(${cache_var})
 
     set(${result_var} "${link_flags}"
         CACHE STRING
         "linker flags for dynamic lookup${caveat}")
     mark_as_advanced(${result_var})
 
     set(${cache_hash_var} "${cmake_flags_hash}"
         CACHE INTERNAL "hashed flags for ${cache_var} check")
   endif()
 
   set(${has_dynamic_lookup_var} "${${cache_var}}" PARENT_SCOPE)
   set(${link_flags_var} "${${result_var}}" PARENT_SCOPE)
 endfunction()
 
 function(mitk_target_link_libraries_with_dynamic_lookup target)
   _get_target_type(target_type ${target})
 
   set(link_props)
   set(link_items)
   set(link_libs)
 
   foreach(lib ${ARGN})
     _get_target_type(lib_type ${lib})
     mitk_check_dynamic_lookup(${target_type}
                          ${lib_type}
                          has_dynamic_lookup
                          dynamic_lookup_flags)
 
     if(has_dynamic_lookup)
       if(dynamic_lookup_flags)
         if("${target_type}" STREQUAL "EXE")
           list(APPEND link_items "${dynamic_lookup_flags}")
         else()
           list(APPEND link_props "${dynamic_lookup_flags}")
         endif()
       endif()
     else()
       list(APPEND link_libs "${lib}")
     endif()
   endforeach()
 
   if(link_props)
     list(REMOVE_DUPLICATES link_props)
   endif()
 
   if(link_items)
     list(REMOVE_DUPLICATES link_items)
   endif()
 
   if(link_libs)
     list(REMOVE_DUPLICATES link_libs)
   endif()
 
   if(link_props)
     set_target_properties(${target}
                           PROPERTIES LINK_FLAGS "${link_props}")
   endif()
 
   set(links "${link_items}" "${link_libs}")
   if(links)
     target_link_libraries(${target} "${links}")
   endif()
 endfunction()
 
 
diff --git a/CMakeExternals/CppUnitCMakeLists.txt b/CMakeExternals/CppUnitCMakeLists.txt
index 14c7590705..34577fe5f0 100644
--- a/CMakeExternals/CppUnitCMakeLists.txt
+++ b/CMakeExternals/CppUnitCMakeLists.txt
@@ -1,228 +1,223 @@
 cmake_minimum_required(VERSION 3.18)
 
 project(CppUnit)
 
 set(${PROJECT_NAME}_MAJOR_VERSION 1)
 set(${PROJECT_NAME}_MINOR_VERSION 15)
 set(${PROJECT_NAME}_PATCH_VERSION 1)
 set(${PROJECT_NAME}_VERSION ${${PROJECT_NAME}_MAJOR_VERSION}.${${PROJECT_NAME}_MINOR_VERSION}.${${PROJECT_NAME}_PATCH_VERSION})
 
-# UNICODE support
-# See Visual C Unicode Programming Summary
-# http://msdn.microsoft.com/en-us/library/dybsewaf%28VS.100%29.aspx
-#add_definitions(-DUNICODE -D_UNICODE)
-
 # Generates include/cppunit/config-auto.h
 # This is originally done by autoconf
 
 include(CheckIncludeFile)
 include(CheckIncludeFileCXX)
 include(CheckCXXSourceCompiles)
 include(CheckCSourceCompiles)
 include(CheckLibraryExists)
 include(CheckFunctionExists)
 
 #Not used == not seen in any *.h *.cpp files
 #Not used FUNC_STRING_COMPARE_STRING_FIRST
 
 check_include_file_cxx(sstream CPPUNIT_HAVE_SSTREAM)
 check_include_file_cxx(strstream CPPUNIT_HAVE_STRSTREAM)
 set (CMAKE_REQUIRED_DEFINITIONS -DHAVE_STRSTREAM=CPPUNIT_HAVE_STRSTREAM)
 check_cxx_source_compiles(
 "#ifdef HAVE_STRSTREAM
 #include <strstream>
 #else
 #include <strstream.h>
 #endif
 int main() {
   std::ostrstream message;
   message << \"Hello\";
   return 0;
 }" CPPUNIT_HAVE_CLASS_STRSTREAM)
 
 check_include_file_cxx(cmath CPPUNIT_HAVE_CMATH)
 #Not used, dld library is obsolete anyway HAVE_DLD
 #Not used HAVE_DLERROR
 check_include_file(dlfcn.h CPPUNIT_HAVE_DLFCN_H)
 
 check_c_source_compiles(
 "#include <math.h>
 int main() {
   return finite(3);
 }" CPPUNIT_HAVE_FINITE)
 
 check_c_source_compiles(
 "#include <math.h>
 int main() {
   return _finite(3);
 }" CPPUNIT_HAVE__FINITE)
 
 check_include_file_cxx(cxxabi.h CPPUNIT_HAVE_GCC_ABI_DEMANGLE)
 #Not used HAVE_INTTYPES_H
 
 check_c_source_compiles(
 "#include <math.h>
 int main() {
   return isfinite(3);
 }" CPPUNIT_HAVE_ISFINITE)
 
 check_library_exists(dl dlopen "" CPPUNIT_HAVE_LIBDL)
 #Not used HAVE_MEMORY_H
 
 check_cxx_source_compiles(
 "namespace Outer {
   namespace Inner {
     int i = 0;
   }
 }
 using namespace Outer::Inner;
 int main() {
   return i;
 }" CPPUNIT_HAVE_NAMESPACES)
 
 check_cxx_source_compiles(
 "#include <typeinfo>
 class Base {
 public:
   Base() {}
   virtual int f() { return 0; }
 };
 class Derived : public Base {
 public:
   Derived() {}
   virtual int f() { return 1; }
 };
 int main() {
   Derived d;
   Base * ptr = &d;
   return typeid(*ptr) == typeid(Derived);
 }" CPPUNIT_HAVE_RTTI)
 
 check_library_exists(dl shl_load "" CPPUNIT_HAVE_SHL_LOAD)
 
 #Not used HAVE_STDINT_H
 #Not used HAVE_STDLIB_H
 #Not used HAVE_STRINGS_H
 #Not used HAVE_STRING_H
 #Not used HAVE_SYS_STAT_H
 #Not used HAVE_SYS_TYPES_H
 #Not used HAVE_UNISTD_H
 #Not used PACKAGE
 #Not used PACKAGE_BUGREPORT
 #Not used PACKAGE_NAME
 #Not used PACKAGE_STRING
 #Not used PACKAGE_TARNAME
 #Not used PACKAGE_VERSION
 #Not used STDC_HEADERS
 check_include_file_cxx(typeinfo CPPUNIT_USE_TYPEINFO_NAME)
 #CPPUNIT_VERSION ok
 
 configure_file(config/config.h.cmake ${CMAKE_CURRENT_SOURCE_DIR}/include/cppunit/config-auto.h)
 ##
 
 
 set(cppunit_SRCS
   src/cppunit/AdditionalMessage.cpp
   src/cppunit/Asserter.cpp
   src/cppunit/BriefTestProgressListener.cpp
   src/cppunit/CompilerOutputter.cpp
   src/cppunit/DefaultProtector.h
   src/cppunit/DefaultProtector.cpp
   src/cppunit/DynamicLibraryManager.cpp
   src/cppunit/DynamicLibraryManagerException.cpp
   src/cppunit/Exception.cpp
   src/cppunit/Message.cpp
   src/cppunit/PlugInManager.cpp
   src/cppunit/PlugInParameters.cpp
   src/cppunit/Protector.cpp
   src/cppunit/ProtectorChain.h
   src/cppunit/ProtectorContext.h
   src/cppunit/ProtectorChain.cpp
   src/cppunit/RepeatedTest.cpp
   src/cppunit/ShlDynamicLibraryManager.cpp
   src/cppunit/SourceLine.cpp
   src/cppunit/StringTools.cpp
   src/cppunit/SynchronizedObject.cpp
   src/cppunit/Test.cpp
   src/cppunit/TestAssert.cpp
   src/cppunit/TestCase.cpp
   src/cppunit/TestCaseDecorator.cpp
   src/cppunit/TestComposite.cpp
   src/cppunit/TestDecorator.cpp
   src/cppunit/TestFactoryRegistry.cpp
   src/cppunit/TestFailure.cpp
   src/cppunit/TestLeaf.cpp
   src/cppunit/TestNamer.cpp
   src/cppunit/TestPath.cpp
   src/cppunit/TestPlugInDefaultImpl.cpp
   src/cppunit/TestResult.cpp
   src/cppunit/TestResultCollector.cpp
   src/cppunit/TestRunner.cpp
   src/cppunit/TestSetUp.cpp
   src/cppunit/TestSuccessListener.cpp
   src/cppunit/TestSuite.cpp
   src/cppunit/TestSuiteBuilderContext.cpp
   src/cppunit/TextOutputter.cpp
   src/cppunit/TextTestProgressListener.cpp
   src/cppunit/TextTestResult.cpp
   src/cppunit/TextTestRunner.cpp
   src/cppunit/TypeInfoHelper.cpp
   src/cppunit/UnixDynamicLibraryManager.cpp
   src/cppunit/Win32DynamicLibraryManager.cpp
   src/cppunit/XmlDocument.cpp
   src/cppunit/XmlElement.cpp
   src/cppunit/XmlOutputter.cpp
   src/cppunit/XmlOutputterHook.cpp
 )
 
 add_library(cppunit SHARED ${cppunit_SRCS})
 target_include_directories(cppunit
   PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
          "$<INSTALL_INTERFACE:include>"
 )
 target_compile_definitions(cppunit PRIVATE CPPUNIT_BUILD_DLL)
 
 set_target_properties(cppunit PROPERTIES
   VERSION ${${PROJECT_NAME}_VERSION}
   SOVERSION ${${PROJECT_NAME}_VERSION}
 )
 
 set(${PROJECT_NAME}_LIBRARIES cppunit)
 
 # Install support
 
 install(TARGETS ${${PROJECT_NAME}_LIBRARIES} EXPORT ${PROJECT_NAME}_TARGETS
   LIBRARY DESTINATION lib
   ARCHIVE DESTINATION lib
   RUNTIME DESTINATION bin
 )
 install(DIRECTORY include/cppunit
   DESTINATION include
 )
 
 # Config files
 configure_file(
   ${PROJECT_NAME}Config.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
   @ONLY
 )
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}ConfigVersion.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
   @ONLY
 )
 
 export(EXPORT ${PROJECT_NAME}_TARGETS
   FILE ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake
 )
 
 set(config_package_location lib/cmake/${PROJECT_NAME})
 install(EXPORT ${PROJECT_NAME}_TARGETS
   FILE ${PROJECT_NAME}Targets.cmake
   DESTINATION ${config_package_location}
 )
 install(FILES
     "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
     "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
   DESTINATION ${config_package_location}
 )
diff --git a/Documentation/CMakeDoxygenFilter.cpp b/Documentation/CMakeDoxygenFilter.cpp
index 1181e6a20a..a6c54a2dfa 100644
--- a/Documentation/CMakeDoxygenFilter.cpp
+++ b/Documentation/CMakeDoxygenFilter.cpp
@@ -1,475 +1,475 @@
 /*============================================================================
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <cstdlib>
 #include <fstream>
 #include <iostream>
 #include <string>
 
 #include <assert.h>
 
 //--------------------------------------
 // Utilitiy classes and functions
 //--------------------------------------
 
 struct ci_char_traits : public std::char_traits<char>
 // just inherit all the other functions
 //  that we don't need to override
 {
   static bool eq(char c1, char c2) { return toupper(c1) == toupper(c2); }
   static bool ne(char c1, char c2) { return toupper(c1) != toupper(c2); }
   static bool lt(char c1, char c2) { return toupper(c1) < toupper(c2); }
   static bool gt(char c1, char c2) { return toupper(c1) > toupper(c2); }
   static int compare(const char *s1, const char *s2, std::size_t n)
   {
     while (n-- > 0)
     {
       if (lt(*s1, *s2))
         return -1;
       if (gt(*s1, *s2))
         return 1;
       ++s1;
       ++s2;
     }
     return 0;
   }
 
   static const char *find(const char *s, int n, char a)
   {
     while (n-- > 0 && toupper(*s) != toupper(a))
     {
       ++s;
     }
     return s;
   }
 };
 
 typedef std::basic_string<char, ci_char_traits> ci_string;
 
 //--------------------------------------
 // Lexer
 //--------------------------------------
 
 class CMakeLexer
 {
 public:
   enum Token
   {
     TOK_EOF = -1,
     TOK_EOL = -2,
 
     // commands
     TOK_MACRO = -3,
     TOK_ENDMACRO = -4,
     TOK_FUNCTION = -5,
     TOK_ENDFUNCTION = -6,
     TOK_DOXYGEN_COMMENT = -7,
     TOK_SET = -8,
     TOK_STRING_LITERAL = -100,
     TOK_NUMBER_LITERAL = -102,
 
     // primary
     TOK_IDENTIFIER = -200
   };
 
   CMakeLexer(std::istream &is) : _lastChar(' '), _is(is), _line(1), _col(1) {}
   int getToken()
   {
     // skip whitespace
     while (isspace(_lastChar) && _lastChar != '\r' && _lastChar != '\n')
     {
       _lastChar = getChar();
     }
 
     if (isalpha(_lastChar) || _lastChar == '_')
     {
       _identifier = _lastChar;
       while (isalnum(_lastChar = getChar()) || _lastChar == '-' || _lastChar == '_')
       {
         _identifier += _lastChar;
       }
 
       if (_identifier == "set")
         return TOK_SET;
       if (_identifier == "function")
         return TOK_FUNCTION;
       if (_identifier == "macro")
         return TOK_MACRO;
       if (_identifier == "endfunction")
         return TOK_ENDFUNCTION;
       if (_identifier == "endmacro")
         return TOK_ENDMACRO;
       return TOK_IDENTIFIER;
     }
 
     if (isdigit(_lastChar))
     {
       // very lax!! number detection
       _identifier = _lastChar;
       while (isalnum(_lastChar = getChar()) || _lastChar == '.' || _lastChar == ',')
       {
         _identifier += _lastChar;
       }
       return TOK_NUMBER_LITERAL;
     }
 
     if (_lastChar == '#')
     {
       _lastChar = getChar();
       if (_lastChar == '!')
       {
         // found a doxygen comment marker
         _identifier.clear();
 
         _lastChar = getChar();
         while (_lastChar != EOF && _lastChar != '\n' && _lastChar != '\r')
         {
           _identifier += _lastChar;
           _lastChar = getChar();
         }
         return TOK_DOXYGEN_COMMENT;
       }
 
       // skip the comment
       while (_lastChar != EOF && _lastChar != '\n' && _lastChar != '\r')
       {
         _lastChar = getChar();
       }
     }
 
     if (_lastChar == '"')
     {
       _lastChar = getChar();
       _identifier.clear();
       while (_lastChar != EOF && _lastChar != '"')
       {
         _identifier += _lastChar;
         _lastChar = getChar();
       }
 
       // eat the closing "
       _lastChar = getChar();
       return TOK_STRING_LITERAL;
     }
 
     // don't eat the EOF
     if (_lastChar == EOF)
       return TOK_EOF;
 
     // don't eat the EOL
     if (_lastChar == '\r' || _lastChar == '\n')
     {
       if (_lastChar == '\r')
         _lastChar = getChar();
       if (_lastChar == '\n')
         _lastChar = getChar();
       return TOK_EOL;
     }
 
     // return the character as its ascii value
     int thisChar = _lastChar;
     _lastChar = getChar();
     return thisChar;
   }
 
   std::string getIdentifier() const { return std::string(_identifier.c_str()); }
   int curLine() const { return _line; }
   int curCol() const { return _col; }
   int getChar()
   {
     int c = _is.get();
     updateLoc(c);
     return c;
   }
 
 private:
   void updateLoc(int c)
   {
     if (c == '\n' || c == '\r')
     {
       ++_line;
       _col = 1;
     }
     else
     {
       ++_col;
     }
   }
 
   ci_string _identifier;
   int _lastChar;
   std::istream &_is;
 
   int _line;
   int _col;
 };
 
 //--------------------------------------
 // Parser
 //--------------------------------------
 
 class CMakeParser
 {
 public:
   CMakeParser(std::istream &is, std::ostream &os)
     : _is(is), _os(os), _lexer(is), _curToken(CMakeLexer::TOK_EOF), _lastToken(CMakeLexer::TOK_EOF)
   {
   }
 
   int curToken() { return _curToken; }
   int nextToken()
   {
     _lastToken = _curToken;
     _curToken = _lexer.getToken();
     while (_curToken == CMakeLexer::TOK_EOL)
     {
       // Try to preserve lines in output to allow correct line number referencing by doxygen.
       _os << std::endl;
       _curToken = _lexer.getToken();
     }
     return _curToken;
   }
 
   void handleMacro()
   {
     if (!parseMacro())
     {
       // skip token for error recovery
       nextToken();
     }
   }
 
   void handleFunction()
   {
     if (!parseFunction())
     {
       // skip token for error recovery
       nextToken();
     }
   }
 
   void handleSet()
   {
     // SET(var ...) following a documentation block is assumed to be a variable declaration.
     if (_lastToken != CMakeLexer::TOK_DOXYGEN_COMMENT)
     {
       // No comment block before
       nextToken();
     }
     else if (!parseSet())
     {
       // skip token for error recovery
       nextToken();
     }
   }
 
   void handleDoxygenComment()
   {
     _os << "///" << _lexer.getIdentifier();
     nextToken();
   }
 
   void handleTopLevelExpression()
   {
     // skip token
     nextToken();
   }
 
 private:
   void printError(const char *str)
   {
     std::cerr << "Error: " << str << " (at line " << _lexer.curLine() << ", col " << _lexer.curCol() << ")";
   }
 
   bool parseMacro()
   {
     if (nextToken() != '(')
     {
       printError("Expected '(' after MACRO");
       return false;
     }
 
     nextToken();
     std::string macroName = _lexer.getIdentifier();
     if (curToken() != CMakeLexer::TOK_IDENTIFIER || macroName.empty())
     {
       printError("Expected macro name");
       return false;
     }
 
     _os << macroName << '(';
     if (nextToken() == CMakeLexer::TOK_IDENTIFIER)
     {
       _os << _lexer.getIdentifier();
       while (nextToken() == CMakeLexer::TOK_IDENTIFIER)
       {
         _os << ", " << _lexer.getIdentifier();
       }
     }
 
     if (curToken() != ')')
     {
       printError("Missing expected ')'");
     }
     else
     {
       _os << ");";
     }
 
     // eat the ')'
     nextToken();
     return true;
   }
 
   bool parseSet()
   {
     if (nextToken() != '(')
     {
       printError("Expected '(' after SET");
       return false;
     }
 
     nextToken();
     std::string variableName = _lexer.getIdentifier();
     if (curToken() != CMakeLexer::TOK_IDENTIFIER || variableName.empty())
     {
       printError("Expected variable name");
       return false;
     }
 
     _os << "CMAKE_VARIABLE " << variableName;
 
     nextToken();
     while ((curToken() == CMakeLexer::TOK_IDENTIFIER) || (curToken() == CMakeLexer::TOK_STRING_LITERAL) ||
            (curToken() == CMakeLexer::TOK_NUMBER_LITERAL))
     {
       nextToken();
     }
 
     if (curToken() != ')')
     {
       printError("Missing expected ')'");
     }
     else
     {
       _os << ";";
     }
 
     // eat the ')'
     nextToken();
     return true;
   }
 
   bool parseFunction()
   {
     if (nextToken() != '(')
     {
       printError("Expected '(' after FUNCTION");
       return false;
     }
 
     nextToken();
     std::string funcName = _lexer.getIdentifier();
     if (curToken() != CMakeLexer::TOK_IDENTIFIER || funcName.empty())
     {
       printError("Expected function name");
       return false;
     }
 
     _os << funcName << '(';
     if (nextToken() == CMakeLexer::TOK_IDENTIFIER)
     {
       _os << _lexer.getIdentifier();
       while (nextToken() == CMakeLexer::TOK_IDENTIFIER)
       {
         _os << ", " << _lexer.getIdentifier();
       }
     }
 
     if (curToken() != ')')
     {
       printError("Missing expected ')'");
     }
     else
     {
       _os << ");";
     }
 
     // eat the ')'
     nextToken();
 
     return true;
   }
 
   std::istream &_is;
   std::ostream &_os;
   CMakeLexer _lexer;
   int _curToken;
   int _lastToken;
 };
 
 #define STRINGIFY(a) #a
 #define DOUBLESTRINGIFY(a) STRINGIFY(a)
 
 int main(int argc, char **argv)
 {
   assert(argc > 1);
 
   for (int i = 1; i < argc; ++i)
   {
     std::ifstream ifs(argv[i]);
     std::ostream &os = std::cout;
 
 #ifdef USE_NAMESPACE
     os << "namespace " << DOUBLESTRINGIFY(USE_NAMESPACE) << " {\n";
 #endif
 
     CMakeParser parser(ifs, os);
     parser.nextToken();
     while (ifs.good())
     {
       switch (parser.curToken())
       {
         case CMakeLexer::TOK_EOF:
           return ifs.get(); // eat EOF
         case CMakeLexer::TOK_MACRO:
           parser.handleMacro();
           break;
         case CMakeLexer::TOK_FUNCTION:
           parser.handleFunction();
           break;
         case CMakeLexer::TOK_SET:
           parser.handleSet();
           break;
         case CMakeLexer::TOK_DOXYGEN_COMMENT:
           parser.handleDoxygenComment();
           break;
         default:
           parser.handleTopLevelExpression();
           break;
       }
     }
 
 #ifdef USE_NAMESPACE
     os << "}\n";
 #endif
   }
 
   return EXIT_SUCCESS;
 }
diff --git a/Documentation/CMakeLists.txt b/Documentation/CMakeLists.txt
index a25b37f09e..00f7794779 100644
--- a/Documentation/CMakeLists.txt
+++ b/Documentation/CMakeLists.txt
@@ -1,166 +1,128 @@
 # Different doxygen versions produce significantly different behaviour in the MITK documentation
 # especially in regards to the MITK Qt assistant help files and markdown files.
 # The HTML documentation is supposed to be build with Doxygen 1.8.7 or newer, the
 # Qt assistant QCH files are supposed to be generated with Doxygen 1.8.7 or newer.
 # So we check for 1.8.7 here and QCH generation support is checked in
 # BlueBerry/CMakeLists.txt
 set(supported_doxygen_version "1.8.7")
 
 if(DOXYGEN_VERSION VERSION_LESS ${supported_doxygen_version})
   MESSAGE(WARNING "Unsupported doxygen version ${DOXYGEN_VERSION}. The MITK HTML documentation has been tested to work with doxygen ${supported_doxygen_version} or newer.")
 endif()
 
 option(USE_DOT "Use dot program for generating graphical class diagrams with doxygen, if available" ON)
 option(MITK_DOXYGEN_BUILD_ALWAYS "Always build the MITK documentation when building the default target" OFF)
 option(MITK_DOXYGEN_GENERATE_QCH_FILES "Use doxygen to generate Qt compressed help files for MITK docs" OFF)
 mark_as_advanced(USE_DOT MITK_DOXYGEN_BUILD_ALWAYS MITK_DOXYGEN_GENERATE_QCH_FILES)
 if (MITK_DOXYGEN_GENERATE_QCH_FILES AND DOXYGEN_VERSION VERSION_LESS "1.8.7")
   message(WARNING "> Forcing MITK_DOXYGEN_GENERATE_QCH_FILES to OFF because Doxygen version 1.8.7 or newer not found.")
   set(MITK_DOXYGEN_GENERATE_QCH_FILES OFF CACHE BOOL "Use doxygen to generate Qt compressed help files for MITK docs" FORCE)
 endif()
 
 set(HAVE_DOT "NO")
 if(DOXYGEN_DOT_EXECUTABLE AND USE_DOT)
   set(HAVE_DOT "YES")
 endif()
 
 set(MITK_DOXYGEN_TAGFILE_NAME ${MITK_DOXYGEN_OUTPUT_DIR}/MITK.tag CACHE INTERNAL "MITK Doxygen tag file")
 
 # This is relative to the working directory of the doxygen command
 set(MITK_DOXYGEN_STYLESHEET mitk_doxygen_extra.css)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${MITK_DOXYGEN_STYLESHEET}
                ${CMAKE_CURRENT_BINARY_DIR}/${MITK_DOXYGEN_STYLESHEET} COPYONLY)
 
 # Create QCH files for MITK and external projects
 set(MITK_DOXYGEN_GENERATE_QHP "NO")
 if(MITK_DOXYGEN_GENERATE_QCH_FILES)
 
   find_program(QT_HELPGENERATOR_EXECUTABLE
     NAMES qhelpgenerator qhelpgenerator-qt5 qhelpgenerator5
     PATHS ${QT_BINARY_DIR}
     DOC "The location of the the Qt help generator executable"
     NO_DEFAULT_PATH
   )
   mark_as_advanced(QT_HELPGENERATOR_EXECUTABLE)
 
   if(NOT QT_HELPGENERATOR_EXECUTABLE)
     message(SEND_ERROR "The Qt help generator could not be found. Disabling qch generation")
   else()
     set(MITK_DOXYGEN_GENERATE_QHP "YES")
   endif()
 
   # The name of the generated MITK qch file, relative to the
   # Doxygen HTML output folder
   set(MITK_DOXYGEN_QCH_FILE "${MITK_BINARY_DIR}/MITK-${MITK_REVISION_ID}.qch")
 
   # Generating ITK and VTK docs it not done yet
   #option(MITK_DOXYGEN_GENERATE_VTK_QCH_FILE "Use doxygen to generate a Qt compressed help file for VTK docs" OFF)
   #option(MITK_DOXYGEN_GENERATE_ITK_QCH_FILE "Use doxygen to generate a Qt compressed help file for ITK docs" OFF)
   #mark_as_advanced(MITK_DOXYGEN_GENERATE_VTK_QCH_FILE MITK_DOXYGEN_GENERATE_ITK_QCH_FILE)
 
 endif()
 
 # Compile a doxygen input filter for processing CMake scripts
 include(mitkFunctionCMakeDoxygenFilterCompile)
 mitkFunctionCMakeDoxygenFilterCompile(NAMESPACE "CMake")
 
 # Configure some doxygen options
 if(NOT MITK_DOXYGEN_INTERNAL_DOCS)
   set(MITK_DOXYGEN_INTERNAL_DOCS "NO")
   set(MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS "YES")
   set(MITK_DOXYGEN_EXCLUDE_PATTERNS "*_p.* *Private.h */internal/*")
 else()
   set(MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS "NO")
   set(MITK_DOXYGEN_EXCLUDE_PATTERNS "")
 endif()
 
 if(NOT MITK_DOXYGEN_GENERATE_TODOLIST)
   set(MITK_DOXYGEN_GENERATE_TODOLIST "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_GENERATE_BUGLIST)
   set(MITK_DOXYGEN_GENERATE_BUGLIST "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS)
   set(MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_UML_LOOK)
   set(MITK_DOXYGEN_UML_LOOK "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_GENERATE_DEPRECATEDLIST)
   set(MITK_DOXYGEN_GENERATE_DEPRECATEDLIST "YES")
 endif()
 
 if(NOT DEFINED MITK_DOXYGEN_DOT_NUM_THREADS)
   set(MITK_DOXYGEN_DOT_NUM_THREADS 0)
 endif()
 
 if(NOT DEFINED US_PLATFORM)
   if(UNIX)
     if(APPLE)
       set(US_PLATFORM "US_PLATFORM_APPLE=1")
     else()
       set(US_PLATFORM "US_PLATFORM_LINUX=1")
     endif()
     set(US_PLATFORM "${US_PLATFORM} \\\nUS_PLATFORM_POSIX=1")
   else()
     set(US_PLATFORM "US_PLATFORM_WINDOWS=1")
   endif()
 endif()
 
-#[[ parse which plug-in documentation to activate
-set(USERS_GUIDE_INPUT "${MITK_SOURCE_DIR}/Documentation/Doxygen/UserManual/")
-if(MITK_USE_BLUEBERRY)
-  if(MITK_BUILD_ALL_PLUGINS)
-    set(USERS_GUIDE_INPUT "${USERS_GUIDE_INPUT} \\
-        ${MITK_SOURCE_DIR}/Plugins/")
-  else()
-    foreach(mitk_plugin ${${CMAKE_PROJECT_NAME}_PLUGIN_LIBRARIES})
-      # we want each line to end in " \" and each directory be on a separate line
-      set(USERS_GUIDE_INPUT "${USERS_GUIDE_INPUT} \\
-          ${${mitk_plugin}_SOURCE_DIR}/")
-    endforeach()
-  endif()
-
-  if(MITK_BUILD_EXAMPLES)
-    set(USERS_GUIDE_INPUT "${USERS_GUIDE_INPUT} \\
-        ${MITK_SOURCE_DIR}/Examples/Plugins/")
-  endif()
-endif()]]
-
-#[[ create output directories for the guides
-file(MAKE_DIRECTORY ${MITK_DOXYGEN_OUTPUT_DIR}/Guides/Users_Guide/)
-file(MAKE_DIRECTORY ${MITK_DOXYGEN_OUTPUT_DIR}/Guides/Developers_Guide/)]]
-
 configure_file(doxygen.conf.in
                ${CMAKE_CURRENT_BINARY_DIR}/doxygen.conf)
-#[[configure_file(doxygen_users_guide.conf.in
-               ${CMAKE_CURRENT_BINARY_DIR}/doxygen_users_guide.conf)
-configure_file(doxygen_developers_guide.conf.in
-               ${CMAKE_CURRENT_BINARY_DIR}/doxygen_developers_guide.conf)]]
 
 if(MITK_DOXYGEN_BUILD_ALWAYS)
   set(_doc_in_all "ALL")
 else()
   set(_doc_in_all "")
 endif()
 
 add_custom_target(doc ${_doc_in_all}
                   ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.conf
                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                   )
 
-#[[add_custom_target(doc_usersguide
-                  ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen_users_guide.conf
-                  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-                  )
-
-add_custom_target(doc_developersguide
-                  ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen_developers_guide.conf
-                  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-                  )]]
-
-set_property(TARGET doc #[[doc_usersguide doc_developersguide]] PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Documentation")
+set_property(TARGET doc PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Documentation")
diff --git a/Documentation/Doxygen/3-DeveloperManual/Concepts/ReaderWriterPage.md b/Documentation/Doxygen/3-DeveloperManual/Concepts/ReaderWriterPage.md
index 9076717513..74c6e26447 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Concepts/ReaderWriterPage.md
+++ b/Documentation/Doxygen/3-DeveloperManual/Concepts/ReaderWriterPage.md
@@ -1,176 +1,176 @@
 Reader and Writer {#ReaderWriterPage}
 =================
 
 This page is work in progress and will introduce you to the IO-System of MITK.
 
 [TOC]
 
 ## Introductory slides
 
 Several Talks have been given on the IO-System. The following list should provide you with a good starting point.
 
-- Introduction to MimeTypes: http://www.mitk.org/images/e/e8/MimeTypes.pdf (by Caspar J. Goch)
-- Introduction to the IO-System: http://www.mitk.org/images/0/0b/Newio.pdf (by Keno März)
-- IO-Streams and the new IO System: http://www.mitk.org/images/9/95/Streams.pdf (by Keno März)
+- Introduction to MimeTypes: https://www.mitk.org/images/e/e8/MimeTypes.pdf (by Caspar J. Goch)
+- Introduction to the IO-System: https://www.mitk.org/images/0/0b/Newio.pdf (by Keno März)
+- IO-Streams and the new IO System: https://www.mitk.org/images/9/95/Streams.pdf (by Keno März)
 
 ## Quick start: Reading and writing files using IOUtil
 
 mitk::IOUtil class provides convenience methods for loading data into a data
 storage or just returning BaseData objects without user interaction. The mitk::IOUtil::Save()
 and mitk::IOUtil::Load() methods cover the typical use cases and
 automatically select the best matching mitk::IFileReader and mitk::IFileWriter
 instance. In most cases, this is the easiest way to read or write a file.
 
      // load files directly into datastorage
     mitk::IOUtil::Load("/path/to/my/file.nrrd",*ds);
 
      // load basedata into local vector
     std::vector< mitk::Basedata::Pointer > basedatas;
      basedatas = mitk::IOUtil::Load("/path/to/my/file.nrrd");
 
      // write basedata to file (here: surface as PLY
      mitk::IOUtil::Save(mySurface, "/Save/surface/here.ply");
 
      // write basedata to file (here: surface as STL
      mitk::IOUtil::Save(mySurface, "/Save/surface/here.stl");
 
 When reading a file using IOUtil, the IO-Framework  first determines the mime-type of the given file.
 Afterwards, the best reader is selected internally, instantiated, and executed. The resulting BaseData Objects are returned to the developer as the method result.
 
 ## Quick start: Creating your own reader or writer
 
 If you implement a new BaseData, usually matching readers and writers are required. The following guide will help you to quickly set up these up and get them working in MITK.
 
 Create new classes for reader and writers. Optimally, place them in an extra IO-Module that is configured as autoload. This way, they are available to the application from the start. If you are working  with common data, the appropriate module is MitkIOExt. You can either extend mitk::AbstractFileIO, which will allow you to implement a class with reader and writer abilities, or you can extend mitk::AbstractFileReader or mitk::AbstractFileWriter specifically.
 
 \imageMacro{reader_writer_classes.png,"",16}
 
 Implement the given Methods. A good example on how to write a simple reader and writer is the mitkPointSetReaderService.cpp and mitkPointSetWriterService.cpp class, from which you can take implementation cues. The following is a simplified version of the header file:
 
      namespace mitk
      {
 
      class PointSetReaderService: public AbstractFileReader // 2) Extend the Abstract File Reader
      {
      public:
 
        PointSetReaderService();  // 3) Provide Constructor and Destructor
        virtual ~PointSetReaderService();
 
        // 4) Overwrite the Read Method as seen here
        using AbstractFileReader::Read;
        virtual std::vector< itk::SmartPointer<BaseData> > Read();
 
      private:
 
        // 5) Provide a clone method
        PointSetReaderService(const PointSetReaderService& other);
        virtual PointSetReaderService* Clone() const;
      };
 
      }
 
 ### Example
 Follow these steps to implement a new Reader:
 
 A) Create a new cpp and h file in an appropriate submodule. Usually, a reader or writer should be located in the same module as the BaseData derivate it reads/writes.
 
 B) Extend AbstractFileReader . This is highly recommended because it enables integration of your Reader into the Registery. It will then automatically be used by the application to load this type of files.
 
 C) Provide a constructor . It should contain a minimal amount of information and might look like this:
 
     mitk::PointSetReaderService::PointSetReaderService()
       : AbstractFileReader(CustomMimeType(IOMimeTypes::POINTSET_MIMETYPE_NAME()), "MITK Point Set Reader")
     {
         RegisterService();
     }
 
 Note the call to the superclass constructor containing the MIME-type. You can either reuse an existent MIME type here or create your own MIME-type locally . Finally, register the service to make it available to MITK.
 
 D) Provide a Clone Method: Readers are clones when the registry requires a new reader. Provide a clone method to accommodate for this. Use the mitkPointSetReaderService.cpp as a reference if necessary.
 
 E) Instantiate it in the module activator. Open the module activator and make sure that the new Reader/Writer is instantiated and held somewhere in the code.  Also, unregister the reader/writer in the unload function if necessary.
 
 ## Reader/Writer Options
 
 Options are a powerful concept to modify Reader/Writer behaviour and to automate user interaction with minimal development overhead. In principal, options are represented by a simple map and a few getter and setter functions:
 
     typedef std::map<std::string, us::Any> Options;
 
     virtual Options GetOptions();
     virtual void SetOptions(const Options& options);
     virtual us::Any GetOption(const std::string& name);
     virtual void SetOptions(const Options& options);
 
 In its constructor, a reader or writer can set its options as a number map entries consisting of an human-readable option name and a default value. When a user tries to read/write a file via the interface, an options menu is generate from the map.
 
 \imageMacro{io_options.png,"The options dialog shown by the raw reader",5}
 
 The user can then modify these options, which are automatically set in the reader/writer. You can use raw-images to see this behaviour in action.
 
 ## Mime Types
 
 The MimeType class provides meta-data about a specific data format.
 Every mitk::IFileReader and mitk::IFileWriter instance must be associated
 with exactly one mime-type via a service property.
 
 \imageMacro{mimetypes.png,"",14}
 
 Mime-type are used for categorizing data formats and creating filter
 strings in file open and save dialogs. Hence they effectively control
 the accessible set of data formats from a graphical user interface.
 Minimally, mime-types should provide a name and a list of handled extensions in lower case.
 Additionally, it is highly encouraged to set a category and a comment which will provide user-readable
 strings for user interaction.
 
 It is important to understand the difference between mitk::MimeType and mitk::CustomMimeType.
 The former is an immutable stack object and can be pulled from mitk::MimeTypeProvider.
 it should be used for all interaction with MimeTypes. mitk::CustomMimeType is the heap-object pendant
 which is wrapped by mitk::MimeType and should exclusively be used for registration purposes, i.e. when you
 register a new MimeType.
 
 ## Additional Capabilities
 
 You can extend your reader writer with useful capabilities. All of these are optional
 + Priority: Reader use a ranking with Get- and SetRanking in order to signify how well they are suited to read a file. If several readers are able to read a file, the one with the highest Ranking level will be chosen.
 + ProgressCallbacks : Readers are executed in a thread automatically. If the reader implements callbacks, the progress bar will be more accurate during loading of files. Note: Progress callbacks are work in progress.
 
 ## Ranking strategies
 
 Todo.
 
 ## Convenience classes
 
 Developers usually do not interact with the service registry directly
 to retrieve and select a matching mitk::IFileReader or mitk::IFileWriter instance.
 
 
 ### %QmitkIOUtil
 
 The QmitkIOUtil class is a wrapper around mitk::IOUtil, providing
 file open and save dialogues for selecting a file name from a within
 a graphical user interface.
 
 ### FileReaderRegistry and FileWriterRegistry
 
 Access to mitk::IFileReader and mitk::IFileWriter objects and their service references.
 
 ## Integrating external I/O mechanisms
 
 The MITK I/O system integrates with several external I/O systems.
 
 ### ITK Reader and Writer
 
 The I/O classes from ITK are automatically added to the service registry
 of MITK. They can be transparently used via the mitk::IFileReader and mitk::IFileWriter
 interfaces or the mitk::IOUtil methods.
 
 ### VTK Reader and Writer
 
 VTK does not provide a mechanism to enumerate all available I/O classes.
 Hence MITK provides manual integration of a specific set of VTK readers
 and writers.
 
 ## Error handling and recovery
 
 Todo.
diff --git a/Documentation/Doxygen/3-DeveloperManual/Concepts/TestsGeneral.dox b/Documentation/Doxygen/3-DeveloperManual/Concepts/TestsGeneral.dox
index 10d3d23308..cb751350a8 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Concepts/TestsGeneral.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Concepts/TestsGeneral.dox
@@ -1,104 +1,104 @@
 /**
 \page GeneralTests General: Tests in MITK
 
 \tableofcontents
 
 \section GeneralTestsIntroduction Testing in MITK
 
 The basic idea about unit testing is to write a test for every unit (e.g. function) of your software, which automatically checks if the code still returns the expected result for a defined input. The goal is to isolate units as much as possible, in order to be efficient with fixing errors.
 
 If this is performed on a low level, this is called unit testing. On higher levels, where various circumstances (such as configuration files, internet connection, hardware, or even input/output) may influence the outcome of the test, this is called integration testing.
 
 MITK uses CppUnit, which is a framework for efficient and fast test writing, to support developers in test coding. Furthermore MITK offers currently three types of tests: classic <B>unit tests</B>, <B>rendering tests</B> and <B>interaction tests</B>. Although our unit tests often involve data input (or output), we still consider them to be unit tests.
 
 \warning Most of our units tests have been written before adopting CppUnit and have not yet been updated. Therefore we do not recommend to look at a random test for an example of coding a test.
 
 This pages gives a general introduction to our test framework. Rendering tests are explained in more detail in the section \ref RenderingTests and interaction tests the section \ref InteractionTestingHowTo. The following sections will explain how to write your own tests with MITK and how to run them.
 
 \section GeneralTestsAdding Adding a test to your module
 
 Generally, functional code you want to test using unit tests will be located in a module. For an overview of the directory structure see \ref NewModulePageCreateFolder and how to add the files comprising your test compare \ref NewModulePageCreateTestingEnvironment
 
 \subsection GeneralTestsAddingFramework Test and test class/suite
 
 CppUnit and MITK distinguish between the term test class and test, which is important to understand. A test is simply a call of a single function and a comparison against a reference.
 
 The ideal way to write a test is:
 \code
         result = myGreatFunction(myParameter);
         ASSERT_EQUAL(result, reference);
 \endcode
 
 which is just 2 lines of code at the best. Sometimes objects and data may be initialized in a test, but usually this should be done in the setUp() method (see below). If possible, avoid multiple assertions in order to be efficient in error localization and for better readability. For instance, if you instantiate an object and test if its data is not NULL, this is already a complete test and you do not want to repeat this comparison in other tests.
 
 All tests check different things and just one at a time. Remember: The goal is to have isolated unit tests and avoid large, confusing tests which are hard to maintain.
 \note The reference should never be computed and ideally be a distinct and well defined (often hard coded) value. You don't care where you reference comes from, you just want to ensure that your test actually results in the reference value.
 
 A test class (also called suite) is a set of tests and often associated to a single functional class in MITK. A test class refers to a TestSuite in CppUnit. These terms are easily confused, so we suggest to use the term <B>test suite</B> for a collection of tests (which is often in a single file), and the term "test" for a single test (usually many per file).
 
 In order to create a test class you need to create a new class deriving from mitk::TestFixture. While a purist approach would be to create a new mitk::TestFixture for each method of your class (resulting in as many test source files as your class has methods), we usually follow a more pragmatic approach within MITK. In most cases we suggest having one test source file per class. If your class source file is called mitkGreatClass.cpp we suggest the name mitkGreatClassTest.cpp for your test source file. For very complex and long classes splitting this into several tests may be advisable. Additionally, rendering tests and interaction tests should always get their own test class/suite to mark them as obvious integration tests, because the goal is to isolate unit tests from integration tests. The dashboard for continuous integration will automatically show the results of a test suite and summarize the output. If you run your test manually (e.g. with ctest -VV), you will see the detailed output of all tests of the suite.
 
 In order to use CppUnit via MITK you will need to include the corresponding files and register your test:
 \code
   #include <mitkTestingMacros.h>
   #include <mitkTestFixture.h>
   …
   MITK_TEST_SUITE_REGISTRATION(mitkImageEqual)
 \endcode
 
 \subsection GeneralTestsAddingHow How to structure your test
 
 As mentioned before, all test suites derive from mitk::TestFixture. A suggested name for your test suite would be \c \<FUNCTIONALITY_TO_BE_TESTED\>TestSuite .
 
 You then create a suite and register your tests. A suggested naming convention for test methods is \c \<METHOD_TO_BE_TESTED\>_\<INPUT_PARAMETERS/CONDITION\>_\<EXPECTED_RESULT\> . We suggest not to add the word test, because that is most likely the only thing the reader knows anyway about your test, as he is reading a test suite.
 
 An example:
 \code
   class mitkImageEqualTestSuite : public mitk::TestFixture
   {
     CPPUNIT_TEST_SUITE(mitkImageEqualTestSuite);
     MITK_TEST(Equal_CloneAndOriginal_ReturnsTrue);
     MITK_TEST(Equal_InputIsNull_ReturnsFalse);
     MITK_TEST(Equal_DifferentImageGeometry_ReturnsFalse);
     MITK_TEST(Equal_DifferentPixelTypes_ReturnsFalse);
     …
     CPPUNIT_TEST_SUITE_END();
     …
   }
 \endcode
 
-You also may provide a setUp() and a tearDown() function. These will be called before/after each test and should be used to make sure that each test works independently and on freshly initialized members and memory to maximize isolation. That way you avoid only testing whether a function works after another function has already been called. See <a href="http://cppunit.sourceforge.net/doc/cvs/class_test_fixture.html">CppUnit documentation</a> for more information. For an example test suite including tests see \ref GeneralTestsExample
+You also may provide a setUp() and a tearDown() function. These will be called before/after each test and should be used to make sure that each test works independently and on freshly initialized members and memory to maximize isolation. That way you avoid only testing whether a function works after another function has already been called. For an example test suite including tests see \ref GeneralTestsExample
 
 \section GeneralTestsRunning Running your test suite
 
 The build system of MITK generates a test driver which includes all test suites that have been added to the project. Alternatively you can run MITK test suites by using the program ctest. This is the way all MITK tests run on the continuous dart clients of MITK. The results of these runs can be found at https://cdash.mitk.org/.
 
 If you use the test driver, you only need to start the executable. If you start it without parameters, it will then give you an overview of all tests which are included in this test driver and you can choose one by typing a number. Alternatively, you can give your test driver the name of your test suite as parameter. If you want to use ctest instead of the test driver you need to start a command line, go to the binary directory of MITK and call ctest. To avoid errors, check if your path variable contains all relevant paths to start MITK.
 
 \section GeneralTestsParameterInput Adding parameters to your test
 
 If possible, the setUp() method of the test suite should provide all necessary inputs for the respective tests. MITK provides several helper classes to generate synthetic test data, such as the mitk::ImageGenerator. If you have to load data from the hard disc for your test, you can use the method GetTestDataFilePath(string fileName). For an example of loading data from the MITK_DATA_DIR check the mitkIOUtilTestSuite.
 
 \section GeneralTestsPredefinedAssertions Predefined assertions
 
-MITK and CppUnit offer predefined assertions, i.e. helper methods which will help to compare your data against a certain reference. All basic types are covered by CppUnit assertions, such as CPPUNIT_ASSERT. For examples, please check the <a href="http://cppunit.sourceforge.net/doc/cvs/group___assertions.html">CppUnit documentation</a>. MITK further offers comparison tools for floating point numbers, vectors, images, surfaces and point sets. A complete list of assertion macros is given in \ref MITKTestingAPI.
+MITK and CppUnit offer predefined assertions, i.e. helper methods which will help to compare your data against a certain reference. All basic types are covered by CppUnit assertions, such as CPPUNIT_ASSERT. MITK further offers comparison tools for floating point numbers, vectors, images, surfaces and point sets. A complete list of assertion macros is given in \ref MITKTestingAPI.
 
 An example to compare images:
 \code
         MITK_ASSERT_EQUAL(image, reference, "Checks if image is equal to a reference");
 \endcode
 
 By default, the method uses an mitk::eps for floating point comparison, but this can be adapted. It can be necessary to write your own assertion for your own data meeting your special requirements. Recommended examples are all equal test suites for basic data types (mitkImageEqualTest, mitkSurfaceEqualTest and mitkPointSetEqualTest).
 
 \section GeneralTestsExample An example
 
 \include Examples/FirstSteps/NewModule/test/mitkExampleDataStructureTest.cpp
 
 \section GeneralTestsFurtherInfo Further information
 
 More examples can be found in the corresponding <a href="https://www.mitk.org/w/images/5/5d/BugSquashingSeminars%24CppUnitFrameworkSeminar.pdf"> bugsquashing presentation</a>.
 */
 
 \section GeneralTestsDeprecatedOldTestingStyle Deprecated macros
 
 All tests with MITK_TEST_BEGIN(); and MITK_TEST_END(); use the deprecated old MITK testing style. If possible, they should be replaced with the new CppUnit style as explained before. Most of these test classes contain very unfortunate examples and should not be regarded as reference.
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox
index ff4c803e83..b8781ce573 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox
@@ -1,115 +1,115 @@
 /**
 \page thirdpartylibs Third-party libraries
 
 The following third-party libraries can be used with MITK by default and can, in part, be automatically downloaded during superbuild.
 
 \par ACVD
 
 https://www.creatis.insa-lyon.fr/~valette/public/project/acvd/
 
 \par ANN
 
 https://www.cs.umd.edu/~mount/ANN/
 
 \par Boost
 
 https://www.boost.org/
 
 \par C++ REST SDK
 
 https://github.com/Microsoft/cpprestsdk/
 
 \par CppUnit
 
 https://sourceforge.net/projects/cppunit/
 
 \par CTK
 
 https://commontk.org/
 
 \par DCMTK
 
 https://dicom.offis.de/dcmtk
 
 \par Eigen
 
-http://eigen.tuxfamily.org/index.php?title=Main_Page
+https://eigen.tuxfamily.org/index.php?title=Main_Page
 
 \par GDCM
 
 https://gdcm.sourceforge.net/
 
 \par HDF5
 
 https://support.hdfgroup.org/HDF5/
 
 \par ITK
 
 https://itk.org/
 
 \par JSON for Modern C++
 
 https://github.com/nlohmann/json
 
 \par lz4
 
 https://github.com/lz4/lz4
 
 \par MatchPoint
 
 https://www.dkfz.de/en/sidt/projects/MatchPoint/info.html
 
 \par OpenCL
 
 https://www.khronos.org/opencl/
 
 \par OpenCV
 
 https://opencv.org/
 
 \par OpenIGTLink
 
 http://openigtlink.org/
 
 \par PCRE
 
 https://www.pcre.org/
 
 \par POCO
 
 https://pocoproject.org/
 
 \par Python
 
 https://www.python.org/
 
 \par Qt
 
 https://www.qt.io/
 
 \par Qwt
 
-http://qwt.sourceforge.net/
+https://qwt.sourceforge.io/
 
 \par SWIG
 
-http://www.swig.org/
+https://www.swig.org/
 
 \par TinyXML-2
 
-http://www.grinninglizard.com/tinyxml2/
+https://www.grinninglizard.com/tinyxml2/
 
 \par VIGRA
 
 https://ukoethe.github.io/vigra/
 
 \par VTK
 
 https://vtk.org/
 
 \par zlib
 
 https://zlib.net/
 
 For copyright information on any of the above toolkits see the corresponding home page or the corresponding source folder.
 */
diff --git a/Documentation/MITKDoxygenLayout.xml b/Documentation/MITKDoxygenLayout.xml
index da9704a0b3..81f8e2f990 100644
--- a/Documentation/MITKDoxygenLayout.xml
+++ b/Documentation/MITKDoxygenLayout.xml
@@ -1,197 +1,197 @@
 <doxygenlayout version="1.0">
   <!-- Navigation index tabs for HTML output -->
   <navindex>
     <tab type="mainpage" visible="yes" title="Home"/>
     <tab type="pages" visible="yes" title="Manual" intro=""/>
     <tab type="usergroup" title="API Reference">
       <tab type="modules" visible="yes" title="Groups" intro="Here is a list of all groups:"/>
       <tab type="namespaces" visible="yes" title="">
         <tab type="namespacelist" visible="yes" title="" intro=""/>
         <tab type="namespacemembers" visible="yes" title="" intro=""/>
       </tab>
       <tab type="classes" visible="yes" title="">
         <tab type="classlist" visible="yes" title="" intro=""/>
         <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
         <tab type="hierarchy" visible="yes" title="" intro=""/>
         <tab type="classmembers" visible="yes" title="" intro=""/>
       </tab>
       <tab type="files" visible="yes" title="">
         <tab type="filelist" visible="yes" title="" intro=""/>
         <tab type="globals" visible="yes" title="" intro=""/>
       </tab>
       <tab type="examples" visible="yes" title="" intro=""/>
     </tab>
-    <tab type="user" url="http://mitk.org/Download" title="Download"/>
-    <tab type="user" url="http://phabricator.mitk.org/maniphest/" title="Bug Tracker"/>
+    <tab type="user" url="https://www.mitk.org/Downloads" title="Download"/>
+    <tab type="user" url="https://phabricator.mitk.org/maniphest/" title="Bug Tracker"/>
   </navindex>
 
   <!-- Layout definition for a class page -->
   <class>
     <briefdescription visible="yes"/>
     <includes visible="$SHOW_INCLUDE_FILES"/>
     <inheritancegraph visible="$CLASS_GRAPH"/>
     <collaborationgraph visible="$COLLABORATION_GRAPH"/>
     <memberdecl>
       <nestedclasses visible="yes" title=""/>
       <publictypes title=""/>
       <services title=""/>
       <interfaces title=""/>
       <publicslots title=""/>
       <signals title=""/>
       <publicmethods title=""/>
       <publicstaticmethods title=""/>
       <publicattributes title=""/>
       <publicstaticattributes title=""/>
       <protectedtypes title=""/>
       <protectedslots title=""/>
       <protectedmethods title=""/>
       <protectedstaticmethods title=""/>
       <protectedattributes title=""/>
       <protectedstaticattributes title=""/>
       <packagetypes title=""/>
       <packagemethods title=""/>
       <packagestaticmethods title=""/>
       <packageattributes title=""/>
       <packagestaticattributes title=""/>
       <properties title=""/>
       <events title=""/>
       <privatetypes title=""/>
       <privateslots title=""/>
       <privatemethods title=""/>
       <privatestaticmethods title=""/>
       <privateattributes title=""/>
       <privatestaticattributes title=""/>
       <friends title=""/>
       <related title="" subtitle=""/>
       <membergroups visible="yes"/>
     </memberdecl>
     <detaileddescription title=""/>
     <memberdef>
       <inlineclasses title=""/>
       <typedefs title=""/>
       <enums title=""/>
       <services title=""/>
       <interfaces title=""/>
       <constructors title=""/>
       <functions title=""/>
       <related title=""/>
       <variables title=""/>
       <properties title=""/>
       <events title=""/>
     </memberdef>
     <allmemberslink visible="yes"/>
     <usedfiles visible="$SHOW_USED_FILES"/>
     <authorsection visible="yes"/>
   </class>
 
   <!-- Layout definition for a namespace page -->
   <namespace>
     <briefdescription visible="yes"/>
     <memberdecl>
       <nestednamespaces visible="yes" title=""/>
       <constantgroups visible="yes" title=""/>
       <classes visible="yes" title=""/>
       <typedefs title=""/>
       <enums title=""/>
       <functions title=""/>
       <variables title=""/>
       <membergroups visible="yes"/>
     </memberdecl>
     <detaileddescription title=""/>
     <memberdef>
       <inlineclasses title=""/>
       <typedefs title=""/>
       <enums title=""/>
       <functions title=""/>
       <variables title=""/>
     </memberdef>
     <authorsection visible="yes"/>
   </namespace>
 
   <!-- Layout definition for a file page -->
   <file>
     <briefdescription visible="yes"/>
     <includes visible="$SHOW_INCLUDE_FILES"/>
     <includegraph visible="$INCLUDE_GRAPH"/>
     <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
     <sourcelink visible="yes"/>
     <memberdecl>
       <classes visible="yes" title=""/>
       <namespaces visible="yes" title=""/>
       <constantgroups visible="yes" title=""/>
       <defines title=""/>
       <typedefs title=""/>
       <enums title=""/>
       <functions title=""/>
       <variables title=""/>
       <membergroups visible="yes"/>
     </memberdecl>
     <detaileddescription title=""/>
     <memberdef>
       <inlineclasses title=""/>
       <defines title=""/>
       <typedefs title=""/>
       <enums title=""/>
       <functions title=""/>
       <variables title=""/>
     </memberdef>
     <authorsection/>
   </file>
 
   <!-- Layout definition for a group page -->
   <group>
     <briefdescription visible="yes"/>
     <groupgraph visible="$GROUP_GRAPHS"/>
     <memberdecl>
       <nestedgroups visible="yes" title=""/>
       <dirs visible="yes" title=""/>
       <files visible="yes" title=""/>
       <namespaces visible="yes" title=""/>
       <classes visible="yes" title=""/>
       <defines title=""/>
       <typedefs title=""/>
       <enums title=""/>
       <enumvalues title=""/>
       <functions title=""/>
       <variables title=""/>
       <signals title=""/>
       <publicslots title=""/>
       <protectedslots title=""/>
       <privateslots title=""/>
       <events title=""/>
       <properties title=""/>
       <friends title=""/>
       <membergroups visible="yes"/>
     </memberdecl>
     <detaileddescription title=""/>
     <memberdef>
       <pagedocs/>
       <inlineclasses title=""/>
       <defines title=""/>
       <typedefs title=""/>
       <enums title=""/>
       <enumvalues title=""/>
       <functions title=""/>
       <variables title=""/>
       <signals title=""/>
       <publicslots title=""/>
       <protectedslots title=""/>
       <privateslots title=""/>
       <events title=""/>
       <properties title=""/>
       <friends title=""/>
     </memberdef>
     <authorsection visible="yes"/>
   </group>
 
   <!-- Layout definition for a directory page -->
   <directory>
     <briefdescription visible="yes"/>
     <directorygraph visible="yes"/>
     <memberdecl>
       <dirs visible="yes"/>
       <files visible="yes"/>
     </memberdecl>
     <detaileddescription title=""/>
   </directory>
 </doxygenlayout>
diff --git a/Documentation/mitk_doxygen_extra.css b/Documentation/mitk_doxygen_extra.css
index 2e2cef5271..a8c790b24d 100644
--- a/Documentation/mitk_doxygen_extra.css
+++ b/Documentation/mitk_doxygen_extra.css
@@ -1,140 +1,140 @@
 /* Main Doxygen CSS overrides */
 
-@import url(http://fonts.googleapis.com/css?family=Open+Sans);
+@import url(https://fonts.googleapis.com/css?family=Open+Sans);
 
 body, table, div, p, dl {
   font-family: 'Open Sans', Lucida Grande, Verdana, Geneva, Arial, sans-serif;
 }
 
 a {
   color: #2d5c88;
 }
 
 #top {
   border-bottom: 1px solid #e1e1e1;
 }
 
 .navpath ul {
   background-image:none;
   color:#dddddd;
 }
 
 .navpath li.navelem a {
   color: inherit;
   font-family: inherit;
   text-shadow: none;
 }
 
 #projectname {
   visibility: hidden;
   height: 70px;
   margin-left: -520px;
 }
 
 #projectbrief {
   display: none;
 }
 
 #projectnumber {
   font: inherit;
   visibility: visible;
   font-size: 12px;
   position: relative;
   top: 17px;
   left: 80px;
 }
 
 #titlearea table tbody>tr:first-child>td:first-child {
   background: url(mitkLogo.jpg) 0 0 no-repeat;
   padding-right: 15px;
 }
 
 /* Doxygen navtree.css overrides */
 
 #nav-tree .label {
   font: inherit;
 }
 
 #nav-tree {
   background-color: inherit;
 }
 
 #nav-tree {
   background-image:none;
   background-color: inherit;
 }
 
 /* Doxygen tabs.css overrides */
 
 .tabs, .tabs2, .tabs3 {
   background-image: none;
   font-family: inherit;
 }
 
 .tabs2 {
   font-size: 12px;
 }
 
 .tablist {
   margin: 0 auto;
 }
 
 .tablist li {
   background-image: none;
 }
 
 .tablist a {
   background-image:none;
   color: #808080;
   transition:all .3s ease-out;
   border-bottom:2px solid transparent;
 }
 
 .tablist a:hover {
   background-image:none;
   text-shadow: none;
   color: #333333;
   border-bottom: 2px solid #2d5c88;
 }
 
 .tablist li.current a {
   background-image:none;
   text-shadow: none;
   color: #333333;
   border-bottom: 2px solid #2d5c88;
 }
 
 /* Search field */
 
 #MSearchBox .left {
   border-style: solid none solid solid;
   border-width: 1px;
   background: none;
   border-color: #000000;
 }
 
 #MSearchField {
   margin-top: -1px;
   border-style: solid none;
   border-width: 1px;
   border-color: #000000;
   background: none;
   padding-top: 0px;
   padding-bottom: 0px;
 }
 
 #MSearchBox .right {
   border-style: solid solid solid none;
   border-width: 1px;
   background: none;
   border-color: #000000;
 }
 
 #MSearchResultsWindow {
   background-color: #ffffff;
 }
 
 #MSearchSelectWindow {
   border-color: #000000;
   background-color: #ffffff;
 }
diff --git a/Examples/BlueBerryExampleLauncher/Configurations/CustomViewer.cmake b/Examples/BlueBerryExampleLauncher/Configurations/CustomViewer.cmake
index 8341577b97..1379663bea 100644
--- a/Examples/BlueBerryExampleLauncher/Configurations/CustomViewer.cmake
+++ b/Examples/BlueBerryExampleLauncher/Configurations/CustomViewer.cmake
@@ -1,23 +1,23 @@
 set(REQUIRED_PLUGINS
   org.mitk.example.gui.customviewer
   org.mitk.gui.qt.datamanager
   org.mitk.example.gui.customviewer.views
 )
 
 set(DESCRIPTION
 "The Custom Viewer Example is a BlueBerry example plugin, developed to demonstrate customization capabilities provided by the BlueBerry application framework. The example plugin implements a GUI customized viewer application. The developed viewer incorporates simple viewer functionality embedded in a customized graphical user interface.
 
 <p>
 Spoken in BlueBerry terms, the following features are provided:
 
 <ul>
 <li> Hidden Menu-, Tool- and Statusbars </li>
 <li> Hidden Editor Area </li>
 <li> Fixed perspectives </li>
 <li> Customized main window contents </li>
 <li> Customized perspectives bar based on QTabBar </li>
 <li> GUI Customization using Qt-Stylesheets </li>
 </ul>
 
-See the main <a href=\"http://docs.mitk.org/nightly/BlueBerryExampleCustomViewer.html\">documentation</a> for details."
+See the main <a href=\"https://docs.mitk.org/nightly/BlueBerryExampleCustomViewer.html\">documentation</a> for details."
 )
diff --git a/Examples/BlueBerryExampleLauncher/Configurations/ExtensionPointDefinition.cmake b/Examples/BlueBerryExampleLauncher/Configurations/ExtensionPointDefinition.cmake
index aa5691918d..7a2f36ac71 100644
--- a/Examples/BlueBerryExampleLauncher/Configurations/ExtensionPointDefinition.cmake
+++ b/Examples/BlueBerryExampleLauncher/Configurations/ExtensionPointDefinition.cmake
@@ -1,19 +1,19 @@
 set(REQUIRED_PLUGINS
   org.mitk.example.gui.extensionpointdefinition
   org.mitk.example.gui.extensionpointcontribution
 )
 
 set(DESCRIPTION
 "This BlueBerry example consists of two plugins that demonstrate the use of the extension point concept. The first plugin defines an extension point and holds the GUI. The user can insert a text in a text field. The second plugin contributes an extension in the form of two classes that can change the user text to upper or lower case.
 
 <p>
 The following features are demonstrated:
 
 <ul>
 <li> creating an extension point </li>
 <li> creating an extension </li>
 <li> collecting extensions for an extension point </li>
 </ul>
 
-See the main <a href=\"http://docs.mitk.org/nightly/BlueBerryExampleExtensionPoint.html\">documentation</a> for details."
+See the main <a href=\"https://docs.mitk.org/nightly/BlueBerryExampleExtensionPoint.html\">documentation</a> for details."
 )
diff --git a/Examples/BlueBerryExampleLauncher/Configurations/MinimalApplication.cmake b/Examples/BlueBerryExampleLauncher/Configurations/MinimalApplication.cmake
index d6d30ed8fd..30d21d369a 100644
--- a/Examples/BlueBerryExampleLauncher/Configurations/MinimalApplication.cmake
+++ b/Examples/BlueBerryExampleLauncher/Configurations/MinimalApplication.cmake
@@ -1,17 +1,17 @@
 set(REQUIRED_PLUGINS
   org.mitk.example.gui.minimalapplication
 )
 
 set(DESCRIPTION
 "This BlueBerry example plugin demonstrates a minimal implementation of an application consisting only of an empty perspective.
 
 <p>
 The following features are demonstrated:
 
 <ul>
 <li> creating a new application </li>
 <li> creating a perspective </li>
 </ul>
 
-See the main <a href=\"http://docs.mitk.org/nightly/BlueBerryExampleMinimalApplication.html\">documentation</a> for details."
+See the main <a href=\"https://docs.mitk.org/nightly/BlueBerryExampleMinimalApplication.html\">documentation</a> for details."
 )
diff --git a/Examples/BlueBerryExampleLauncher/Configurations/MultiplePerspectives.cmake b/Examples/BlueBerryExampleLauncher/Configurations/MultiplePerspectives.cmake
index f7d468bd3c..6e59762bb6 100644
--- a/Examples/BlueBerryExampleLauncher/Configurations/MultiplePerspectives.cmake
+++ b/Examples/BlueBerryExampleLauncher/Configurations/MultiplePerspectives.cmake
@@ -1,20 +1,20 @@
 set(REQUIRED_PLUGINS
   org.mitk.example.gui.multipleperspectives
 )
 
 set(DESCRIPTION
 "This BlueBerry example plugin demonstrates the use of multiple perspectives and the perspective bar. The example plugin implements a minimal application with two perspectives and two empty views. This example is a direct extension of the 'minimal BlueBerry application' example.
 
 <p>
 The following features are demonstrated:
 
 <ul>
 <li> Hidden Editor Area </li>
 <li> creating a view </li>
 <li> using more than one perspective </li>
 <li> use of the perspective bar </li>
 <li> setting an initial size </li>
 </ul>
 
-See the main <a href=\"http://docs.mitk.org/nightly/BlueBerryExampleMultiplePerspectives.html\">documentation</a> for details."
+See the main <a href=\"https://docs.mitk.org/nightly/BlueBerryExampleMultiplePerspectives.html\">documentation</a> for details."
 )
diff --git a/Examples/BlueBerryExampleLauncher/Configurations/SelectionServiceMITK.cmake b/Examples/BlueBerryExampleLauncher/Configurations/SelectionServiceMITK.cmake
index aecc709ce0..5a28f6c257 100644
--- a/Examples/BlueBerryExampleLauncher/Configurations/SelectionServiceMITK.cmake
+++ b/Examples/BlueBerryExampleLauncher/Configurations/SelectionServiceMITK.cmake
@@ -1,19 +1,19 @@
 set(REQUIRED_PLUGINS
   org.mitk.example.gui.selectionservicemitk
   org.mitk.example.gui.selectionservicemitk.views
 )
 
 set(DESCRIPTION
 "The Selection Service MITK Example is a BlueBerry example plugin, developed to demonstrate the use and the concept of the selection service provided by MITK. The example plugin implements a selection service based on mitk data nodes. This example is an alternative for the Qt selection service described in the 'Selection Service QT' example.
 
 <p>
 The following features are demonstrated:
 
 <ul>
 <li> manually creating mitk data nodes </li>
 <li> creating qt list widget items </li>
 <li> reimplementation of the selection listener method </li>
 </ul>
 
-See the main <a href=\"http://docs.mitk.org/nightly/BlueBerrySelectionServiceIntro.html\">documentation</a> for details."
+See the main <a href=\"https://docs.mitk.org/nightly/BlueBerrySelectionServiceIntro.html\">documentation</a> for details."
 )
diff --git a/Examples/BlueBerryExampleLauncher/Configurations/SelectionServiceQT.cmake b/Examples/BlueBerryExampleLauncher/Configurations/SelectionServiceQT.cmake
index 8ec723b470..8095cf1d8c 100644
--- a/Examples/BlueBerryExampleLauncher/Configurations/SelectionServiceQT.cmake
+++ b/Examples/BlueBerryExampleLauncher/Configurations/SelectionServiceQT.cmake
@@ -1,18 +1,18 @@
 set(REQUIRED_PLUGINS
   org.mitk.example.gui.selectionserviceqt
 )
 
 set(DESCRIPTION
 "The Selection Service QT Example is a BlueBerry example plugin, developed to demonstrate the use and the concept of the selection service provided by Qt. The example plugin implements a selection service based on QListWidgetItems. A selection provider is created for a QListWidget and selection listener is used for the selection of two radio buttons. This example is an alternative for the MITK selection service described in the 'Selection Service MITK' example.
 
 <p>
 The following features are demonstrated:
 
 <ul>
 <li> creating a selection provider </li>
 <li> setting the selection model of the selection provider </li>
 <li> selection listener implementation </li>
 </ul>
 
-See the main <a href=\"http://docs.mitk.org/nightly/BlueBerrySelectionServiceIntro.html\">documentation</a> for details."
+See the main <a href=\"https://docs.mitk.org/nightly/BlueBerrySelectionServiceIntro.html\">documentation</a> for details."
 )
diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.customviewer.views/manifest_headers.cmake
index 9d97d71601..843e7b95ec 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/manifest_headers.cmake
@@ -1,8 +1,8 @@
 set(Plugin-Name "MITK Example Test Views")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin
  org.mitk.gui.qt.common # QmitkAbstractView
  )
 
diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.customviewer/manifest_headers.cmake
index 7cf2e7837d..058dcf0b91 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer/manifest_headers.cmake
@@ -1,9 +1,9 @@
 set(Plugin-Name "MITK Example Custom Viewer")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin
  org.mitk.core.ext # Registers file reader factories
  org.mitk.gui.qt.application # Initializes GlobalInteraction and registers MITK Core factories
  )
 
diff --git a/Examples/Plugins/org.mitk.example.gui.extensionpointcontribution/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.extensionpointcontribution/manifest_headers.cmake
index e45e6ae862..f353dbb990 100644
--- a/Examples/Plugins/org.mitk.example.gui.extensionpointcontribution/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.extensionpointcontribution/manifest_headers.cmake
@@ -1,8 +1,8 @@
 set(Plugin-Name "MITK Example: Extension Point Contribution")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin
   org.blueberry.ui.qt
   org.mitk.example.gui.extensionpointdefinition
 )
diff --git a/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/manifest_headers.cmake
index cba1e99058..537225e489 100644
--- a/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/manifest_headers.cmake
@@ -1,7 +1,7 @@
 set(Plugin-Name "MITK Example: Extension Point Definition")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin
   org.blueberry.ui.qt
 )
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.imaging/manifest_headers.cmake
index 45e5ae51ff..ad1561e537 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Examples")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Examples/Plugins/org.mitk.example.gui.minimalapplication/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.minimalapplication/manifest_headers.cmake
index 8ca4c41380..d0083fc102 100644
--- a/Examples/Plugins/org.mitk.example.gui.minimalapplication/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.minimalapplication/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "MITK Example Minimal Application")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.ui.qt)
 
diff --git a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/manifest_headers.cmake
index d0da20b9dc..053ad0f085 100644
--- a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/manifest_headers.cmake
@@ -1,7 +1,7 @@
 set(Plugin-Name "MITK Example: multiple perspectives and views")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin
   org.blueberry.ui.qt
 )
diff --git a/Examples/Plugins/org.mitk.example.gui.opencv/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.opencv/manifest_headers.cmake
index 8897e4cfed..4f58c01ac1 100644
--- a/Examples/Plugins/org.mitk.example.gui.opencv/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.opencv/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Examples OpenCV")
 set(Plugin-Version "1.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Examples/Plugins/org.mitk.example.gui.selectionservicemitk.views/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.selectionservicemitk.views/manifest_headers.cmake
index dcdb9807c2..b59bf17ec9 100644
--- a/Examples/Plugins/org.mitk.example.gui.selectionservicemitk.views/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.selectionservicemitk.views/manifest_headers.cmake
@@ -1,7 +1,7 @@
 set(Plugin-Name "MITK Example: Seletion service MITK")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin
   org.mitk.gui.qt.common
 )
diff --git a/Examples/Plugins/org.mitk.example.gui.selectionservicemitk/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.selectionservicemitk/manifest_headers.cmake
index 2eb89a444a..ddeb405483 100644
--- a/Examples/Plugins/org.mitk.example.gui.selectionservicemitk/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.selectionservicemitk/manifest_headers.cmake
@@ -1,7 +1,7 @@
 set(Plugin-Name "MITK Example: Seletion service MITK")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin
   org.blueberry.ui.qt
 )
diff --git a/Examples/Plugins/org.mitk.example.gui.selectionserviceqt/manifest_headers.cmake b/Examples/Plugins/org.mitk.example.gui.selectionserviceqt/manifest_headers.cmake
index 7c800b9b3f..7b788636a4 100644
--- a/Examples/Plugins/org.mitk.example.gui.selectionserviceqt/manifest_headers.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.selectionserviceqt/manifest_headers.cmake
@@ -1,7 +1,7 @@
 set(Plugin-Name "MITK Example: Seletion service QT")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin
   org.blueberry.ui.qt
 )
diff --git a/Licenses/OFL.txt b/Licenses/OFL.txt
index 1456c1809d..71cde63e28 100644
--- a/Licenses/OFL.txt
+++ b/Licenses/OFL.txt
@@ -1,97 +1,97 @@
 Copyright (c) <dates>, <Copyright Holder> (<URL|email>),
 with Reserved Font Name <Reserved Font Name>.
 Copyright (c) <dates>, <additional Copyright Holder> (<URL|email>),
 with Reserved Font Name <additional Reserved Font Name>.
 Copyright (c) <dates>, <additional Copyright Holder> (<URL|email>).
 
 This Font Software is licensed under the SIL Open Font License, Version 1.1.
 This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
+https://scripts.sil.org/OFL
 
 
 -----------------------------------------------------------
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
 -----------------------------------------------------------
 
 PREAMBLE
 The goals of the Open Font License (OFL) are to stimulate worldwide
 development of collaborative font projects, to support the font creation
 efforts of academic and linguistic communities, and to provide a free and
 open framework in which fonts may be shared and improved in partnership
 with others.
 
 The OFL allows the licensed fonts to be used, studied, modified and
 redistributed freely as long as they are not sold by themselves. The
 fonts, including any derivative works, can be bundled, embedded, 
 redistributed and/or sold with any software provided that any reserved
 names are not used by derivative works. The fonts and derivatives,
 however, cannot be released under any other type of license. The
 requirement for fonts to remain under this license does not apply
 to any document created using the fonts or their derivatives.
 
 DEFINITIONS
 "Font Software" refers to the set of files released by the Copyright
 Holder(s) under this license and clearly marked as such. This may
 include source files, build scripts and documentation.
 
 "Reserved Font Name" refers to any names specified as such after the
 copyright statement(s).
 
 "Original Version" refers to the collection of Font Software components as
 distributed by the Copyright Holder(s).
 
 "Modified Version" refers to any derivative made by adding to, deleting,
 or substituting -- in part or in whole -- any of the components of the
 Original Version, by changing formats or by porting the Font Software to a
 new environment.
 
 "Author" refers to any designer, engineer, programmer, technical
 writer or other person who contributed to the Font Software.
 
 PERMISSION & CONDITIONS
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of the Font Software, to use, study, copy, merge, embed, modify,
 redistribute, and sell modified and unmodified copies of the Font
 Software, subject to the following conditions:
 
 1) Neither the Font Software nor any of its individual components,
 in Original or Modified Versions, may be sold by itself.
 
 2) Original or Modified Versions of the Font Software may be bundled,
 redistributed and/or sold with any software, provided that each copy
 contains the above copyright notice and this license. These can be
 included either as stand-alone text files, human-readable headers or
 in the appropriate machine-readable metadata fields within text or
 binary files as long as those fields can be easily viewed by the user.
 
 3) No Modified Version of the Font Software may use the Reserved Font
 Name(s) unless explicit written permission is granted by the corresponding
 Copyright Holder. This restriction only applies to the primary font name as
 presented to the users.
 
 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
 Software shall not be used to promote, endorse or advertise any
 Modified Version, except to acknowledge the contribution(s) of the
 Copyright Holder(s) and the Author(s) or with their explicit written
 permission.
 
 5) The Font Software, modified or unmodified, in part or in whole,
 must be distributed entirely under this license, and must not be
 distributed under any other license. The requirement for fonts to
 remain under this license does not apply to any document created
 using the Font Software.
 
 TERMINATION
 This license becomes null and void if any of the above conditions are
 not met.
 
 DISCLAIMER
 THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
 OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
 COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
 OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/MITKCPackOptions.cmake.in b/MITKCPackOptions.cmake.in
index c4aabcee3d..5728c46f84 100644
--- a/MITKCPackOptions.cmake.in
+++ b/MITKCPackOptions.cmake.in
@@ -1,31 +1,31 @@
 
 if(CPACK_GENERATOR MATCHES "NSIS")
 
   # set the package header icon for MUI
   set(CPACK_PACKAGE_ICON "@MITK_SOURCE_DIR@\\mitk.bmp")
   # set the install/unistall icon used for the installer itself
   # There is a bug in NSIS that does not handle full unix paths properly. 
   set(CPACK_NSIS_MUI_ICON "@MITK_SOURCE_DIR@\\mitk.ico")
   set(CPACK_NSIS_MUI_UNIICON "@MITK_SOURCE_DIR@\\mitk.ico")
 
   set(CPACK_NSIS_DISPLAY_NAME "MITK - Medical Imaging and Interaction Toolkit")
   
   # tell cpack to create links to the doc files
   set(CPACK_NSIS_MENU_LINKS
-    "http://www.mitk.org" "MITK Web Site"
+    "https://www.mitk.org" "MITK Web Site"
     )
 
   # tell cpack the executables you want in the start menu as links
   set(CPACK_PACKAGE_EXECUTABLES "@MITK_CPACK_PACKAGE_EXECUTABLES@")
      
   # tell cpack to create a desktop link to MainApp
   set(CPACK_CREATE_DESKTOP_LINKS "@CPACK_CREATE_DESKTOP_LINKS@")
   set(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\mitk.ico")
   set(CPACK_NSIS_HELP_LINK "http:\\\\www.mitk.org")
   set(CPACK_NSIS_URL_INFO_ABOUT "http:\\\\www.mitk.org")
   set(CPACK_NSIS_CONTACT mitk@mitk.org)
   set(CPACK_NSIS_MODIFY_PATH ON)
   
 endif(CPACK_GENERATOR MATCHES "NSIS")
 
 
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h
index 528fd0ebf4..dde9e23548 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h
@@ -1,184 +1,184 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter_h
 #define __itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter_h
 
 #include "itkHistogram.h"
 #include "itkMacro.h"
 #include "itkProcessObject.h"
 #include "itkSimpleDataObjectDecorator.h"
 
 namespace itk {
   namespace Statistics {
     /** \class EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter
     *  \brief This class computes texture feature coefficients from a grey level
     * Zone-length matrix.
     *
     * By default, Zone length features are computed for each spatial
     * direction and then averaged afterward, so it is possible to access the
     * standard deviations of the texture features. These values give a clue as
     * to texture anisotropy. However, doing this is much more work, because it
     * involved computing one for each offset given. To compute a single matrix
     * using the first offset, call FastCalculationsOn(). If this is called,
     * then the texture standard deviations will not be computed (and will be set
     * to zero), but texture computation will be much faster.
     *
     * This class is templated over the input histogram type.
     *
     * Print references:
     * M. M. Galloway. Texture analysis using gray level Zone lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * Zone lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level Zone-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
-    * IJ article: http://hdl.handle.net/1926/1374
+    * IJ article: https://hdl.handle.net/1926/1374
     *
     * \sa ScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter
     * \sa ScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter
     * \sa EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template< typename THistogram >
     class EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter : public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter     Self;
       typedef ProcessObject                          Superclass;
       typedef SmartPointer<Self>                     Pointer;
       typedef SmartPointer<const Self>               ConstPointer;
 
       /** Zone-time type information (and related methods). */
       itkTypeMacro( EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter, ProcessObject );
 
       /** standard New() method support */
       itkNewMacro( Self );
 
       typedef THistogram                                      HistogramType;
       typedef typename HistogramType::Pointer                 HistogramPointer;
       typedef typename HistogramType::ConstPointer            HistogramConstPointer;
       typedef typename HistogramType::MeasurementType         MeasurementType;
       typedef typename HistogramType::MeasurementVectorType   MeasurementVectorType;
       typedef typename HistogramType::IndexType               IndexType;
       typedef typename HistogramType::
         TotalAbsoluteFrequencyType                            FrequencyType;
 
       /** Method to Set/Get the input Histogram */
       using Superclass::SetInput;
       void SetInput (const HistogramType * histogram );
       const HistogramType * GetInput() const;
 
       /** Smart Pointer type to a DataObject. */
       typedef DataObject::Pointer                   DataObjectPointer;
 
       /** Type of DataObjects used for scalar outputs */
       typedef SimpleDataObjectDecorator<MeasurementType>     MeasurementObjectType;
 
       /** Methods to return the short Zone emphasis. */
       MeasurementType GetCoarseness() const;
       const MeasurementObjectType* GetCoarsenessOutput() const;
 
       /** Methods to return the long Zone emphasis. */
       MeasurementType GetContrast() const;
       const MeasurementObjectType* GetContrastOutput() const;
 
       /** Methods to return the grey level nonuniformity. */
       MeasurementType GetBusyness() const;
       const MeasurementObjectType* GetBusynessOutput() const;
 
       /** Methods to return the Zone length nonuniformity. */
       MeasurementType GetComplexity() const;
       const MeasurementObjectType* GetComplexityOutput() const;
 
       /** Methods to return the low grey level Zone emphasis. */
       MeasurementType GetStrength() const;
       const MeasurementObjectType* GetStrengthOutput() const;
 
       itkGetMacro( TotalNumberOfValidVoxels, unsigned long );
 
       itkGetConstMacro(NumberOfVoxels, unsigned long);
       itkSetMacro(NumberOfVoxels, unsigned long);
 
       void SetSiMatrix(double* matrix)
       {
         m_siMatrix = matrix;
       }
 
       /** Zone-length feature types */
       typedef enum
       {
         Coarseness,
         Contrast,
         Busyness,
         Complexity,
         Strength
       }  NeighbourhoodGreyLevelDifferenceFeatureName;
 
       /** convenience method to access the Zone length values */
       MeasurementType GetFeature( NeighbourhoodGreyLevelDifferenceFeatureName name );
 
     protected:
       EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter();
       ~EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter() override {};
       void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;
 
       /** Make a DataObject to be used for output output. */
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       DataObjectPointer MakeOutput( DataObjectPointerArraySizeType ) ITK_OVERRIDE;
 
       void GenerateData() ITK_OVERRIDE;
 
     private:
       EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter(const Self&); //purposely not implemented
       void operator=(const Self&); //purposely not implemented
 
       unsigned long                           m_TotalNumberOfValidVoxels;
       unsigned long                           m_NumberOfVoxels;
 
       double*                                 m_siMatrix;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx
index d4d195f2c4..c2ccadf2b6 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx
@@ -1,326 +1,326 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter_hxx
 #define __itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter_hxx
 
 #include "itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h"
 
 #include "itkNumericTraits.h"
 #include "vnl/vnl_math.h"
 
 namespace itk {
 namespace Statistics {
 //constructor
 template<typename THistogram>
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter() :
   m_NumberOfVoxels(1)
 {
   this->ProcessObject::SetNumberOfRequiredInputs( 1 );
 
   // allocate the data objects for the outputs which are
   // just decorators real types
   for( unsigned int i = 0; i < 5; i++ )
   {
     this->ProcessObject::SetNthOutput( i, this->MakeOutput( i ) );
   }
 }
 
 template<typename THistogram>
 void
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>
 ::SetInput(const HistogramType *histogram )
 {
   this->ProcessObject::SetNthInput( 0, const_cast<HistogramType*>( histogram ) );
 }
 
 
 template<typename THistogram>
 const typename
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::HistogramType *
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>
 ::GetInput() const
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return ITK_NULLPTR;
   }
   return itkDynamicCastInDebugMode<const HistogramType *>(this->ProcessObject::GetInput(0) );
 }
 
 template<typename THistogram>
 typename
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::DataObjectPointer
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
 {
   return MeasurementObjectType::New().GetPointer();
 }
 
 template<typename THistogram>
 void
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>::
 GenerateData( void )
 {
   const HistogramType * inputHistogram = this->GetInput(); //The nis
 
   this->m_TotalNumberOfValidVoxels = static_cast<unsigned long>
       ( inputHistogram->GetTotalFrequency() );
 
   MeasurementType coarseness  = NumericTraits<MeasurementType>::ZeroValue();
   MeasurementType contrast    = NumericTraits<MeasurementType>::ZeroValue();
   MeasurementType busyness    = NumericTraits<MeasurementType>::ZeroValue();
   MeasurementType complexity  = NumericTraits<MeasurementType>::ZeroValue();
   MeasurementType strength    = NumericTraits<MeasurementType>::ZeroValue();
 
   typedef typename HistogramType::ConstIterator HistogramIterator;
 
   long unsigned int Ng = inputHistogram->GetSize(0);
   std::cout << "No of bins: " << Ng << "  total number of valid voxels: " << this->m_TotalNumberOfValidVoxels << std::endl;
 
   double sumPiSi    = 0.0;
   double sumSi      = 0.0;
   unsigned int Ngp  = 0;
   unsigned int Nv   = 0;
 
   //Calculate sum(pi*si).
   for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
   {
     IndexType index = hit.GetIndex();
 
     MeasurementType ni = hit.GetFrequency();
     double si = m_siMatrix[index[0]];
     if ( ni == 0 )
     {
       continue;
     }
     sumPiSi += ni*si;
     sumSi += si;
     Ngp++;
     Nv += ni;
   }
 
   sumPiSi /= (Nv > 0) ? Nv : 1;
 
 
   //Calculate the other features
   //pi = ni / Nv, so we can simply calculate with ni instead of pi
 
   double pipj   = 0.0;
   double ipijpj = 0.0;
   double complexitySum = 0.0;
   double strengthSum = 0.0;
 
   for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
   {
     MeasurementVectorType measurement = hit.GetMeasurementVector();
     IndexType index = hit.GetIndex();
     //MITK_WARN << "current index " << index;
 
     MeasurementType ni = hit.GetFrequency();
     double si = m_siMatrix[index[0]];
 
     double i = measurement[0];
 
     for ( HistogramIterator hit2 = inputHistogram->Begin();
           hit2 != inputHistogram->End(); ++hit2 )
     {
       MeasurementVectorType measurement2 = hit2.GetMeasurementVector();
       IndexType index2 = hit2.GetIndex();
 
       MeasurementType nj= hit2.GetFrequency();
       double sj = m_siMatrix[index2[0]];
 
       double j = measurement2[0];
 
       pipj += ni*nj*(i-j)*(i-j);
       ipijpj += std::abs(i*ni - j*nj);
 
       if(ni != 0 && nj != 0)
         complexitySum += std::abs(i-j) * (ni*si + nj*sj)/(ni+nj);
 
       strengthSum += (ni+nj)*(i-j)*(i-j);
     }
   }
 
 
   //Calculate Coarseness
   coarseness = (sumPiSi == 0) ? 1e6 : 1.0 / sumPiSi;
   contrast = (Ngp <= 1 || Nv == 0) ? 0 : (1.0/(Ngp * (Ngp - 1))*pipj / Nv / Nv) * (sumSi / Nv / Nv);
   busyness = (Ngp <= 1 || ipijpj == 0) ? 0 : sumPiSi / ipijpj / Nv;
   complexity = (Nv == 0) ? 0: complexitySum / Nv / Nv;
   strength = (sumSi == 0 || Nv == 0) ? 0 : strengthSum / Nv / sumSi;
 
   //Calculate the other features.
 
   MeasurementObjectType* CoarsenessOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 0 ) );
   CoarsenessOutputObject->Set( coarseness );
 
   MeasurementObjectType* ContrastOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
   ContrastOutputObject->Set( contrast );
 
   MeasurementObjectType* BusynessOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 2 ) );
   BusynessOutputObject->Set( busyness );
 
   MeasurementObjectType* ComplexityOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 3 ) );
   ComplexityOutputObject->Set( complexity );
 
   MeasurementObjectType* StrengthOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
   StrengthOutputObject->Set( strength );
 
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetCoarsenessOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 0 ) );
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetContrastOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetBusynessOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 2 ) );
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetComplexityOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 3 ) );
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetStrengthOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
 }
 
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetCoarseness() const
 {
   return this->GetCoarsenessOutput()->Get();
 }
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetContrast() const
 {
   return this->GetContrastOutput()->Get();
 }
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetBusyness() const
 {
   return this->GetBusynessOutput()->Get();
 }
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetComplexity() const
 {
   return this->GetComplexityOutput()->Get();
 }
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetStrength() const
 {
   return this->GetStrengthOutput()->Get();
 }
 
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetFeature( NeighbourhoodGreyLevelDifferenceFeatureName feature )
 {
   switch( feature )
   {
   case Coarseness:
     return this->GetCoarseness();
   case Contrast:
     return this->GetContrast();
   case Busyness:
     return this->GetBusyness();
   case Complexity:
     return this->GetComplexity();
   case Strength:
     return this->GetStrength();
   default:
     return 0;
   }
 }
 
 template< typename THistogram>
 void
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>::
 PrintSelf(std::ostream& os, Indent indent) const
 {
   Superclass::PrintSelf( os,indent );
 }
 } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.h
index 9bd7524ec5..568ac5b7b9 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.h
@@ -1,237 +1,237 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedHistogramToRunLengthFeaturesFilter_h
 #define __itkEnhancedHistogramToRunLengthFeaturesFilter_h
 
 #include "itkHistogram.h"
 #include "itkMacro.h"
 #include "itkProcessObject.h"
 #include "itkSimpleDataObjectDecorator.h"
 
 namespace itk {
   namespace Statistics {
     /** \class EnhancedHistogramToRunLengthFeaturesFilter
     *  \brief This class computes texture feature coefficients from a grey level
     * run-length matrix.
     *
     * By default, run length features are computed for each spatial
     * direction and then averaged afterward, so it is possible to access the
     * standard deviations of the texture features. These values give a clue as
     * to texture anisotropy. However, doing this is much more work, because it
     * involved computing one for each offset given. To compute a single matrix
     * using the first offset, call FastCalculationsOn(). If this is called,
     * then the texture standard deviations will not be computed (and will be set
     * to zero), but texture computation will be much faster.
     *
     * This class is templated over the input histogram type.
     *
     * Print references:
     * M. M. Galloway. Texture analysis using gray level run lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * run lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level run-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
-    * IJ article: http://hdl.handle.net/1926/1374
+    * IJ article: https://hdl.handle.net/1926/1374
     *
     * \sa ScalarImageToRunLengthFeaturesFilter
     * \sa ScalarImageToRunLengthMatrixFilter
     * \sa EnhancedHistogramToRunLengthFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template< typename THistogram >
     class EnhancedHistogramToRunLengthFeaturesFilter : public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedHistogramToRunLengthFeaturesFilter     Self;
       typedef ProcessObject                          Superclass;
       typedef SmartPointer<Self>                     Pointer;
       typedef SmartPointer<const Self>               ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro( EnhancedHistogramToRunLengthFeaturesFilter, ProcessObject );
 
       /** standard New() method support */
       itkNewMacro( Self );
 
       typedef THistogram                                      HistogramType;
       typedef typename HistogramType::Pointer                 HistogramPointer;
       typedef typename HistogramType::ConstPointer            HistogramConstPointer;
       typedef typename HistogramType::MeasurementType         MeasurementType;
       typedef typename HistogramType::MeasurementVectorType   MeasurementVectorType;
       typedef typename HistogramType::IndexType               IndexType;
       typedef typename HistogramType::
         TotalAbsoluteFrequencyType                            FrequencyType;
 
       /** Method to Set/Get the input Histogram */
       using Superclass::SetInput;
       void SetInput ( const HistogramType * histogram );
       const HistogramType * GetInput() const;
 
       /** Smart Pointer type to a DataObject. */
       typedef DataObject::Pointer                   DataObjectPointer;
 
       /** Type of DataObjects used for scalar outputs */
       typedef SimpleDataObjectDecorator<MeasurementType>     MeasurementObjectType;
 
       /** Methods to return the short run emphasis. */
       MeasurementType GetShortRunEmphasis() const;
       const MeasurementObjectType* GetShortRunEmphasisOutput() const;
 
       /** Methods to return the long run emphasis. */
       MeasurementType GetLongRunEmphasis() const;
       const MeasurementObjectType* GetLongRunEmphasisOutput() const;
 
       /** Methods to return the grey level nonuniformity. */
       MeasurementType GetGreyLevelNonuniformity() const;
       const MeasurementObjectType* GetGreyLevelNonuniformityOutput() const;
 
       /** Methods to return the grey level nonuniformity. */
       MeasurementType GetGreyLevelNonuniformityNormalized() const;
       const MeasurementObjectType* GetGreyLevelNonuniformityNormalizedOutput() const;
 
       /** Methods to return the run length nonuniformity. */
       MeasurementType GetRunLengthNonuniformity() const;
       const MeasurementObjectType* GetRunLengthNonuniformityOutput() const;
 
       /** Methods to return the run length nonuniformity. */
       MeasurementType GetRunLengthNonuniformityNormalized() const;
       const MeasurementObjectType* GetRunLengthNonuniformityNormalizedOutput() const;
 
       /** Methods to return the low grey level run emphasis. */
       MeasurementType GetLowGreyLevelRunEmphasis() const;
       const MeasurementObjectType* GetLowGreyLevelRunEmphasisOutput() const;
 
       /** Methods to return the high grey level run emphasis. */
       MeasurementType GetHighGreyLevelRunEmphasis() const;
       const MeasurementObjectType* GetHighGreyLevelRunEmphasisOutput() const;
 
       /** Methods to return the short run low grey level run emphasis. */
       MeasurementType GetShortRunLowGreyLevelEmphasis() const;
       const MeasurementObjectType* GetShortRunLowGreyLevelEmphasisOutput() const;
 
       /** Methods to return the short run high grey level run emphasis. */
       MeasurementType GetShortRunHighGreyLevelEmphasis() const;
       const MeasurementObjectType* GetShortRunHighGreyLevelEmphasisOutput() const;
 
       /** Methods to return the long run low grey level run emphasis. */
       MeasurementType GetLongRunLowGreyLevelEmphasis() const;
       const MeasurementObjectType* GetLongRunLowGreyLevelEmphasisOutput() const;
 
       /** Methods to return the long run high grey level run emphasis. */
       MeasurementType GetLongRunHighGreyLevelEmphasis() const;
       const MeasurementObjectType* GetLongRunHighGreyLevelEmphasisOutput() const;
 
       /** Methods to return the long run high grey level run emphasis. */
       MeasurementType GetRunPercentage() const;
       const MeasurementObjectType* GetRunPercentageOutput() const;
 
       /** Methods to return the long run high grey level run emphasis. */
       MeasurementType GetNumberOfRuns() const;
       const MeasurementObjectType* GetNumberOfRunsOutput() const;
 
       /** Methods to return the grey level variance. */
       MeasurementType GetGreyLevelVariance() const;
       const MeasurementObjectType* GetGreyLevelVarianceOutput() const;
 
       /** Methods to return the run length variance. */
       MeasurementType GetRunLengthVariance() const;
       const MeasurementObjectType* GetRunLengthVarianceOutput() const;
 
       /** Methods to return the run entropy. */
       MeasurementType GetRunEntropy() const;
       const MeasurementObjectType* GetRunEntropyOutput() const;
 
       itkGetMacro( TotalNumberOfRuns, unsigned long );
 
       itkGetConstMacro(NumberOfVoxels, unsigned long);
       itkSetMacro(NumberOfVoxels, unsigned long);
 
       /** Run-length feature types */
       typedef enum
       {
         ShortRunEmphasis,
         LongRunEmphasis,
         GreyLevelNonuniformity,
         GreyLevelNonuniformityNormalized,
         RunLengthNonuniformity,
         RunLengthNonuniformityNormalized,
         LowGreyLevelRunEmphasis,
         HighGreyLevelRunEmphasis,
         ShortRunLowGreyLevelEmphasis,
         ShortRunHighGreyLevelEmphasis,
         LongRunLowGreyLevelEmphasis,
         LongRunHighGreyLevelEmphasis,
         RunPercentage,
         NumberOfRuns,
         GreyLevelVariance,
         RunLengthVariance,
         RunEntropy
       }  RunLengthFeatureName;
 
       /** convenience method to access the run length values */
       MeasurementType GetFeature( RunLengthFeatureName name );
 
     protected:
       EnhancedHistogramToRunLengthFeaturesFilter();
       ~EnhancedHistogramToRunLengthFeaturesFilter() override {};
       void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;
 
       /** Make a DataObject to be used for output output. */
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       DataObjectPointer MakeOutput( DataObjectPointerArraySizeType ) ITK_OVERRIDE;
 
       void GenerateData() ITK_OVERRIDE;
 
     private:
       EnhancedHistogramToRunLengthFeaturesFilter(const Self&); //purposely not implemented
       void operator=(const Self&); //purposely not implemented
 
       unsigned long                           m_TotalNumberOfRuns;
       unsigned long                           m_NumberOfVoxels;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedHistogramToRunLengthFeaturesFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.hxx
index 488404b32c..c4fc4748b3 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.hxx
@@ -1,658 +1,658 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedHistogramToRunLengthFeaturesFilter_hxx
 #define __itkEnhancedHistogramToRunLengthFeaturesFilter_hxx
 
 #include "itkEnhancedHistogramToRunLengthFeaturesFilter.h"
 
 #include "itkNumericTraits.h"
 #include "vnl/vnl_math.h"
 
 namespace itk {
   namespace Statistics {
     //constructor
     template<typename THistogram>
     EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::EnhancedHistogramToRunLengthFeaturesFilter() :
     m_NumberOfVoxels(1)
     {
       this->ProcessObject::SetNumberOfRequiredInputs( 1 );
 
       // allocate the data objects for the outputs which are
       // just decorators real types
       for( unsigned int i = 0; i < 17; i++ )
       {
         this->ProcessObject::SetNthOutput( i, this->MakeOutput( i ) );
       }
     }
 
     template<typename THistogram>
     void
       EnhancedHistogramToRunLengthFeaturesFilter< THistogram>
       ::SetInput( const HistogramType *histogram )
     {
       this->ProcessObject::SetNthInput( 0, const_cast<HistogramType*>( histogram ) );
     }
 
     template<typename THistogram>
     const typename
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::HistogramType *
       EnhancedHistogramToRunLengthFeaturesFilter< THistogram>
       ::GetInput() const
     {
       if ( this->GetNumberOfInputs() < 1 )
       {
         return ITK_NULLPTR;
       }
       return itkDynamicCastInDebugMode<const HistogramType *>(this->ProcessObject::GetInput( 0 ) );
     }
 
     template<typename THistogram>
     typename
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::DataObjectPointer
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
     {
       return MeasurementObjectType::New().GetPointer();
     }
 
     template<typename THistogram>
     void
       EnhancedHistogramToRunLengthFeaturesFilter< THistogram>::
       GenerateData( void )
     {
       const HistogramType * inputHistogram = this->GetInput();
 
       this->m_TotalNumberOfRuns = static_cast<unsigned long>
         ( inputHistogram->GetTotalFrequency() );
 
       MeasurementType shortRunEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType longRunEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType greyLevelNonuniformity = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType runLengthNonuniformity = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType lowGreyLevelRunEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType highGreyLevelRunEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType shortRunLowGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType shortRunHighGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType longRunLowGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType longRunHighGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType runPercentage = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType numberOfRuns = NumericTraits<MeasurementType>::ZeroValue();
       //Added 15.07.2016
       MeasurementType greyLevelVariance = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType runLengthVariance = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType runEntropy = NumericTraits<MeasurementType>::ZeroValue();
 
       //Added 09.09.2016
       MeasurementType greyLevelNonuniformityNormalized = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType runLengthNonuniformityNormalized = NumericTraits<MeasurementType>::ZeroValue();
 
       vnl_vector<double> greyLevelNonuniformityVector(
         inputHistogram->GetSize()[0], 0.0 );
       vnl_vector<double> runLengthNonuniformityVector(
         inputHistogram->GetSize()[1], 0.0 );
 
       typedef typename HistogramType::ConstIterator HistogramIterator;
 
       double mu_i = 0.0;
       double mu_j = 0.0;
 
       //Calculate the means.
       for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
       {
         IndexType index = hit.GetIndex();
         MeasurementType frequency = hit.GetFrequency();
 
         if ( frequency == 0 )
         {
           continue;
         }
 
         // MITK_INFO << index[0] + 1 << "|" << index[1] + 1 << " " << frequency;
 
         MeasurementVectorType measurement = hit.GetMeasurementVector();
 
 
         double i = index[0] + 1;
         double j = index[1] + 1;
 
         double p_ij = frequency / (1.0*m_TotalNumberOfRuns);
 
         mu_i += i * p_ij;
         mu_j += j * p_ij;
       }
       // MITK_INFO << "Mu_i " << mu_i << " Mu_j " << mu_j;
       //Calculate the other features.
       const double log2 = std::log(2.0);
 
       for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
       {
         MeasurementType frequency = hit.GetFrequency();
         if ( frequency == 0 )
         {
           continue;
         }
         MeasurementVectorType measurement = hit.GetMeasurementVector();
         IndexType index = hit.GetIndex();
         //      inputHistogram->GetIndex( hit.GetInstanceIdentifier() );
 
         double i = index[0] + 1;
         double j = index[1] + 1;
         double i2 = i*i;
         double j2 = j*j;
 
         double p_ij = frequency / m_TotalNumberOfRuns;
 
         greyLevelVariance += ((i - mu_i) * (i - mu_i) * p_ij);
         runLengthVariance += ((j - mu_j) * (j - mu_j) * p_ij);
         runEntropy -= ( p_ij > 0.0001 ) ? p_ij *std::log(p_ij) / log2 : 0;
 
         // Traditional measures
         shortRunEmphasis += ( frequency / j2 );
         longRunEmphasis += ( frequency * j2 );
 
         greyLevelNonuniformityVector[index[0]] += frequency;
         runLengthNonuniformityVector[index[1]] += frequency;
 
         // measures from Chu et al.
         lowGreyLevelRunEmphasis += (i2 > 0.0001) ? ( frequency / i2 ) : 0;
         highGreyLevelRunEmphasis += ( frequency * i2 );
 
         // measures from Dasarathy and Holder
         shortRunLowGreyLevelEmphasis += ((i2 * j2) > 0.0001) ? ( frequency / ( i2 * j2 ) ) : 0;
         shortRunHighGreyLevelEmphasis += (j2 > 0.0001) ? ( frequency * i2 / j2 ) : 0;
         longRunLowGreyLevelEmphasis += (i2 > 0.0001) ? ( frequency * j2 / i2 ) : 0;
         longRunHighGreyLevelEmphasis += ( frequency * i2 * j2 );
       }
       greyLevelNonuniformity =
         greyLevelNonuniformityVector.squared_magnitude();
       runLengthNonuniformity =
         runLengthNonuniformityVector.squared_magnitude();
 
       // Normalize all measures by the total number of runs
 
       if (this->m_TotalNumberOfRuns > 0)
       {
         shortRunEmphasis       /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         longRunEmphasis        /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         greyLevelNonuniformity /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         runLengthNonuniformity /=
           static_cast<double>( this->m_TotalNumberOfRuns );
 
         lowGreyLevelRunEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         highGreyLevelRunEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
 
         shortRunLowGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         shortRunHighGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         longRunLowGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         longRunHighGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         runPercentage = static_cast<double>( this->m_TotalNumberOfRuns ) / static_cast<double>( this->m_NumberOfVoxels );
         numberOfRuns = static_cast<double>( this->m_TotalNumberOfRuns ) ;
 
         greyLevelNonuniformityNormalized = greyLevelNonuniformity / static_cast<double>(this->m_TotalNumberOfRuns);
         runLengthNonuniformityNormalized = runLengthNonuniformity / static_cast<double>(this->m_TotalNumberOfRuns);
 
       } else {
         shortRunEmphasis        = 0;
         longRunEmphasis         = 0;
         greyLevelNonuniformity  = 0;
         runLengthNonuniformity= 0;
 
         lowGreyLevelRunEmphasis  = 0;
         highGreyLevelRunEmphasis = 0;
 
         shortRunLowGreyLevelEmphasis = 0;
         shortRunHighGreyLevelEmphasis= 0;
         longRunLowGreyLevelEmphasis  = 0;
         longRunHighGreyLevelEmphasis = 0;
         runPercentage = 0;
 
         greyLevelNonuniformityNormalized = 0;
         runLengthNonuniformityNormalized = 0;
 
         numberOfRuns = static_cast<double>( this->m_TotalNumberOfRuns ) ;
       }
 
       MeasurementObjectType* shortRunEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 0 ) );
       shortRunEmphasisOutputObject->Set( shortRunEmphasis );
 
       MeasurementObjectType* longRunEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
       longRunEmphasisOutputObject->Set( longRunEmphasis );
 
       MeasurementObjectType* greyLevelNonuniformityOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 2 ) );
       greyLevelNonuniformityOutputObject->Set( greyLevelNonuniformity );
 
       MeasurementObjectType* greyLevelNonuniformityNormalizedOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 15 ) );
       greyLevelNonuniformityNormalizedOutputObject->Set( greyLevelNonuniformityNormalized );
 
       MeasurementObjectType* runLengthNonuniformityNormalizedOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 16 ) );
       runLengthNonuniformityNormalizedOutputObject->Set( runLengthNonuniformityNormalized );
 
       MeasurementObjectType* runLengthNonuniformityOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 3 ) );
       runLengthNonuniformityOutputObject->Set( runLengthNonuniformity );
 
       MeasurementObjectType* lowGreyLevelRunEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
       lowGreyLevelRunEmphasisOutputObject->Set( lowGreyLevelRunEmphasis );
 
       MeasurementObjectType* highGreyLevelRunEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 5 ) );
       highGreyLevelRunEmphasisOutputObject->Set( highGreyLevelRunEmphasis );
 
       MeasurementObjectType* shortRunLowGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 6 ) );
       shortRunLowGreyLevelEmphasisOutputObject->Set( shortRunLowGreyLevelEmphasis );
 
       MeasurementObjectType* shortRunHighGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 7 ) );
       shortRunHighGreyLevelEmphasisOutputObject->Set(
         shortRunHighGreyLevelEmphasis );
 
       MeasurementObjectType* longRunLowGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 8 ) );
       longRunLowGreyLevelEmphasisOutputObject->Set( longRunLowGreyLevelEmphasis );
 
       MeasurementObjectType* longRunHighGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 9 ) );
       longRunHighGreyLevelEmphasisOutputObject->Set( longRunHighGreyLevelEmphasis );
 
       MeasurementObjectType* runPercentagesOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 10 ) );
       runPercentagesOutputObject->Set( runPercentage );
 
       MeasurementObjectType* numberOfRunsOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 11 ) );
       numberOfRunsOutputObject->Set( numberOfRuns );
 
       MeasurementObjectType* greyLevelVarianceOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 12 ) );
       greyLevelVarianceOutputObject->Set( greyLevelVariance );
 
       MeasurementObjectType* runLengthVarianceOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 13 ) );
       runLengthVarianceOutputObject->Set( runLengthVariance );
 
       MeasurementObjectType* runEntropyOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 14 ) );
       runEntropyOutputObject->Set( runEntropy );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 0 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformityOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 2 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthNonuniformityOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 3 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLowGreyLevelRunEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetHighGreyLevelRunEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 5 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunLowGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 6 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunHighGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 7 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunLowGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 8 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunHighGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 9 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunPercentageOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 10 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetNumberOfRunsOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 11 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelVarianceOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 12 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthVarianceOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 13 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunEntropyOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 14 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformityNormalizedOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 15 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthNonuniformityNormalizedOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 16 ) );
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunEmphasis() const
     {
       return this->GetShortRunEmphasisOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunEmphasis() const
     {
       return this->GetLongRunEmphasisOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformity() const
     {
       return this->GetGreyLevelNonuniformityOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthNonuniformity() const
     {
       return this->GetRunLengthNonuniformityOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLowGreyLevelRunEmphasis() const
     {
       return this->GetLowGreyLevelRunEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetHighGreyLevelRunEmphasis() const
     {
       return this->GetHighGreyLevelRunEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunLowGreyLevelEmphasis() const
     {
       return this->GetShortRunLowGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunHighGreyLevelEmphasis() const
     {
       return this->GetShortRunHighGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunLowGreyLevelEmphasis() const
     {
       return this->GetLongRunLowGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunHighGreyLevelEmphasis() const
     {
       return this->GetLongRunHighGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunPercentage() const
     {
       return this->GetRunPercentageOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetNumberOfRuns() const
     {
       return this->GetNumberOfRunsOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelVariance() const
     {
       return this->GetGreyLevelVarianceOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthVariance() const
     {
       return this->GetRunLengthVarianceOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunEntropy() const
     {
       return this->GetRunEntropyOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformityNormalized() const
     {
       return this->GetGreyLevelNonuniformityNormalizedOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthNonuniformityNormalized() const
     {
       return this->GetRunLengthNonuniformityNormalizedOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter< THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetFeature( RunLengthFeatureName feature )
     {
       switch( feature )
       {
       case ShortRunEmphasis:
         return this->GetShortRunEmphasis();
       case LongRunEmphasis:
         return this->GetLongRunEmphasis();
       case GreyLevelNonuniformity:
         return this->GetGreyLevelNonuniformity();
       case GreyLevelNonuniformityNormalized:
         return this->GetGreyLevelNonuniformityNormalized();
       case RunLengthNonuniformity:
         return this->GetRunLengthNonuniformity();
       case RunLengthNonuniformityNormalized:
         return this->GetRunLengthNonuniformityNormalized();
       case LowGreyLevelRunEmphasis:
         return this->GetLowGreyLevelRunEmphasis();
       case HighGreyLevelRunEmphasis:
         return this->GetHighGreyLevelRunEmphasis();
       case ShortRunLowGreyLevelEmphasis:
         return this->GetShortRunLowGreyLevelEmphasis();
       case ShortRunHighGreyLevelEmphasis:
         return this->GetShortRunHighGreyLevelEmphasis();
       case LongRunLowGreyLevelEmphasis:
         return this->GetLongRunLowGreyLevelEmphasis();
       case LongRunHighGreyLevelEmphasis:
         return this->GetLongRunHighGreyLevelEmphasis();
       case RunPercentage:
         return this->GetRunPercentage();
       case NumberOfRuns:
         return this->GetNumberOfRuns();
       case GreyLevelVariance:
         return this->GetGreyLevelVariance();
       case RunLengthVariance:
         return this->GetRunLengthVariance();
       case RunEntropy:
         return this->GetRunEntropy();
       default:
         return 0;
       }
     }
 
     template< typename THistogram>
     void
       EnhancedHistogramToRunLengthFeaturesFilter< THistogram>::
       PrintSelf(std::ostream& os, Indent indent) const
     {
       Superclass::PrintSelf( os,indent );
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToSizeZoneFeaturesFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToSizeZoneFeaturesFilter.h
index 6e86fee66f..167abc07e4 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToSizeZoneFeaturesFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToSizeZoneFeaturesFilter.h
@@ -1,236 +1,236 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedHistogramToSizeZoneFeaturesFilter_h
 #define __itkEnhancedHistogramToSizeZoneFeaturesFilter_h
 
 #include "itkHistogram.h"
 #include "itkMacro.h"
 #include "itkProcessObject.h"
 #include "itkSimpleDataObjectDecorator.h"
 
 namespace itk {
   namespace Statistics {
     /** \class EnhancedHistogramToSizeZoneFeaturesFilter
     *  \brief This class computes texture feature coefficients from a grey level
     * Zone-length matrix.
     *
     * By default, Zone length features are computed for each spatial
     * direction and then averaged afterward, so it is possible to access the
     * standard deviations of the texture features. These values give a clue as
     * to texture anisotropy. However, doing this is much more work, because it
     * involved computing one for each offset given. To compute a single matrix
     * using the first offset, call FastCalculationsOn(). If this is called,
     * then the texture standard deviations will not be computed (and will be set
     * to zero), but texture computation will be much faster.
     *
     * This class is templated over the input histogram type.
     *
     * Print references:
     * M. M. Galloway. Texture analysis using gray level Zone lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * Zone lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level Zone-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
-    * IJ article: http://hdl.handle.net/1926/1374
+    * IJ article: https://hdl.handle.net/1926/1374
     *
     * \sa ScalarImageToSizeZoneFeaturesFilter
     * \sa ScalarImageToSizeZoneMatrixFilter
     * \sa EnhancedHistogramToSizeZoneFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template< typename THistogram >
     class EnhancedHistogramToSizeZoneFeaturesFilter : public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedHistogramToSizeZoneFeaturesFilter     Self;
       typedef ProcessObject                          Superclass;
       typedef SmartPointer<Self>                     Pointer;
       typedef SmartPointer<const Self>               ConstPointer;
 
       /** Zone-time type information (and related methods). */
       itkTypeMacro( EnhancedHistogramToSizeZoneFeaturesFilter, ProcessObject );
 
       /** standard New() method support */
       itkNewMacro( Self );
 
       typedef THistogram                                      HistogramType;
       typedef typename HistogramType::Pointer                 HistogramPointer;
       typedef typename HistogramType::ConstPointer            HistogramConstPointer;
       typedef typename HistogramType::MeasurementType         MeasurementType;
       typedef typename HistogramType::MeasurementVectorType   MeasurementVectorType;
       typedef typename HistogramType::IndexType               IndexType;
       typedef typename HistogramType::
         TotalAbsoluteFrequencyType                            FrequencyType;
 
       /** Method to Set/Get the input Histogram */
       using Superclass::SetInput;
       void SetInput ( const HistogramType * histogram );
       const HistogramType * GetInput() const;
 
       /** Smart Pointer type to a DataObject. */
       typedef DataObject::Pointer                   DataObjectPointer;
 
       /** Type of DataObjects used for scalar outputs */
       typedef SimpleDataObjectDecorator<MeasurementType>     MeasurementObjectType;
 
       /** Methods to return the short Zone emphasis. */
       MeasurementType GetSmallZoneEmphasis() const;
       const MeasurementObjectType* GetSmallZoneEmphasisOutput() const;
 
       /** Methods to return the long Zone emphasis. */
       MeasurementType GetLargeZoneEmphasis() const;
       const MeasurementObjectType* GetLargeZoneEmphasisOutput() const;
 
       /** Methods to return the grey level nonuniformity. */
       MeasurementType GetGreyLevelNonuniformity() const;
       const MeasurementObjectType* GetGreyLevelNonuniformityOutput() const;
 
       /** Methods to return the grey level nonuniformity normalized. */
       MeasurementType GetGreyLevelNonuniformityNormalized() const;
       const MeasurementObjectType* GetGreyLevelNonuniformityNormalizedOutput() const;
 
       /** Methods to return the Zone length nonuniformity. */
       MeasurementType GetSizeZoneNonuniformity() const;
       const MeasurementObjectType* GetSizeZoneNonuniformityOutput() const;
 
       /** Methods to return the Zone length nonuniformity normalized. */
       MeasurementType GetSizeZoneNonuniformityNormalized() const;
       const MeasurementObjectType* GetSizeZoneNonuniformityNormalizedOutput() const;
 
       /** Methods to return the low grey level Zone emphasis. */
       MeasurementType GetLowGreyLevelZoneEmphasis() const;
       const MeasurementObjectType* GetLowGreyLevelZoneEmphasisOutput() const;
 
       /** Methods to return the high grey level Zone emphasis. */
       MeasurementType GetHighGreyLevelZoneEmphasis() const;
       const MeasurementObjectType* GetHighGreyLevelZoneEmphasisOutput() const;
 
       /** Methods to return the short Zone low grey level Zone emphasis. */
       MeasurementType GetSmallZoneLowGreyLevelEmphasis() const;
       const MeasurementObjectType* GetSmallZoneLowGreyLevelEmphasisOutput() const;
 
       /** Methods to return the short Zone high grey level Zone emphasis. */
       MeasurementType GetSmallZoneHighGreyLevelEmphasis() const;
       const MeasurementObjectType* GetSmallZoneHighGreyLevelEmphasisOutput() const;
 
       /** Methods to return the long Zone low grey level Zone emphasis. */
       MeasurementType GetLargeZoneLowGreyLevelEmphasis() const;
       const MeasurementObjectType* GetLargeZoneLowGreyLevelEmphasisOutput() const;
 
       /** Methods to return the long Zone high grey level Zone emphasis. */
       MeasurementType GetLargeZoneHighGreyLevelEmphasis() const;
       const MeasurementObjectType* GetLargeZoneHighGreyLevelEmphasisOutput() const;
 
       /** Methods to return the long Zone high grey level Zone emphasis. */
       MeasurementType GetZonePercentage() const;
       const MeasurementObjectType* GetZonePercentageOutput() const;
 
       /** Methods to return the long Zone high grey level Zone emphasis. */
       MeasurementType GetNumberOfZones() const;
       const MeasurementObjectType* GetNumberOfZonesOutput() const;
 
       /** Methods to return the grey level variance. */
       MeasurementType GetGreyLevelVariance() const;
       const MeasurementObjectType* GetGreyLevelVarianceOutput() const;
 
       /** Methods to return the Zone length variance. */
       MeasurementType GetSizeZoneVariance() const;
       const MeasurementObjectType* GetSizeZoneVarianceOutput() const;
 
       /** Methods to return the Zone entropy. */
       MeasurementType GetZoneEntropy() const;
       const MeasurementObjectType* GetZoneEntropyOutput() const;
 
       itkGetMacro( TotalNumberOfZones, unsigned long );
 
       itkGetConstMacro(NumberOfVoxels, unsigned long);
       itkSetMacro(NumberOfVoxels, unsigned long);
 
       /** Zone-length feature types */
       typedef enum
       {
         SmallZoneEmphasis,
         LargeZoneEmphasis,
         GreyLevelNonuniformity,
         GreyLevelNonuniformityNormalized,
         SizeZoneNonuniformity,
         SizeZoneNonuniformityNormalized,
         LowGreyLevelZoneEmphasis,
         HighGreyLevelZoneEmphasis,
         SmallZoneLowGreyLevelEmphasis,
         SmallZoneHighGreyLevelEmphasis,
         LargeZoneLowGreyLevelEmphasis,
         LargeZoneHighGreyLevelEmphasis,
         ZonePercentage,
         GreyLevelVariance,
         SizeZoneVariance,
         ZoneEntropy
       }  SizeZoneFeatureName;
 
       /** convenience method to access the Zone length values */
       MeasurementType GetFeature( SizeZoneFeatureName name );
 
     protected:
       EnhancedHistogramToSizeZoneFeaturesFilter();
       ~EnhancedHistogramToSizeZoneFeaturesFilter() {};
       virtual void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;
 
       /** Make a DataObject to be used for output output. */
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       virtual DataObjectPointer MakeOutput( DataObjectPointerArraySizeType ) ITK_OVERRIDE;
 
       virtual void GenerateData() ITK_OVERRIDE;
 
     private:
       EnhancedHistogramToSizeZoneFeaturesFilter(const Self&); //purposely not implemented
       void operator=(const Self&); //purposely not implemented
 
       unsigned long                           m_TotalNumberOfZones;
       unsigned long                           m_NumberOfVoxels;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedHistogramToSizeZoneFeaturesFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToSizeZoneFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToSizeZoneFeaturesFilter.hxx
index 5effb5f15f..f698fc2b60 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToSizeZoneFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToSizeZoneFeaturesFilter.hxx
@@ -1,665 +1,665 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedHistogramToSizeZoneFeaturesFilter_hxx
 #define __itkEnhancedHistogramToSizeZoneFeaturesFilter_hxx
 
 #include "itkEnhancedHistogramToSizeZoneFeaturesFilter.h"
 
 #include "itkNumericTraits.h"
 #include "vnl/vnl_math.h"
 
 namespace itk {
   namespace Statistics {
     //constructor
     template<typename THistogram>
     EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::EnhancedHistogramToSizeZoneFeaturesFilter() :
     m_NumberOfVoxels(1)
     {
       this->ProcessObject::SetNumberOfRequiredInputs( 1 );
 
       // allocate the data objects for the outputs which are
       // just decorators real types
       for( unsigned int i = 0; i < 17; i++ )
       {
         this->ProcessObject::SetNthOutput( i, this->MakeOutput( i ) );
       }
     }
 
     template<typename THistogram>
     void
       EnhancedHistogramToSizeZoneFeaturesFilter< THistogram>
       ::SetInput( const HistogramType *histogram )
     {
       this->ProcessObject::SetNthInput( 0, const_cast<HistogramType*>( histogram ) );
     }
 
     template<typename THistogram>
     const typename
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::HistogramType *
       EnhancedHistogramToSizeZoneFeaturesFilter< THistogram>
       ::GetInput() const
     {
       if ( this->GetNumberOfInputs() < 1 )
       {
         return ITK_NULLPTR;
       }
       return itkDynamicCastInDebugMode<const HistogramType *>(this->ProcessObject::GetInput( 0 ) );
     }
 
     template<typename THistogram>
     typename
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::DataObjectPointer
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
     {
       return MeasurementObjectType::New().GetPointer();
     }
 
     template<typename THistogram>
     void
       EnhancedHistogramToSizeZoneFeaturesFilter< THistogram>::
       GenerateData( void )
     {
       const HistogramType * inputHistogram = this->GetInput();
 
       this->m_TotalNumberOfZones = static_cast<unsigned long>
         ( inputHistogram->GetTotalFrequency() );
 
       MeasurementType SmallZoneEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType LargeZoneEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType greyLevelNonuniformity = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType SizeZoneNonuniformity = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType lowGreyLevelZoneEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType highGreyLevelZoneEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType SmallZoneLowGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType SmallZoneHighGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType LargeZoneLowGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType LargeZoneHighGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType ZonePercentage = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType numberOfZones = NumericTraits<MeasurementType>::ZeroValue();
       //Added 15.07.2016
       MeasurementType greyLevelVariance = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType SizeZoneVariance = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType ZoneEntropy = NumericTraits<MeasurementType>::ZeroValue();
 
       //Added 09.09.2016
       MeasurementType greyLevelNonuniformityNormalized = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType SizeZoneNonuniformityNormalized = NumericTraits<MeasurementType>::ZeroValue();
 
 
       vnl_vector<double> greyLevelNonuniformityVector(
         inputHistogram->GetSize()[0], 0.0 );
       vnl_vector<double> SizeZoneNonuniformityVector(
         inputHistogram->GetSize()[1], 0.0 );
 
       typedef typename HistogramType::ConstIterator HistogramIterator;
 
       double mu_i = 0.0;
       double mu_j = 0.0;
 
       //Calculate the means.
       for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
       {
         MeasurementType frequency = hit.GetFrequency();
         if ( frequency == 0 )
         {
           continue;
         }
         MeasurementVectorType measurement = hit.GetMeasurementVector();
         IndexType index = hit.GetIndex();
 
         int value = floor(measurement[0] + 0.5);
         int count = measurement[1];
 
         double i = value;
         double j = count;
 
         double p_ij = frequency / m_TotalNumberOfZones;
 
         mu_i += i * p_ij;
         mu_j += j * p_ij;
       }
 
       //Calculate the other features.
       const double log2 = std::log(2.0);
       int totNumOfVoxelsUsed = 0;
 
       for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
       {
         MeasurementType frequency = hit.GetFrequency();
         if ( frequency == 0 )
         {
           continue;
         }
         MeasurementVectorType measurement = hit.GetMeasurementVector();
         IndexType index = hit.GetIndex();
         //      inputHistogram->GetIndex( hit.GetInstanceIdentifier() );
 
         int value = floor(measurement[0] + 0.5);
         int count = measurement[1];
 
         double i = value;
         double j = count;
 
         double i2 = static_cast<double>( i*i );
         double j2 = static_cast<double>( j*j );
 
         double p_ij = frequency / m_TotalNumberOfZones;
 
         greyLevelVariance += ((i - mu_i) * (i - mu_i) * p_ij);
         SizeZoneVariance += ((j - mu_j) * (j - mu_j) * p_ij);
         ZoneEntropy -= ( p_ij > 0.0001 ) ? p_ij *std::log(p_ij) / log2 : 0;
 
         // Traditional measures
         SmallZoneEmphasis += ( frequency / j2 );
         LargeZoneEmphasis += ( frequency * j2 );
 
         greyLevelNonuniformityVector[index[0]] += frequency;
         SizeZoneNonuniformityVector[index[1]] += frequency;
 
         // measures from Chu et al.
         lowGreyLevelZoneEmphasis += (i2 > 0.0001) ? ( frequency / i2 ) : 0;
         highGreyLevelZoneEmphasis += ( frequency * i2 );
 
         // measures from Dasarathy and Holder
         SmallZoneLowGreyLevelEmphasis += ((i2 * j2) > 0.0001) ? ( frequency / ( i2 * j2 ) ) : 0;
         SmallZoneHighGreyLevelEmphasis += (j2 > 0.00001) ? ( frequency * i2 / j2 ) : 0;
         LargeZoneLowGreyLevelEmphasis += (i2 > 0.00001) ? ( frequency * j2 / i2 ) : 0;
         LargeZoneHighGreyLevelEmphasis += ( frequency * i2 * j2 );
 
         totNumOfVoxelsUsed += (frequency);
       }
       greyLevelNonuniformity =
         greyLevelNonuniformityVector.squared_magnitude();
       SizeZoneNonuniformity =
         SizeZoneNonuniformityVector.squared_magnitude();
 
       // Normalize all measures by the total number of Zones
 
       m_TotalNumberOfZones = totNumOfVoxelsUsed;
 
       if (this->m_TotalNumberOfZones > 0)
       {
         SmallZoneEmphasis       /=
           static_cast<double>( this->m_TotalNumberOfZones );
         LargeZoneEmphasis        /=
           static_cast<double>( this->m_TotalNumberOfZones );
         greyLevelNonuniformity /=
           static_cast<double>( this->m_TotalNumberOfZones );
         SizeZoneNonuniformity /=
           static_cast<double>( this->m_TotalNumberOfZones );
 
         lowGreyLevelZoneEmphasis /=
           static_cast<double>( this->m_TotalNumberOfZones );
         highGreyLevelZoneEmphasis /=
           static_cast<double>( this->m_TotalNumberOfZones );
 
         SmallZoneLowGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfZones );
         SmallZoneHighGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfZones );
         LargeZoneLowGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfZones );
         LargeZoneHighGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfZones );
         ZonePercentage = static_cast<double>( this->m_TotalNumberOfZones ) / static_cast<double>( this->m_NumberOfVoxels );
         numberOfZones = static_cast<double>( this->m_TotalNumberOfZones ) ;
 
         greyLevelNonuniformityNormalized = greyLevelNonuniformity / static_cast<double>(this->m_TotalNumberOfZones);
         SizeZoneNonuniformityNormalized = SizeZoneNonuniformity / static_cast<double>(this->m_TotalNumberOfZones);
 
       } else {
         SmallZoneEmphasis      = 0;
         LargeZoneEmphasis      = 0;
         greyLevelNonuniformity = 0;
         SizeZoneNonuniformity  = 0;
         greyLevelNonuniformityNormalized = 0;
         SizeZoneNonuniformityNormalized  = 0;
 
         lowGreyLevelZoneEmphasis  = 0;
         highGreyLevelZoneEmphasis = 0;
 
         SmallZoneLowGreyLevelEmphasis = 0;
         SmallZoneHighGreyLevelEmphasis= 0;
         LargeZoneLowGreyLevelEmphasis = 0;
         LargeZoneHighGreyLevelEmphasis= 0;
         ZonePercentage = 0;
         numberOfZones = static_cast<double>( this->m_TotalNumberOfZones ) ;
       }
 
       MeasurementObjectType* SmallZoneEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 0 ) );
       SmallZoneEmphasisOutputObject->Set( SmallZoneEmphasis );
 
       MeasurementObjectType* LargeZoneEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
       LargeZoneEmphasisOutputObject->Set( LargeZoneEmphasis );
 
       MeasurementObjectType* greyLevelNonuniformityOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 2 ) );
       greyLevelNonuniformityOutputObject->Set( greyLevelNonuniformity );
 
       MeasurementObjectType* SizeZoneNonuniformityOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 3 ) );
       SizeZoneNonuniformityOutputObject->Set( SizeZoneNonuniformity );
 
       MeasurementObjectType* lowGreyLevelZoneEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
       lowGreyLevelZoneEmphasisOutputObject->Set( lowGreyLevelZoneEmphasis );
 
       MeasurementObjectType* highGreyLevelZoneEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 5 ) );
       highGreyLevelZoneEmphasisOutputObject->Set( highGreyLevelZoneEmphasis );
 
       MeasurementObjectType* SmallZoneLowGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 6 ) );
       SmallZoneLowGreyLevelEmphasisOutputObject->Set( SmallZoneLowGreyLevelEmphasis );
 
       MeasurementObjectType* SmallZoneHighGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 7 ) );
       SmallZoneHighGreyLevelEmphasisOutputObject->Set(
         SmallZoneHighGreyLevelEmphasis );
 
       MeasurementObjectType* LargeZoneLowGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 8 ) );
       LargeZoneLowGreyLevelEmphasisOutputObject->Set( LargeZoneLowGreyLevelEmphasis );
 
       MeasurementObjectType* LargeZoneHighGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 9 ) );
       LargeZoneHighGreyLevelEmphasisOutputObject->Set( LargeZoneHighGreyLevelEmphasis );
 
       MeasurementObjectType* ZonePercentagesOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 10 ) );
       ZonePercentagesOutputObject->Set( ZonePercentage );
 
       MeasurementObjectType* numberOfZonesOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 11 ) );
       numberOfZonesOutputObject->Set( numberOfZones );
 
       MeasurementObjectType* greyLevelVarianceOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 12 ) );
       greyLevelVarianceOutputObject->Set( greyLevelVariance );
 
       MeasurementObjectType* SizeZoneVarianceOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 13 ) );
       SizeZoneVarianceOutputObject->Set( SizeZoneVariance );
 
       MeasurementObjectType* ZoneEntropyOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 14 ) );
       ZoneEntropyOutputObject->Set( ZoneEntropy );
 
       MeasurementObjectType* greyLevelNonuniformityNormalizedOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 15 ) );
       greyLevelNonuniformityNormalizedOutputObject->Set( greyLevelNonuniformityNormalized );
 
       MeasurementObjectType* SizeZoneNonuniformityNormalizedOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 16 ) );
       SizeZoneNonuniformityNormalizedOutputObject->Set( SizeZoneNonuniformityNormalized );
 
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSmallZoneEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 0 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetLargeZoneEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformityOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 2 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSizeZoneNonuniformityOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 3 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformityNormalizedOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 15 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSizeZoneNonuniformityNormalizedOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 16 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetLowGreyLevelZoneEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetHighGreyLevelZoneEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 5 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSmallZoneLowGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 6 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSmallZoneHighGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 7 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetLargeZoneLowGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 8 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetLargeZoneHighGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 9 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetZonePercentageOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 10 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetNumberOfZonesOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 11 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetGreyLevelVarianceOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 12 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSizeZoneVarianceOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 13 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetZoneEntropyOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 14 ) );
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSmallZoneEmphasis() const
     {
       return this->GetSmallZoneEmphasisOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetLargeZoneEmphasis() const
     {
       return this->GetLargeZoneEmphasisOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformity() const
     {
       return this->GetGreyLevelNonuniformityOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformityNormalized() const
     {
       return this->GetGreyLevelNonuniformityNormalizedOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSizeZoneNonuniformity() const
     {
       return this->GetSizeZoneNonuniformityOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSizeZoneNonuniformityNormalized() const
     {
       return this->GetSizeZoneNonuniformityNormalizedOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetLowGreyLevelZoneEmphasis() const
     {
       return this->GetLowGreyLevelZoneEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetHighGreyLevelZoneEmphasis() const
     {
       return this->GetHighGreyLevelZoneEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSmallZoneLowGreyLevelEmphasis() const
     {
       return this->GetSmallZoneLowGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSmallZoneHighGreyLevelEmphasis() const
     {
       return this->GetSmallZoneHighGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetLargeZoneLowGreyLevelEmphasis() const
     {
       return this->GetLargeZoneLowGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetLargeZoneHighGreyLevelEmphasis() const
     {
       return this->GetLargeZoneHighGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetZonePercentage() const
     {
       return this->GetZonePercentageOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetNumberOfZones() const
     {
       return this->GetNumberOfZonesOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetGreyLevelVariance() const
     {
       return this->GetGreyLevelVarianceOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetSizeZoneVariance() const
     {
       return this->GetSizeZoneVarianceOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetZoneEntropy() const
     {
       return this->GetZoneEntropyOutput()->Get();
     }
 
 
     template<typename THistogram>
     typename EnhancedHistogramToSizeZoneFeaturesFilter< THistogram>::MeasurementType
       EnhancedHistogramToSizeZoneFeaturesFilter<THistogram>
       ::GetFeature( SizeZoneFeatureName feature )
     {
       switch( feature )
       {
       case SmallZoneEmphasis:
         return this->GetSmallZoneEmphasis();
       case LargeZoneEmphasis:
         return this->GetLargeZoneEmphasis();
       case GreyLevelNonuniformity:
         return this->GetGreyLevelNonuniformity();
       case GreyLevelNonuniformityNormalized:
         return this->GetGreyLevelNonuniformityNormalized();
       case SizeZoneNonuniformity:
         return this->GetSizeZoneNonuniformity();
       case SizeZoneNonuniformityNormalized:
         return this->GetSizeZoneNonuniformityNormalized();
       case LowGreyLevelZoneEmphasis:
         return this->GetLowGreyLevelZoneEmphasis();
       case HighGreyLevelZoneEmphasis:
         return this->GetHighGreyLevelZoneEmphasis();
       case SmallZoneLowGreyLevelEmphasis:
         return this->GetSmallZoneLowGreyLevelEmphasis();
       case SmallZoneHighGreyLevelEmphasis:
         return this->GetSmallZoneHighGreyLevelEmphasis();
       case LargeZoneLowGreyLevelEmphasis:
         return this->GetLargeZoneLowGreyLevelEmphasis();
       case LargeZoneHighGreyLevelEmphasis:
         return this->GetLargeZoneHighGreyLevelEmphasis();
       case ZonePercentage:
         return this->GetZonePercentage();
       case GreyLevelVariance:
         return this->GetGreyLevelVariance();
       case SizeZoneVariance:
         return this->GetSizeZoneVariance();
       case ZoneEntropy:
         return this->GetZoneEntropy();
       default:
         return 0;
       }
     }
 
     template< typename THistogram>
     void
       EnhancedHistogramToSizeZoneFeaturesFilter< THistogram>::
       PrintSelf(std::ostream& os, Indent indent) const
     {
       Superclass::PrintSelf( os,indent );
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToTextureFeaturesFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToTextureFeaturesFilter.h
index 0bdae76994..f7992dd190 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToTextureFeaturesFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToTextureFeaturesFilter.h
@@ -1,278 +1,273 @@
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedHistogramToTextureFeaturesFilter_h
 #define __itkEnhancedHistogramToTextureFeaturesFilter_h
 
 #include "itkHistogram.h"
 #include "itkMacro.h"
 #include "itkProcessObject.h"
 #include "itkSimpleDataObjectDecorator.h"
 
 /** Get built-in type.  Creates member Get"name"() (e.g., GetVisibility()); */
 #define itkMacroGLCMFeatureGetter(name)                                       \
   const MeasurementObjectType * Get##name##Output() const;                      \
   \
   MeasurementType Get##name() const;
 
 namespace itk
 {
   namespace Statistics
   {
     /** \class EnhancedHistogramToTextureFeaturesFilter
     *  \brief This class computes texture feature coefficients from a grey level
     * co-occurrence matrix.
     *
     * This class computes features that summarize image texture, given a grey level
     * co-occurrence matrix (generated by a ScalarImageToCooccurrenceMatrixFilter
     * or related class).
     *
     * The features calculated are as follows (where \f$ g(i, j) \f$ is the element in
     * cell i, j of a a normalized GLCM):
     *
     * "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)
     *
     * A good texture feature set to use is the Conners, Trivedi and Harlow set:
     * features 1, 2, 4, 5, 6, and 7. There is some correlation between the various
     * features, so using all of them at the same time is not necessarialy a good idea.
     *
     * NOTA BENE: The input histogram will be forcably normalized!
     * This algorithm takes three passes through the input
     * histogram if the histogram was already normalized, and four if not.
     *
-    * Web references:
-    *
-    * http://www.cssip.uq.edu.au/meastex/www/algs/algs/algs.html
-    * http://www.ucalgary.ca/~mhallbey/texture/texture_tutorial.html
-    *
     * 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.
     *
     * Haralick, R.M. 1979. Statistical and Structural Approaches to Texture.
     * Proceedings of the IEEE, 67:786-804.
     *
     * R.W. Conners and C.A. Harlow. A Theoretical Comaprison of Texture Algorithms.
     * IEEE Transactions on Pattern Analysis and Machine Intelligence,  2:204-222, 1980.
     *
     * R.W. Conners, M.M. Trivedi, and C.A. Harlow. Segmentation of a High-Resolution
     * Urban Scene using Texture  Operators. Computer Vision, Graphics and Image
     * Processing, 25:273-310,  1984.
     *
     * \sa ScalarImageToCooccurrenceMatrixFilter
     * \sa ScalarImageToTextureFeaturesFilter
     *
     * Author: Zachary Pincus
     * \ingroup ITKStatistics
     */
 
     template< typename THistogram >
     class EnhancedHistogramToTextureFeaturesFilter:public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedHistogramToTextureFeaturesFilter Self;
       typedef ProcessObject                    Superclass;
       typedef SmartPointer< Self >             Pointer;
       typedef SmartPointer< const Self >       ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro(EnhancedHistogramToTextureFeaturesFilter, ProcessObject);
 
       /** standard New() method support */
       itkNewMacro(Self);
 
       typedef THistogram                                    HistogramType;
       typedef typename HistogramType::Pointer               HistogramPointer;
       typedef typename HistogramType::ConstPointer          HistogramConstPointer;
       typedef typename HistogramType::MeasurementType       MeasurementType;
       typedef typename HistogramType::MeasurementVectorType MeasurementVectorType;
       typedef typename HistogramType::IndexType             IndexType;
       typedef typename HistogramType::AbsoluteFrequencyType AbsoluteFrequencyType;
       typedef typename HistogramType::RelativeFrequencyType RelativeFrequencyType;
 
       typedef typename HistogramType::TotalAbsoluteFrequencyType
         TotalAbsoluteFrequencyType;
 
       typedef typename HistogramType::TotalRelativeFrequencyType
         TotalRelativeFrequencyType;
 
       /** Container to hold relative frequencies of the histogram */
       typedef std::vector< RelativeFrequencyType > RelativeFrequencyContainerType;
 
       /** Method to Set/Get the input Histogram */
       using Superclass::SetInput;
       void SetInput(const HistogramType *histogram);
 
       const HistogramType * GetInput() const;
 
       /** Smart Pointer type to a DataObject. */
       typedef DataObject::Pointer DataObjectPointer;
 
       /** Type of DataObjects used for scalar outputs */
       typedef SimpleDataObjectDecorator< MeasurementType > MeasurementObjectType;
 
       /** Return energy texture value. */
       MeasurementType GetEnergy() const;
 
       const MeasurementObjectType * GetEnergyOutput() const;
 
       /** Return entropy texture value. */
       MeasurementType GetEntropy() const;
 
       const MeasurementObjectType * GetEntropyOutput() const;
 
       /** return correlation texture value. */
       MeasurementType GetCorrelation() const;
 
       const MeasurementObjectType * GetCorrelationOutput() const;
 
       /** Return inverse difference moment texture value. */
       MeasurementType GetInverseDifferenceMoment() const;
 
       const MeasurementObjectType * GetInverseDifferenceMomentOutput() const;
 
       /** Return inertia texture value. */
       MeasurementType GetInertia() const;
 
       const MeasurementObjectType * GetInertiaOutput() const;
 
       /** Return cluster shade texture value. */
       MeasurementType GetClusterShade() const;
 
       const MeasurementObjectType * GetClusterShadeOutput() const;
 
       /** Return cluster prominence texture value. */
       MeasurementType GetClusterProminence() const;
 
       const MeasurementObjectType * GetClusterProminenceOutput() const;
 
       /** Return Haralick correlation texture value. */
       MeasurementType GetHaralickCorrelation() const;
 
       const MeasurementObjectType * GetHaralickCorrelationOutput() const;
 
       itkMacroGLCMFeatureGetter(Autocorrelation);
       itkMacroGLCMFeatureGetter(Contrast);
       itkMacroGLCMFeatureGetter(Dissimilarity);
       itkMacroGLCMFeatureGetter(MaximumProbability);
       itkMacroGLCMFeatureGetter(InverseVariance);
       itkMacroGLCMFeatureGetter(Homogeneity1);
       itkMacroGLCMFeatureGetter(ClusterTendency);
       itkMacroGLCMFeatureGetter(Variance);
       itkMacroGLCMFeatureGetter(SumAverage);
       itkMacroGLCMFeatureGetter(SumEntropy);
       itkMacroGLCMFeatureGetter(SumVariance);
       itkMacroGLCMFeatureGetter(DifferenceAverage);
       itkMacroGLCMFeatureGetter(DifferenceEntropy);
       itkMacroGLCMFeatureGetter(DifferenceVariance);
       itkMacroGLCMFeatureGetter(InverseDifferenceMomentNormalized);
       itkMacroGLCMFeatureGetter(InverseDifferenceNormalized);
       itkMacroGLCMFeatureGetter(InverseDifference);
       itkMacroGLCMFeatureGetter(JointAverage);
       itkMacroGLCMFeatureGetter(FirstMeasureOfInformationCorrelation);
       itkMacroGLCMFeatureGetter(SecondMeasureOfInformationCorrelation);
 
       /** Texture feature types */
       typedef enum {
         Energy,
         Entropy,
         Correlation,
         InverseDifferenceMoment,
         Inertia,
         ClusterShade,
         ClusterProminence,
         HaralickCorrelation,
         Autocorrelation,
         Contrast,
         Dissimilarity,
         MaximumProbability,
         InverseVariance,
         Homogeneity1,
         ClusterTendency,
         Variance,
         SumAverage,
         SumEntropy,
         SumVariance,
         DifferenceAverage,
         DifferenceEntropy,
         DifferenceVariance,
         InverseDifferenceMomentNormalized,
         InverseDifferenceNormalized,
         InverseDifference,
         JointAverage,
         FirstMeasureOfInformationCorrelation,
         SecondMeasureOfInformationCorrelation,
         InvalidFeatureName
       }  TextureFeatureName;
 
       /** convenience method to access the texture values */
       MeasurementType GetFeature(TextureFeatureName name);
 
     protected:
       EnhancedHistogramToTextureFeaturesFilter();
       ~EnhancedHistogramToTextureFeaturesFilter() override {}
       void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
 
       /** Make a DataObject to be used for output output. */
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       DataObjectPointer MakeOutput(DataObjectPointerArraySizeType) ITK_OVERRIDE;
 
       void GenerateData() ITK_OVERRIDE;
 
     private:
       EnhancedHistogramToTextureFeaturesFilter(const Self &); //purposely not implemented
       void operator=(const Self &);                   //purposely not implemented
 
       void ComputeMeansAndVariances(double & pixelMean, double & marginalMean,
         double & marginalDevSquared, double & pixelVariance);
 
       RelativeFrequencyContainerType m_RelativeFrequencyContainer;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedHistogramToTextureFeaturesFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToTextureFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToTextureFeaturesFilter.hxx
index ff154fcf33..8a6356d7f5 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToTextureFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToTextureFeaturesFilter.hxx
@@ -1,760 +1,760 @@
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedHistogramToTextureFeaturesFilter_hxx
 #define __itkEnhancedHistogramToTextureFeaturesFilter_hxx
 
 #include "itkEnhancedHistogramToTextureFeaturesFilter.h"
 
 #include "itkNumericTraits.h"
 #include "vnl/vnl_math.h"
 #include "itkMath.h"
 
 #define itkMacroGLCMFeature(name, id)                                       \
   template< typename THistogram >                                                                   \
   const                                                                                             \
   typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementObjectType *          \
   EnhancedHistogramToTextureFeaturesFilter< THistogram >                                            \
   ::Get##name##Output() const                                                                         \
 {                                                                                                   \
   return static_cast< const MeasurementObjectType * >( this->ProcessObject::GetOutput(id) );        \
   }                                                                                                   \
   \
   template< typename THistogram >                                                                   \
   typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType                  \
   EnhancedHistogramToTextureFeaturesFilter< THistogram >                                            \
   ::Get##name() const                                                                               \
 {                                                                                                   \
   return this->Get##name##Output()->Get();                                                            \
   }
 
 namespace itk
 {
 namespace Statistics
 {
 //constructor
 template< typename THistogram >
 EnhancedHistogramToTextureFeaturesFilter< THistogram >::EnhancedHistogramToTextureFeaturesFilter(void)
 {
   this->ProcessObject::SetNumberOfRequiredInputs(1);
 
   // allocate the data objects for the outputs which are
   // just decorators real types
   for ( int i = 0; i < 28; ++i )
   {
     this->ProcessObject::SetNthOutput( i, this->MakeOutput(i) );
   }
 }
 
 template< typename THistogram >
 void
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::SetInput(const HistogramType *histogram)
 {
   this->ProcessObject::SetNthInput( 0, const_cast< HistogramType * >( histogram ) );
 }
 
 template< typename THistogram >
 const typename
 EnhancedHistogramToTextureFeaturesFilter< THistogram >::HistogramType *
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetInput() const
 {
   return itkDynamicCastInDebugMode< const HistogramType * >( this->GetPrimaryInput() );
 }
 
 template< typename THistogram >
 typename
 EnhancedHistogramToTextureFeaturesFilter< THistogram >::DataObjectPointer
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed(idx) )
 {
   return MeasurementObjectType::New().GetPointer();
 }
 
 template< typename THistogram >
 void
 EnhancedHistogramToTextureFeaturesFilter< THistogram >::GenerateData(void)
 {
   typedef typename HistogramType::ConstIterator HistogramIterator;
 
   const HistogramType *inputHistogram = this->GetInput();
 
   //Normalize the absolute frequencies and populate the relative frequency
   //container
   TotalRelativeFrequencyType totalFrequency =
       static_cast< TotalRelativeFrequencyType >( inputHistogram->GetTotalFrequency() );
 
   m_RelativeFrequencyContainer.clear();
 
   typename HistogramType::SizeValueType binsPerAxis = inputHistogram->GetSize(0);
   std::vector<double> sumP;
   std::vector<double> diffP;
 
   sumP.resize(2*binsPerAxis,0.0);
   diffP.resize(binsPerAxis,0.0);
 
   double numberOfPixels = 0;
 
   for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
   {
     AbsoluteFrequencyType frequency = hit.GetFrequency();
     RelativeFrequencyType relativeFrequency =  (totalFrequency > 0) ? frequency / totalFrequency : 0;
     m_RelativeFrequencyContainer.push_back(relativeFrequency);
 
     IndexType index = inputHistogram->GetIndex( hit.GetInstanceIdentifier() );
     sumP[index[0] + index[1]] += relativeFrequency;
     diffP[std::abs(index[0] - index[1])] += relativeFrequency;
 
     //if (index[1] == 0)
     numberOfPixels += frequency;
   }
 
   // Now get the various means and variances. This is takes two passes
   // through the histogram.
   double pixelMean;
   double marginalMean;
   double marginalDevSquared;
   double pixelVariance;
 
   this->ComputeMeansAndVariances(pixelMean, marginalMean, marginalDevSquared,
                                  pixelVariance);
 
   // Finally compute the texture features. Another one pass.
   MeasurementType energy      = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType entropy     = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType correlation = NumericTraits< MeasurementType >::ZeroValue();
 
   MeasurementType inverseDifferenceMoment      =
       NumericTraits< MeasurementType >::ZeroValue();
 
   MeasurementType inertia             = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType clusterShade        = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType clusterProminence   = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType haralickCorrelation = NumericTraits< MeasurementType >::ZeroValue();
 
   MeasurementType autocorrelation = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType contrast = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType dissimilarity = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType maximumProbability = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType inverseVariance = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType homogeneity1 = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType clusterTendency = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType variance = NumericTraits< MeasurementType >::ZeroValue();
 
   MeasurementType sumAverage = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType sumEntropy = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType sumVariance = NumericTraits< MeasurementType >::ZeroValue();
 
   MeasurementType diffAverage = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType diffEntropy = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType diffVariance = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType inverseDifferenceMomentNormalized = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType inverseDifferenceNormalized      = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType inverseDifference      = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType averageProbability = NumericTraits< MeasurementType >::ZeroValue();
 
   MeasurementType firstMeasureOfInformationCorrelation = NumericTraits< MeasurementType >::ZeroValue();
   MeasurementType secondMeasureOfInformationCorrelation = NumericTraits< MeasurementType >::ZeroValue();
 
   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( Math::FloatAlmostEqual( pixelVarianceSquared, 0.0, 4, 2*NumericTraits<double>::epsilon() ) )
   {
     pixelVarianceSquared = 1.;
   }
   const double log2 = std::log(2.0);
 
   typename RelativeFrequencyContainerType::const_iterator rFreqIterator =
       m_RelativeFrequencyContainer.begin();
 
   IndexType globalIndex(2);
 
   for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
   {
     RelativeFrequencyType frequency = *rFreqIterator;
     ++rFreqIterator;
     if ( frequency == 0 )
     {
       continue; // no use doing these calculations if we're just multiplying by
       // zero.
     }
 
     IndexType index = inputHistogram->GetIndex( hit.GetInstanceIdentifier() );
     globalIndex = index;
     energy += frequency * frequency;
     entropy -= ( frequency > 0.0001 ) ? frequency *std::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 += std::pow( ( index[0] - pixelMean ) + ( index[1] - pixelMean ), 3 )
         * frequency;
     clusterProminence += std::pow( ( index[0] - pixelMean ) + ( index[1] - pixelMean ), 4 )
         * frequency;
     haralickCorrelation += index[0] * index[1] * frequency;
 
     // New Features added for Aerts compatibility
     autocorrelation +=index[0] * index[1] * frequency;
     contrast += (index[0] - index[1]) * (index[0] - index[1]) * frequency;
     dissimilarity += std::abs(index[0] - index[1]) * frequency;
     maximumProbability +=std::max(maximumProbability, frequency);
     averageProbability += frequency * index[0];
     if (index[0] != index[1])
       inverseVariance += frequency / ((index[0] - index[1])*(index[0] - index[1]));
     homogeneity1 +=frequency / ( 1.0 + std::abs( index[0] - index[1] ));
     clusterTendency += std::pow( ( index[0] - pixelMean ) + ( index[1] - pixelMean ), 2 ) * frequency;
     variance += std::pow( ( index[0] - pixelMean ), 2) * frequency;
 
     if (numberOfPixels > 0)
     {
       inverseDifferenceMomentNormalized += frequency / ( 1.0 + ( index[0] - index[1] ) * ( index[0] - index[1] ) / numberOfPixels / numberOfPixels);
       inverseDifferenceNormalized += frequency / ( 1.0 + std::abs( index[0] - index[1] ) / numberOfPixels );
     }
     else
     {
       inverseDifferenceMomentNormalized = 0;
       inverseDifferenceNormalized = 0;
     }
     inverseDifference += frequency / ( 1.0 + std::abs( index[0] - index[1] ) );
   }
 
   for (int i = 0; i < (int)sumP.size();++i)
   {
     double frequency = sumP[i];
     sumAverage += i * frequency;
     sumEntropy -= ( frequency > 0.0001 ) ? frequency *std::log(frequency) / log2:0;
   }
   for (int i = 0; i < (int)sumP.size();++i)
   {
     double frequency = sumP[i];
     sumVariance += (i-sumAverage)*(i-sumAverage) * frequency;
   }
 
   for (int i = 0; i < (int)diffP.size();++i)
   {
     double frequency = diffP[i];
     diffAverage += i * frequency;
     diffEntropy -= ( frequency > 0.0001 ) ? frequency *std::log(frequency) / log2:0;
   }
   for (int i = 0; i < (int)diffP.size();++i)
   {
     double frequency = diffP[i];
     sumVariance += (i-diffAverage)*(i-diffAverage) * frequency;
   }
 
   if (marginalDevSquared > 0)
   {
     haralickCorrelation = ( haralickCorrelation - marginalMean * marginalMean )
         / marginalDevSquared;
   } else
   {
     haralickCorrelation =0;
   }
 
   //Calculate the margin probs
   std::vector<double> pi_margins;
   std::vector<double> pj_margins;
 
   //pi.
   for ( std::size_t i = 1; i <= inputHistogram->GetSize(0); i++ )
   {
     double pi_tmp= 0.0;
     for( std::size_t j = 1; j <= inputHistogram->GetSize(1); j++ )
     {
       globalIndex[0] = i;
       globalIndex[1] = j;
       pi_tmp += inputHistogram->GetFrequency(globalIndex);
     }
     pi_margins.push_back(pi_tmp);
   }
 
   //pj.
   for ( std::size_t j = 1; j <= inputHistogram->GetSize(1); j++ )
   {
     double pj_tmp= 0.0;
     for( std::size_t i = 1; i <= inputHistogram->GetSize(0); i++ )
     {
       globalIndex[0] = i;
       globalIndex[1] = j;
       pj_tmp += inputHistogram->GetFrequency(globalIndex);
     }
     pj_margins.push_back(pj_tmp);
   }
 
   //Calculate HX
   double hx = 0.0;
 
   for ( std::size_t i = 0; i < inputHistogram->GetSize(0); i++ )
   {
     double pi_margin = pi_margins[i];
     hx -= ( pi_margin > 0.0001 ) ? pi_margin *std::log(pi_margin) / log2:0;
   }
 
   //Calculate HXY1
   double hxy1 = 0.0;
 
   for ( std::size_t i = 0; i < inputHistogram->GetSize(0); i++ )
   {
     for ( std::size_t j = 0; j < inputHistogram->GetSize(1); j++ )
     {
       globalIndex[0] = i;
       globalIndex[1] = j;
 
       double pi_margin = pi_margins[i];
       double pj_margin = pj_margins[j];
 
       double p_ij = inputHistogram->GetFrequency(globalIndex);
 
       hxy1 -= ( (pi_margin * pj_margin) > 0.0001 ) ? p_ij *std::log(pi_margin * pj_margin) / log2:0;
     }
   }
 
   //Calculate HXY2
   double hxy2 = 0.0;
 
   for ( std::size_t i = 0; i < inputHistogram->GetSize(0); i++ )
   {
     for ( std::size_t j = 0; j < inputHistogram->GetSize(1); j++ )
     {
       globalIndex[0] = i;
       globalIndex[1] = j;
 
       double pi_margin = pi_margins[i];
       double pj_margin = pj_margins[j];
 
       hxy1 -= ( (pi_margin * pj_margin) > 0.0001 ) ? (pi_margin * pj_margin) *std::log(pi_margin * pj_margin) / log2:0;
     }
   }
 
   firstMeasureOfInformationCorrelation = (entropy - hxy1) / hx;
   secondMeasureOfInformationCorrelation = (entropy > hxy2) ? 0 : std::sqrt(1 - std::exp(-2*(hxy2 - entropy)));
 
   MeasurementObjectType *energyOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(0) );
   energyOutputObject->Set(energy);
 
   MeasurementObjectType *entropyOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(1) );
   entropyOutputObject->Set(entropy);
 
   MeasurementObjectType *correlationOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(2) );
   correlationOutputObject->Set(correlation);
 
   MeasurementObjectType *inverseDifferenceMomentOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(3) );
   inverseDifferenceMomentOutputObject->Set(inverseDifferenceMoment);
 
   MeasurementObjectType *inertiaOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(4) );
   inertiaOutputObject->Set(inertia);
 
   MeasurementObjectType *clusterShadeOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(5) );
   clusterShadeOutputObject->Set(clusterShade);
 
   MeasurementObjectType *clusterProminenceOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(6) );
   clusterProminenceOutputObject->Set(clusterProminence);
 
   MeasurementObjectType *haralickCorrelationOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(7) );
   haralickCorrelationOutputObject->Set(haralickCorrelation);
 
   MeasurementObjectType *autocorrelationOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(8) );
   autocorrelationOutputObject->Set(autocorrelation);
 
   MeasurementObjectType *contrastOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(9) );
   contrastOutputObject->Set(contrast);
 
   MeasurementObjectType *dissimilarityOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(10) );
   dissimilarityOutputObject->Set(dissimilarity);
 
   MeasurementObjectType *maximumProbabilityOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(11) );
   maximumProbabilityOutputObject->Set(maximumProbability);
 
   MeasurementObjectType *inverseVarianceOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(12) );
   inverseVarianceOutputObject->Set(inverseVariance);
 
   MeasurementObjectType *homogeneity1OutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(13) );
   homogeneity1OutputObject->Set(homogeneity1);
 
   MeasurementObjectType *clusterTendencyOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(14) );
   clusterTendencyOutputObject->Set(clusterTendency);
 
   MeasurementObjectType *varianceOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(15) );
   varianceOutputObject->Set(variance);
 
   MeasurementObjectType *sumAverageOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(16) );
   sumAverageOutputObject->Set(sumAverage);
 
   MeasurementObjectType *sumEntropyOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(17) );
   sumEntropyOutputObject->Set(sumEntropy);
 
   MeasurementObjectType *sumVarianceOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(18) );
   sumVarianceOutputObject->Set(sumVariance);
 
   MeasurementObjectType *diffAverageOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(19) );
   diffAverageOutputObject->Set(diffAverage);
 
   MeasurementObjectType *diffEntropyOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(20) );
   diffEntropyOutputObject->Set(diffEntropy);
 
   MeasurementObjectType *diffVarianceOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(21) );
   diffVarianceOutputObject->Set(diffVariance);
 
   MeasurementObjectType *inverseDifferenceMomentNormalizedOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(22) );
   inverseDifferenceMomentNormalizedOutputObject->Set(inverseDifferenceMomentNormalized);
 
   MeasurementObjectType *inverseDifferenceNormalizedOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(23) );
   inverseDifferenceNormalizedOutputObject->Set(inverseDifferenceNormalized);
 
   MeasurementObjectType *inverseDifferenceOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(24) );
   inverseDifferenceOutputObject->Set(inverseDifference);
 
   MeasurementObjectType *jointAverageOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(25) );
   jointAverageOutputObject->Set(averageProbability);
 
   MeasurementObjectType *firstMeasureOfInformationCorrelationOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(26) );
   firstMeasureOfInformationCorrelationOutputObject->Set(firstMeasureOfInformationCorrelation);
 
   MeasurementObjectType *secondMeasureOfInformationCorrelationOutputObject =
       static_cast< MeasurementObjectType * >( this->ProcessObject::GetOutput(27) );
   secondMeasureOfInformationCorrelationOutputObject->Set(secondMeasureOfInformationCorrelation);
 }
 
 template< typename THistogram >
 void
 EnhancedHistogramToTextureFeaturesFilter< THistogram >::ComputeMeansAndVariances(double & pixelMean,
                                                                                  double & marginalMean,
                                                                                  double & marginalDevSquared,
                                                                                  double & pixelVariance)
 {
   // This function takes two passes through the histogram and two passes through
   // an array of the same length as a histogram axis. This could probably be
   // cleverly compressed to one pass, but it's not clear that that's necessary.
 
   typedef typename HistogramType::ConstIterator HistogramIterator;
 
   const HistogramType *inputHistogram =  this->GetInput();
 
   // Initialize everything
   typename HistogramType::SizeValueType binsPerAxis = inputHistogram->GetSize(0);
   double *marginalSums = new double[binsPerAxis];
   for ( double *ms_It = marginalSums;
         ms_It < marginalSums + binsPerAxis; ms_It++ )
   {
     *ms_It = 0;
   }
   pixelMean = 0;
 
   typename RelativeFrequencyContainerType::const_iterator rFreqIterator =
       m_RelativeFrequencyContainer.begin();
 
   // Ok, now do the first pass through the histogram to get the marginal sums
   // and compute the pixel mean
   HistogramIterator hit = inputHistogram->Begin();
   while ( hit != inputHistogram->End() )
   {
     RelativeFrequencyType frequency = *rFreqIterator;
     IndexType             index = inputHistogram->GetIndex( hit.GetInstanceIdentifier() );
     pixelMean += index[0] * frequency;
     marginalSums[index[0]] += frequency;
     ++hit;
     ++rFreqIterator;
   }
 
   /*  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 = std::sqrt(S(n) / n) (or divide by n-1 for sample SD instead of
       population SD).
       */
   marginalMean = marginalSums[0];
   marginalDevSquared = 0;
   for ( unsigned int arrayIndex = 1; arrayIndex < binsPerAxis; arrayIndex++ )
   {
     int    k = arrayIndex + 1;
     double M_k_minus_1 = marginalMean;
     double S_k_minus_1 = marginalDevSquared;
     double x_k = marginalSums[arrayIndex];
 
     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 / binsPerAxis;
 
   rFreqIterator = m_RelativeFrequencyContainer.begin();
   // OK, now compute the pixel variances.
   pixelVariance = 0;
   for ( hit = inputHistogram->Begin(); hit != inputHistogram->End(); ++hit )
   {
     RelativeFrequencyType frequency = *rFreqIterator;
     IndexType             index = inputHistogram->GetIndex( hit.GetInstanceIdentifier() );
     pixelVariance += ( index[0] - pixelMean ) * ( index[0] - pixelMean ) * frequency;
     ++rFreqIterator;
   }
 
   delete[] marginalSums;
 }
 
 template< typename THistogram >
 const
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementObjectType *
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetEnergyOutput() const
 {
   return static_cast< const MeasurementObjectType * >( this->ProcessObject::GetOutput(0) );
 }
 
 template< typename THistogram >
 const
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementObjectType *
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetEntropyOutput() const
 {
   return static_cast< const MeasurementObjectType * >( this->ProcessObject::GetOutput(1) );
 }
 
 template< typename THistogram >
 const
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementObjectType *
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetCorrelationOutput() const
 {
   return static_cast< const MeasurementObjectType * >( this->ProcessObject::GetOutput(2) );
 }
 
 template< typename THistogram >
 const
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementObjectType *
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetInverseDifferenceMomentOutput() const
 {
   return static_cast< const MeasurementObjectType * >( this->ProcessObject::GetOutput(3) );
 }
 
 template< typename THistogram >
 const
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementObjectType *
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetInertiaOutput() const
 {
   return static_cast< const MeasurementObjectType * >( this->ProcessObject::GetOutput(4) );
 }
 
 template< typename THistogram >
 const
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementObjectType *
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetClusterShadeOutput() const
 {
   return static_cast< const MeasurementObjectType * >( this->ProcessObject::GetOutput(5) );
 }
 
 template< typename THistogram >
 const
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementObjectType *
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetClusterProminenceOutput() const
 {
   return static_cast< const MeasurementObjectType * >( this->ProcessObject::GetOutput(6) );
 }
 
 template< typename THistogram >
 const
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementObjectType *
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetHaralickCorrelationOutput() const
 {
   return static_cast< const MeasurementObjectType * >( this->ProcessObject::GetOutput(7) );
 }
 
 itkMacroGLCMFeature(Autocorrelation,8)
 itkMacroGLCMFeature(Contrast,9)
 itkMacroGLCMFeature(Dissimilarity,10)
 itkMacroGLCMFeature(MaximumProbability,11)
 itkMacroGLCMFeature(InverseVariance,12)
 itkMacroGLCMFeature(Homogeneity1,13)
 itkMacroGLCMFeature(ClusterTendency,14)
 itkMacroGLCMFeature(Variance,15)
 itkMacroGLCMFeature(SumAverage,16)
 itkMacroGLCMFeature(SumEntropy,17)
 itkMacroGLCMFeature(SumVariance,18)
 itkMacroGLCMFeature(DifferenceAverage,19)
 itkMacroGLCMFeature(DifferenceEntropy,20)
 itkMacroGLCMFeature(DifferenceVariance,21)
 itkMacroGLCMFeature(InverseDifferenceMomentNormalized,22)
 itkMacroGLCMFeature(InverseDifferenceNormalized,23)
 itkMacroGLCMFeature(InverseDifference,24)
 itkMacroGLCMFeature(JointAverage,25)
 itkMacroGLCMFeature(FirstMeasureOfInformationCorrelation,26)
 itkMacroGLCMFeature(SecondMeasureOfInformationCorrelation,27)
 
 template< typename THistogram >
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetEnergy() const
 {
   return this->GetEnergyOutput()->Get();
 }
 
 template< typename THistogram >
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetEntropy() const
 {
   return this->GetEntropyOutput()->Get();
 }
 
 template< typename THistogram >
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetCorrelation() const
 {
   return this->GetCorrelationOutput()->Get();
 }
 
 template< typename THistogram >
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetInverseDifferenceMoment() const
 {
   return this->GetInverseDifferenceMomentOutput()->Get();
 }
 
 template< typename THistogram >
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetInertia() const
 {
   return this->GetInertiaOutput()->Get();
 }
 
 template< typename THistogram >
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetClusterShade() const
 {
   return this->GetClusterShadeOutput()->Get();
 }
 
 template< typename THistogram >
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetClusterProminence() const
 {
   return this->GetClusterProminenceOutput()->Get();
 }
 
 template< typename THistogram >
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetHaralickCorrelation() const
 {
   return this->GetHaralickCorrelationOutput()->Get();
 }
 
 #define itkMacroGLCMFeatureSwitch(name)     \
   case name :                             \
   return this->Get##name()
 template< typename THistogram >
 typename EnhancedHistogramToTextureFeaturesFilter< THistogram >::MeasurementType
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::GetFeature(TextureFeatureName feature)
 {
   switch ( feature )
   {
   itkMacroGLCMFeatureSwitch(Energy);
   itkMacroGLCMFeatureSwitch(Entropy);
   itkMacroGLCMFeatureSwitch(Correlation);
   itkMacroGLCMFeatureSwitch(InverseDifferenceMoment);
   itkMacroGLCMFeatureSwitch(Inertia);
   itkMacroGLCMFeatureSwitch(ClusterShade);
   itkMacroGLCMFeatureSwitch(ClusterProminence);
   itkMacroGLCMFeatureSwitch(HaralickCorrelation);
   itkMacroGLCMFeatureSwitch(Autocorrelation);
   itkMacroGLCMFeatureSwitch(Contrast);
   itkMacroGLCMFeatureSwitch(Dissimilarity);
   itkMacroGLCMFeatureSwitch(MaximumProbability);
   itkMacroGLCMFeatureSwitch(InverseVariance);
   itkMacroGLCMFeatureSwitch(Homogeneity1);
   itkMacroGLCMFeatureSwitch(ClusterTendency);
   itkMacroGLCMFeatureSwitch(Variance);
   itkMacroGLCMFeatureSwitch(SumAverage);
   itkMacroGLCMFeatureSwitch(SumEntropy);
   itkMacroGLCMFeatureSwitch(SumVariance);
   itkMacroGLCMFeatureSwitch(DifferenceAverage);
   itkMacroGLCMFeatureSwitch(DifferenceEntropy);
   itkMacroGLCMFeatureSwitch(DifferenceVariance);
   itkMacroGLCMFeatureSwitch(InverseDifferenceMomentNormalized);
   itkMacroGLCMFeatureSwitch(InverseDifferenceNormalized);
   itkMacroGLCMFeatureSwitch(InverseDifference);
   itkMacroGLCMFeatureSwitch(JointAverage);
   itkMacroGLCMFeatureSwitch(FirstMeasureOfInformationCorrelation);
   itkMacroGLCMFeatureSwitch(SecondMeasureOfInformationCorrelation);
   default:
     return 0;
   }
 }
 
 #undef itkMacroGLCMFeatureSwitch
 
 template< typename THistogram >
 void
 EnhancedHistogramToTextureFeaturesFilter< THistogram >
 ::PrintSelf(std::ostream & os, Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
 }
 } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h
index fcb9705d48..3e3dd337ca 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h
@@ -1,241 +1,241 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter_h
 #define __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter_h
 
 #include "itkDataObjectDecorator.h"
 
 #include "itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h"
 #include "itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.h"
 
 namespace itk
 {
   namespace Statistics
   {
     /** \class EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter
     *  \brief This class computes run length descriptions from an image.
     *
     * By default, run length features are computed for each spatial
     * direction and then averaged afterward, so it is possible to access the
     * standard deviations of the texture features. These values give a clue as
     * to texture anisotropy. However, doing this is much more work, because it
     * involved computing one for each offset given. To compute a single
     * matrix using the first offset, call FastCalculationsOn(). If this is called,
     * then the texture standard deviations will not be computed (and will be set
     * to zero), but texture computation will be much faster.
     *
     * This class is templated over the input image type.
     *
     * Template Parameters:
     * The image type, and the type of histogram frequency container. If you are
     * using a large number of bins per axis, a sparse frequency container may be
     * advisable.  The default is to use a dense frequency container.
     *
     * Inputs and parameters:
     * -# An image
     * -# A mask defining the region over which texture features will be
     *    calculated. (Optional)
     * -# The pixel value that defines the "inside" of the mask. (Optional, defaults
     *    to 1 if a mask is set.)
     * -# The set of features to be calculated. These features are defined
     *    in the HistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter class.
     * -# The number of intensity bins. (Optional, defaults to 256.)
     * -# The set of directions (offsets) to average across. (Optional, defaults to
     *    {(-1, 0), (-1, -1), (0, -1), (1, -1)} for 2D images and scales analogously
     *    for ND images.)
     * -# The pixel intensity range over which the features will be calculated.
     *    (Optional, defaults to the full dynamic range of the pixel type.)
     * -# The distance range over which the features will be calculated.
     *    (Optional, defaults to the full dynamic range of double type.)
     *
     * In general, the default parameter values should be sufficient.
     *
     * Outputs:
     * (1) The average value of each feature.
     * (2) The standard deviation in the values of each feature.
     *
     * Print references:
     * M. M. Galloway. Texture analysis using gray level run lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * run lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level run-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
-    * IJ article: http://hdl.handle.net/1926/1374
+    * IJ article: https://hdl.handle.net/1926/1374
     *
     * \sa EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter
     * \sa ScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter
     * \sa HistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template< typename TImageType,
       typename THistogramFrequencyContainer = DenseFrequencyContainer2 >
     class EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter:public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter  Self;
       typedef ProcessObject                         Superclass;
       typedef SmartPointer< Self >                  Pointer;
       typedef SmartPointer< const Self >            ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro(EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter, ProcessObject);
 
       /** standard New() method support */
       itkNewMacro(Self);
 
       typedef THistogramFrequencyContainer FrequencyContainerType;
       typedef TImageType                   ImageType;
       typedef typename ImageType::Pointer  ImagePointer;
 
       typedef typename ImageType::PixelType                PixelType;
       typedef typename ImageType::OffsetType               OffsetType;
       typedef VectorContainer< unsigned char, OffsetType > OffsetVector;
       typedef typename OffsetVector::Pointer               OffsetVectorPointer;
       typedef typename OffsetVector::ConstPointer          OffsetVectorConstPointer;
 
       typedef EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<
         ImageType, FrequencyContainerType >               NeighbourhoodGreyLevelDifferenceMatrixFilterType;
 
       typedef typename NeighbourhoodGreyLevelDifferenceMatrixFilterType::HistogramType
         HistogramType;
 
       typedef EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< HistogramType >
         NeighbourhoodGreyLevelDifferenceFeaturesFilterType;
 
       typedef short                                    NeighbourhoodGreyLevelDifferenceFeatureName;
       typedef VectorContainer<unsigned char,
         NeighbourhoodGreyLevelDifferenceFeatureName>                          FeatureNameVector;
       typedef typename FeatureNameVector::Pointer      FeatureNameVectorPointer;
       typedef typename FeatureNameVector::ConstPointer FeatureNameVectorConstPointer;
       typedef VectorContainer< unsigned char, double > FeatureValueVector;
       typedef typename FeatureValueVector::Pointer     FeatureValueVectorPointer;
 
       /** Smart Pointer type to a DataObject. */
       typedef DataObject::Pointer DataObjectPointer;
 
       /** Type of DataObjects used for scalar outputs */
       typedef DataObjectDecorator< FeatureValueVector >
         FeatureValueVectorDataObjectType;
 
       const FeatureValueVectorDataObjectType * GetFeatureMeansOutput() const;
 
       const FeatureValueVectorDataObjectType * GetFeatureStandardDeviationsOutput()
         const;
 
       /** Connects the input image for which the features are going to be computed
       */
       using Superclass::SetInput;
       void SetInput(const ImageType *);
 
       const ImageType * GetInput() const;
 
       /** Return the feature means and deviations.  */
       itkGetConstReferenceObjectMacro(FeatureMeans, FeatureValueVector);
       itkGetConstReferenceObjectMacro(FeatureStandardDeviations, FeatureValueVector);
 
       /** Set the desired feature set. Optional, for default value see above. */
       itkSetConstObjectMacro(RequestedFeatures, FeatureNameVector);
       itkGetConstObjectMacro(RequestedFeatures, FeatureNameVector);
 
       /** Set the  offsets over which the co-occurrence pairs will be computed.
       Optional; for default value see above. */
       itkSetConstObjectMacro(Offsets, OffsetVector);
       itkGetConstObjectMacro(Offsets, OffsetVector);
 
       /** Set number of histogram bins along each axis.
       Optional; for default value see above. */
       void SetNumberOfBinsPerAxis(unsigned int);
 
       /** Set the min and max (inclusive) pixel value that will be used for
       feature calculations. Optional; for default value see above. */
       void SetPixelValueMinMax(PixelType min, PixelType max);
 
       /** Set the min and max (inclusive) pixel value that will be used for
       feature calculations. Optional; for default value see above. */
       void SetDistanceValueMinMax( double min, double max );
 
       /** Connects the mask image for which the histogram is going to be computed.
       Optional; for default value see above. */
       void SetMaskImage(const ImageType *);
 
       const ImageType * GetMaskImage() const;
 
       /** Set the pixel value of the mask that should be considered "inside" the
       object. Optional; for default value see above. */
       void SetInsidePixelValue(PixelType InsidePixelValue);
 
       itkGetConstMacro(FastCalculations, bool);
       itkSetMacro(FastCalculations, bool);
       itkBooleanMacro(FastCalculations);
 
     protected:
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter();
       ~EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter() override {}
       void PrintSelf( std::ostream & os, Indent indent ) const ITK_OVERRIDE;
 
       void FastCompute();
 
       void FullCompute();
 
       /** This method causes the filter to generate its output. */
       void GenerateData() ITK_OVERRIDE;
 
       /** Make a DataObject to be used for output output. */
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       DataObjectPointer MakeOutput(DataObjectPointerArraySizeType) ITK_OVERRIDE;
 
     private:
       typename NeighbourhoodGreyLevelDifferenceMatrixFilterType::Pointer m_NeighbourhoodGreyLevelDifferenceMatrixGenerator;
 
       FeatureValueVectorPointer     m_FeatureMeans;
       FeatureValueVectorPointer     m_FeatureStandardDeviations;
       FeatureNameVectorConstPointer m_RequestedFeatures;
       OffsetVectorConstPointer      m_Offsets;
       bool                          m_FastCalculations;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx
index 9d1a67c702..cfa5a15036 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx
@@ -1,406 +1,406 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter_hxx
 #define __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter_hxx
 
 #include "itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h"
 #include "itkNeighborhood.h"
 #include <itkImageRegionConstIterator.h>
 #include "vnl/vnl_math.h"
 
 namespace itk
 {
   namespace Statistics
   {
     template<typename TImage, typename THistogramFrequencyContainer>
     EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter()
     {
       this->SetNumberOfRequiredInputs( 1 );
       this->SetNumberOfRequiredOutputs( 1 );
 
       for( int i = 0; i < 2; ++i )
       {
         this->ProcessObject::SetNthOutput( i, this->MakeOutput( i ) );
       }
 
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator = NeighbourhoodGreyLevelDifferenceMatrixFilterType::New();
       this->m_FeatureMeans = FeatureValueVector::New();
       this->m_FeatureStandardDeviations = FeatureValueVector::New();
 
       // Set the requested features to the default value:
       // {Energy, Entropy, InverseDifferenceMoment, Inertia, ClusterShade,
       // ClusterProminence}
       FeatureNameVectorPointer requestedFeatures = FeatureNameVector::New();
       // can't directly set this->m_RequestedFeatures since it is const!
 
       requestedFeatures->push_back( NeighbourhoodGreyLevelDifferenceFeaturesFilterType::Coarseness );
       requestedFeatures->push_back( NeighbourhoodGreyLevelDifferenceFeaturesFilterType::Contrast );
       requestedFeatures->push_back( NeighbourhoodGreyLevelDifferenceFeaturesFilterType::Busyness );
       requestedFeatures->push_back( NeighbourhoodGreyLevelDifferenceFeaturesFilterType::Complexity );
       requestedFeatures->push_back( NeighbourhoodGreyLevelDifferenceFeaturesFilterType::Strength );
       requestedFeatures->push_back( 20 );
 
       this->SetRequestedFeatures( requestedFeatures );
 
       // 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 Neighborhood<typename ImageType::PixelType,
         ImageType::ImageDimension> 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 );
       this->m_FastCalculations = false;
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     typename
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::DataObjectPointer
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed(idx) )
     {
       return FeatureValueVectorDataObjectType::New().GetPointer();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GenerateData(void)
     {
       if ( this->m_FastCalculations )
       {
         this->FastCompute();
       }
       else
       {
         this->FullCompute();
       }
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FullCompute()
     {
       int numFeatures = this->m_RequestedFeatures->size();
       double *features = new double [numFeatures];
 
       unsigned long numberOfVoxels = 0;
       ImageRegionConstIterator<TImage> voxelCountIter(this->GetMaskImage(),this->GetMaskImage()->GetLargestPossibleRegion());
       while ( ! voxelCountIter.IsAtEnd() )
       {
         if (voxelCountIter.Get() > 0)
           ++numberOfVoxels;
         ++voxelCountIter;
       }
 
       // For each offset, calculate each feature
       typename OffsetVector::ConstIterator offsetIt;
       int offsetNum, featureNum;
       typedef typename NeighbourhoodGreyLevelDifferenceFeaturesFilterType::NeighbourhoodGreyLevelDifferenceFeatureName
         InternalNeighbourhoodGreyLevelDifferenceFeatureName;
 
       std::vector <OffsetType> tVector;
       for( offsetIt = this->m_Offsets->Begin(), offsetNum = 0;
         offsetIt != this->m_Offsets->End(); offsetIt++, offsetNum++ )
       {
         MITK_INFO << "Adding offset " << offsetIt.Value();
         tVector.push_back(offsetIt.Value());
       }
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->AddOffsets( tVector);
         this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->Update();
         typename NeighbourhoodGreyLevelDifferenceFeaturesFilterType::Pointer NeighbourhoodGreyLevelDifferenceMatrixCalculator =
           NeighbourhoodGreyLevelDifferenceFeaturesFilterType::New();
         NeighbourhoodGreyLevelDifferenceMatrixCalculator->SetInput(
           this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->GetOutput() );
         NeighbourhoodGreyLevelDifferenceMatrixCalculator->SetSiMatrix(
           this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->GetSiMatrix() );
         NeighbourhoodGreyLevelDifferenceMatrixCalculator->SetNumberOfVoxels(numberOfVoxels);
         NeighbourhoodGreyLevelDifferenceMatrixCalculator->Update();
 
         typename FeatureNameVector::ConstIterator fnameIt;
         for( fnameIt = this->m_RequestedFeatures->Begin(), featureNum = 0;
           fnameIt != this->m_RequestedFeatures->End(); fnameIt++, featureNum++ )
         {
           InternalNeighbourhoodGreyLevelDifferenceFeatureName tn = ( InternalNeighbourhoodGreyLevelDifferenceFeatureName )fnameIt.Value();
           double xx = NeighbourhoodGreyLevelDifferenceMatrixCalculator->GetFeature(tn);
 
           features[featureNum] = xx;
         }
 
 
       // Now get the mean and deviaton of each feature across the offsets.
       this->m_FeatureMeans->clear();
       this->m_FeatureStandardDeviations->clear();
       double *tempFeatureMeans = new double[numFeatures];
       double *tempFeatureDevs = new double[numFeatures];
 
       /*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 = std::sqrt(S(n) / n) (or divide by n-1 for sample SD instead of
       population SD).
       */
 
       // Set up the initial conditions (k = 1)
       for( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         this->m_FeatureMeans->push_back( features[featureNum] );
         //tempFeatureMeans[featureNum] = features[0][featureNum];
         //tempFeatureDevs[featureNum] = 0;
       }
       // Zone through the recurrence (k = 2 ... N)
       /*for( offsetNum = 1; offsetNum < numOffsets; offsetNum++ )
       {
         int k = offsetNum + 1;
         for( featureNum = 0; featureNum < numFeatures; featureNum++ )
         {
           double M_k_minus_1 = tempFeatureMeans[featureNum];
           double S_k_minus_1 = tempFeatureDevs[featureNum];
           double x_k = features[offsetNum][featureNum];
 
           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 );
 
           tempFeatureMeans[featureNum] = M_k;
           tempFeatureDevs[featureNum] = S_k;
         }
       }
       for( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         tempFeatureDevs[featureNum] = std::sqrt( tempFeatureDevs[featureNum] /
           numOffsets );
 
         this->m_FeatureMeans->push_back( tempFeatureMeans[featureNum] );
         this->m_FeatureStandardDeviations->push_back( tempFeatureDevs[featureNum] );
       }
       */
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 0 ) );
       meanOutputObject->Set( this->m_FeatureMeans );
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 1 ) );
       standardDeviationOutputObject->Set( this->m_FeatureStandardDeviations );
 
       delete[] tempFeatureMeans;
       delete[] tempFeatureDevs;
       /*for( int i = 0; i < numOffsets; i++ )
       {
         delete[] features[i];
       }*/
       delete[] features;
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FastCompute()
     {
       // Compute the feature for the first offset
       typename OffsetVector::ConstIterator offsetIt = this->m_Offsets->Begin();
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->SetOffset( offsetIt.Value() );
 
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->Update();
       typename NeighbourhoodGreyLevelDifferenceFeaturesFilterType::Pointer NeighbourhoodGreyLevelDifferenceMatrixCalculator =
         NeighbourhoodGreyLevelDifferenceFeaturesFilterType::New();
       NeighbourhoodGreyLevelDifferenceMatrixCalculator->SetInput(
         this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->GetOutput() );
       NeighbourhoodGreyLevelDifferenceMatrixCalculator->SetSiMatrix(
         this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->GetSiMatrix() );
       NeighbourhoodGreyLevelDifferenceMatrixCalculator->Update();
 
       typedef typename NeighbourhoodGreyLevelDifferenceFeaturesFilterType::NeighbourhoodGreyLevelDifferenceFeatureName
         InternalNeighbourhoodGreyLevelDifferenceFeatureName;
       this->m_FeatureMeans->clear();
       this->m_FeatureStandardDeviations->clear();
       typename FeatureNameVector::ConstIterator fnameIt;
       for( fnameIt = this->m_RequestedFeatures->Begin();
         fnameIt != this->m_RequestedFeatures->End(); fnameIt++ )
       {
         this->m_FeatureMeans->push_back( NeighbourhoodGreyLevelDifferenceMatrixCalculator->GetFeature(
           ( InternalNeighbourhoodGreyLevelDifferenceFeatureName )fnameIt.Value() ) );
         this->m_FeatureStandardDeviations->push_back( 0.0 );
       }
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 0 ) );
       meanOutputObject->Set( this->m_FeatureMeans );
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 1 ) );
       standardDeviationOutputObject->Set( this->m_FeatureStandardDeviations );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetInput( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 0,
         const_cast<ImageType *>( image ) );
 
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->SetInput( image );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetNumberOfBinsPerAxis( unsigned int numberOfBins )
     {
       itkDebugMacro( "setting NumberOfBinsPerAxis to " << numberOfBins );
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->SetNumberOfBinsPerAxis( numberOfBins );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetPixelValueMinMax( PixelType min, PixelType max )
     {
       itkDebugMacro( "setting Min to " << min << "and Max to " << max );
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->SetPixelValueMinMax( min, max );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetDistanceValueMinMax( double min, double max )
     {
       itkDebugMacro( "setting Min to " << min << "and Max to " << max );
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->SetDistanceValueMinMax( min, max );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetMaskImage( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 1,
         const_cast< ImageType * >( image ) );
 
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->SetMaskImage( image );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const TImage *
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetInput() const
     {
       if ( this->GetNumberOfInputs() < 1 )
       {
         return ITK_NULLPTR;
       }
       return static_cast<const ImageType *>( this->ProcessObject::GetInput( 0 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const typename
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetFeatureMeansOutput() const
     {
       return itkDynamicCastInDebugMode<const FeatureValueVectorDataObjectType *>
         (this->ProcessObject::GetOutput( 0 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const typename
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetFeatureStandardDeviationsOutput() const
     {
       return itkDynamicCastInDebugMode< const FeatureValueVectorDataObjectType * >
         ( this->ProcessObject::GetOutput( 1 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const TImage *
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetMaskImage() const
     {
       if ( this->GetNumberOfInputs() < 2 )
       {
         return ITK_NULLPTR;
       }
       return static_cast< const ImageType *>( this->ProcessObject::GetInput( 1 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetInsidePixelValue( PixelType insidePixelValue )
     {
       itkDebugMacro( "setting InsidePixelValue to " << insidePixelValue );
       this->m_NeighbourhoodGreyLevelDifferenceMatrixGenerator->SetInsidePixelValue( insidePixelValue );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::PrintSelf(std::ostream & os, Indent indent) const
     {
       Superclass::PrintSelf(os, indent);
       os << indent << "RequestedFeatures: "
         << this->GetRequestedFeatures() << std::endl;
       os << indent << "FeatureStandardDeviations: "
         << this->GetFeatureStandardDeviations() << std::endl;
       os << indent << "FastCalculations: "
         << this->GetFastCalculations() << std::endl;
       os << indent << "Offsets: " << this->GetOffsets() << std::endl;
       os << indent << "FeatureMeans: " << this->GetFeatureMeans() << std::endl;
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.h
index 3b55f16b9e..1f58958dd6 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.h
@@ -1,295 +1,295 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter_h
 #define __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter_h
 
 #include "itkImage.h"
 #include "itkHistogram.h"
 #include "itkNumericTraits.h"
 #include "itkVectorContainer.h"
 
 namespace itk
 {
   namespace Statistics
   {
     /** \class EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter
     *  \brief This class computes a run length matrix (histogram) from
     *  a given image and a mask image if provided. Run length matrces are
     *  used for image texture description.
     *
     * This filters creates a grey-level run length matrix from a N-D scalar
     * image. This is another possible texture description.  See the following
     * references.
     * M. M. Galloway. Texture analysis using gray level run lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * run lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level run-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
     * The basic idea is as follows:
     * Given an image and an offset (e.g. (1, -1) for a 2-d image), each element
     * in the joint histogram describes the frequency for a particular distance/
     * intensity pair within a given image.  This distance/intensity pair can be
     * described as follows: we start at a given voxel which has some intensity.
     * We then "jump" to neighboring pixels in increments provided by the offset(s)
     * as long as the pixel to which we are jumping is within the same intensity
     * bin as the original voxel.  The distance component is given by the distance
     * from the original to the final voxel satisfying our jumping criteria.
     *
     * The offset (or offsets) along which the co-occurences are calculated can be
     * set by the user. Traditionally, only one offset is used per histogram, and
     * offset components in the range [-1, 1] are used. For rotation-invariant
     * features averages of features computed over several histograms with different
     * offsets are generally used, instead of computing features from one histogram
     * create with several offsets. Additionally, instead of using offsets of two or
     * more pixels in any direction, multi-resolution techniques (e.g. image
     * pyramids) are generally used to deal with texture at different spatial
     * resolutions.
     *
     * This class calculates a 2-d histogram of all the intensity/distance pairs in
     * the given image's requested region, for a given set of offsets. That is, if
     * a given offset falls outside of the requested region (or outside the mask)
     * at a particular point, that distance/intensity pair will not be added to
     * the matrix.
     *
     * The number of histogram bins on each axis can be set (defaults to 256). Also,
     * by default the histogram min and max corresponds to the largest and smallest
     * possible pixel value of that pixel type. To customize the histogram bounds
     * for a given image, the max and min pixel values that will be placed in the
     * histogram can be set manually. NB: The min and max are INCLUSIVE.
     *
     * Further, the type of histogram frequency container used is an optional
     * template parameter. By default, a dense container is used, but for images
     * with little texture or in cases where the user wants more histogram bins,
     * a sparse container can be used for the histogram instead.
     *
     * WARNING: This probably won't work for pixels of double or long-double type
     * unless you set the histogram min and max manually. This is because the largest
     * histogram bin by default has max value of the largest possible pixel value
     * plus 1. For double and long-double types, whose "RealType" as defined by the
     * NumericTraits class is the same, and thus cannot hold any larger values,
     * this would cause a float overflow.
     *
-    * IJ article: http://hdl.handle.net/1926/1374
+    * IJ article: https://hdl.handle.net/1926/1374
     *
     * \sa ScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter
     * \sa EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter
     * \sa HistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template<typename TImageType, typename THistogramFrequencyContainer =
       DenseFrequencyContainer2>
     class EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter : public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter  Self;
       typedef ProcessObject                       Superclass;
       typedef SmartPointer<Self>                  Pointer;
       typedef SmartPointer<const Self>            ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro( EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter, ProcessObject );
 
       /** standard New() method support */
       itkNewMacro( Self );
 
       typedef TImageType                                      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                  RegionType;
       typedef typename ImageType::SizeType                    RadiusType;
       typedef typename ImageType::OffsetType                  OffsetType;
       typedef VectorContainer<unsigned char, OffsetType>      OffsetVector;
       typedef typename OffsetVector::Pointer                  OffsetVectorPointer;
       typedef typename ImageType::PointType                   PointType;
 
       typedef typename NumericTraits<PixelType>::RealType     MeasurementType;
       typedef typename NumericTraits<PixelType>::RealType     RealType;
 
       typedef Histogram<MeasurementType, THistogramFrequencyContainer>
         HistogramType;
       typedef typename HistogramType::Pointer                 HistogramPointer;
       typedef typename HistogramType::ConstPointer            HistogramConstPointer;
       typedef typename HistogramType::MeasurementVectorType   MeasurementVectorType;
 
       /** ImageDimension constants */
       itkStaticConstMacro( ImageDimension, unsigned int,
         TImageType::ImageDimension );
 
       /** Specify the default number of bins per axis */
       itkStaticConstMacro( DefaultBinsPerAxis, unsigned int, 256 );
 
       /**
       * Set the offsets over which the intensity/distance pairs will be computed.
       * Invoking this function clears the previous offsets.
       * Note: for each individual offset in the OffsetVector, the rightmost non-zero
       * offset element must be positive. For example, in the offset list of a 2D image,
       * (1, 0) means the offset  along x-axis. (1, 0) has to be set instead
       * of (-1, 0). This is required from the iterating order of pixel iterator.
       *
       */
       itkSetObjectMacro( Offsets, OffsetVector );
 
       /**
       * Set offset over which the intensity/distance pairs will be computed.
       * Invoking this function clears the previous offset(s).
       * Note: for each individual offset, the rightmost non-zero
       * offset element must be positive. For example, in the offset list of a 2D image,
       * (1, 0) means the offset  along x-axis. (1, 0) has to be set instead
       * of (-1, 0). This is required from the iterating order of pixel iterator.
       *
       */
       void SetOffset( const OffsetType offset );
 
       void AddOffsets( const std::vector<OffsetType> offset );
 
       /**
       * Get the current offset(s).
       */
       itkGetModifiableObjectMacro(Offsets, OffsetVector );
 
       /** Set number of histogram bins along each axis */
       itkSetMacro( NumberOfBinsPerAxis, unsigned int );
 
       /** Get number of histogram bins along each axis */
       itkGetConstMacro( NumberOfBinsPerAxis, unsigned int );
 
       /**
       * Set the min and max (inclusive) pixel value that will be used in
       * generating the histogram.
       */
       void SetPixelValueMinMax( PixelType min, PixelType max );
 
       /** Get the min pixel value defining one dimension of the joint histogram. */
       itkGetConstMacro( Min, PixelType );
 
       /** Get the max pixel value defining one dimension of the joint histogram. */
       itkGetConstMacro( Max, PixelType );
 
       /**
       * Set the min and max (inclusive) pixel value that will be used in
       * generating the histogram.
       */
       void SetDistanceValueMinMax( RealType min, RealType max );
 
       /**
       * Get the min distance value defining one dimension of the joint histogram.
       */
       itkGetConstMacro( MinDistance, RealType );
 
       /**
       * Get the max distance value defining one dimension of the joint histogram.
       */
       itkGetConstMacro( MaxDistance, RealType );
 
       /** Method to set the input image */
       using Superclass::SetInput;
       void SetInput( const ImageType *image );
 
       /** Method to get the input image */
       const ImageType * GetInput() const;
 
       /** Method to set the mask image */
       void SetMaskImage( const ImageType *image );
 
       /** Method to get the mask image */
       const ImageType * GetMaskImage() const;
 
       /** method to get the Histogram */
       const HistogramType * GetOutput() const;
 
       /** method to get the Histogram */
       double* GetSiMatrix() const;
 
       /**
       * Set the pixel value of the mask that should be considered "inside" the
       * object. Defaults to 1.
       */
       itkSetMacro( InsidePixelValue, PixelType );
       itkGetConstMacro( InsidePixelValue, PixelType );
 
     protected:
       EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter();
       ~EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter() override {};
       void PrintSelf( std::ostream& os, Indent indent ) const ITK_OVERRIDE;
 
       /** Standard itk::ProcessObject subclass method. */
       typedef DataObject::Pointer DataObjectPointer;
 
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       DataObjectPointer MakeOutput( DataObjectPointerArraySizeType idx ) ITK_OVERRIDE;
 
       /** This method causes the filter to generate its output. */
       void GenerateData() ITK_OVERRIDE;
 
       /**
       * Normalize the direction of the offset before it is applied.
       * The last non-zero dimension of the offest has to be positive in order
       * to match to scanning order of the iterator. Only the sign is changed.
       * For example, the input offset (-1, 0) will be normalized as
       * (1, 0).
       * */
       void NormalizeOffsetDirection(OffsetType &offset);
 
     private:
 
       unsigned int             m_NumberOfBinsPerAxis;
       PixelType                m_Min;
       PixelType                m_Max;
       RealType                 m_MinDistance;
       RealType                 m_MaxDistance;
       PixelType                m_InsidePixelValue;
 
       MeasurementVectorType    m_LowerBound;
       MeasurementVectorType    m_UpperBound;
       OffsetVectorPointer      m_Offsets;
 
       double * m_siMatrix;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.hxx
index 05f7bd24b2..bb0e407288 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.hxx
@@ -1,396 +1,396 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter_hxx
 #define __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter_hxx
 
 #include "itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.h"
 
 #include "itkConstNeighborhoodIterator.h"
 #include "itkNeighborhood.h"
 #include "vnl/vnl_math.h"
 #include "itkMacro.h"
 #include "itkRescaleIntensityImageFilter.h"
 #include "itkMaskImageFilter.h"
 #include "itkLabelStatisticsImageFilter.h"
 #include "itkScalarConnectedComponentImageFilter.h"
 #include "itkRelabelComponentImageFilter.h"
 #include "itkCastImageFilter.h"
 
 #include <mitkLogMacros.h>
 
 namespace itk
 {
 namespace Statistics
 {
 template<typename TImageType, typename THistogramFrequencyContainer>
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter() :
   m_NumberOfBinsPerAxis( itkGetStaticConstMacro( DefaultBinsPerAxis ) ),
   m_Min( NumericTraits<PixelType>::NonpositiveMin() ),
   m_Max( NumericTraits<PixelType>::max() ),
   m_MinDistance( NumericTraits<RealType>::ZeroValue() ),
   m_MaxDistance( NumericTraits<RealType>::max() ),
   m_InsidePixelValue( NumericTraits<PixelType>::OneValue() )
 {
   this->SetNumberOfRequiredInputs( 1 );
   this->SetNumberOfRequiredOutputs( 1 );
 
   const unsigned int measurementVectorSize = 1;
 
   this->ProcessObject::SetNthOutput( 0, this->MakeOutput( 0 ) );
   this->ProcessObject::SetNthOutput( 1, this->MakeOutput( 1 ) );
   HistogramType *output = const_cast<HistogramType *>( this->GetOutput() );
   output->SetMeasurementVectorSize( measurementVectorSize );
 
   m_siMatrix = new double[m_NumberOfBinsPerAxis];
   for(unsigned int i = 0; i < m_NumberOfBinsPerAxis; i++)
   {
     m_siMatrix[i] = 0;
   }
 
   this->m_LowerBound.SetSize( measurementVectorSize );
   this->m_UpperBound.SetSize( measurementVectorSize );
 
   this->m_LowerBound[0] = this->m_Min;
   this->m_LowerBound[1] = this->m_MinDistance;
   this->m_UpperBound[0] = this->m_Max;
   this->m_UpperBound[1] = this->m_MaxDistance;
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetOffset( const OffsetType offset )
 {
   OffsetVectorPointer offsetVector = OffsetVector::New();
   offsetVector->push_back( offset );
   this->SetOffsets( offsetVector );
   MITK_WARN << "We now have " << this->GetOffsets()->size() << " offsets in matrixgenerator";
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::AddOffsets( const std::vector<OffsetType> _offsets )
 {
   OffsetVectorPointer offsetVector = OffsetVector::New();
   typename OffsetVector::ConstIterator offsets;
   //MITK_WARN << "We have " << this->GetOffsets()->size() << " offsets!";
   for( std::size_t i = 0; i < _offsets.size(); i++)
   {
   offsetVector->push_back(_offsets[i]);
   auto k = _offsets[i];
   this->NormalizeOffsetDirection(k);
   offsetVector->push_back(k);
   }
   this->SetOffsets( offsetVector );
   MITK_WARN << "We now have " << this->GetOffsets()->size() << " offsets in matrixgenerator";
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetInput( const ImageType *image )
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 0, const_cast<ImageType *>( image ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetMaskImage( const ImageType *image )
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 1, const_cast<ImageType *>( image ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 const TImageType *
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetInput() const
 {
   if( this->GetNumberOfInputs() < 1 )
   {
     return ITK_NULLPTR;
   }
   return static_cast<const ImageType *>( this->ProcessObject::GetInput( 0 ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 const TImageType *
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetMaskImage() const
 {
   if( this->GetNumberOfInputs() < 2 )
   {
     return ITK_NULLPTR;
   }
   return static_cast<const ImageType *>( this->ProcessObject::GetInput( 1 ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 const typename EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType,
 THistogramFrequencyContainer >::HistogramType *
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetOutput() const
 {
   const HistogramType *output =
       static_cast<const HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
   return output;
 }
 
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 double* EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetSiMatrix() const
 {
   return m_siMatrix;
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 typename EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType,
 THistogramFrequencyContainer>::DataObjectPointer
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
 {
   return HistogramType::New().GetPointer();
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GenerateData()
 {
   HistogramType *output =
       static_cast<HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
 
   const ImageType * inputImage = this->GetInput();
   const ImageType * maskImage = this->GetMaskImage();
 
   // First, create an appropriate histogram with the right number of bins
   // and mins and maxes correct for the image type.
   typename HistogramType::SizeType size( output->GetMeasurementVectorSize() );
 
   size.Fill( this->m_NumberOfBinsPerAxis );
   this->m_LowerBound[0] = this->m_Min;
   this->m_LowerBound[1] = this->m_MinDistance;
   this->m_UpperBound[0] = this->m_Max;
   this->m_UpperBound[1] = this->m_MaxDistance;
 
   output->Initialize( size, this->m_LowerBound, this->m_UpperBound );
 
   MeasurementVectorType run( output->GetMeasurementVectorSize() );
   typename HistogramType::IndexType hIndex;
 
   //Cast the image to a float image - with no respect to the incoming image
   //to prevent some non-templated itk issues
   typedef itk::Image<float, 3> FloatImageType;
   typedef itk::CastImageFilter<ImageType, FloatImageType> CastFilterType;
 
   typename CastFilterType::Pointer caster = CastFilterType::New();
   caster->SetInput(inputImage);
   caster->Update();
   typename FloatImageType::Pointer floatImage = caster->GetOutput();
 
   //Cast the mask to an unsigned short image - with no respect to the incomimg maskimage
   //to prevent some non-templated itk issues
   typedef unsigned short                 LabelPixelType;
   typedef itk::Image<LabelPixelType, 3 > LabelImageType;
 
   typedef itk::CastImageFilter<ImageType, LabelImageType> MaskCastFilterType;
   typename MaskCastFilterType::Pointer maskCaster = MaskCastFilterType::New();
   maskCaster->SetInput(maskImage);
   maskCaster->Update();
 
   //Set all values out of the mask to nans.
   typedef itk::MaskImageFilter< FloatImageType, LabelImageType, FloatImageType > MaskFilterType;
   typename MaskFilterType::Pointer maskFilter = MaskFilterType::New();
   maskFilter->SetInput(floatImage);
   maskFilter->SetMaskImage(maskCaster->GetOutput());
   maskFilter->SetOutsideValue( std::numeric_limits<float>::quiet_NaN());
   maskFilter->Update();
   FloatImageType::Pointer floatImageMasked = maskFilter->GetOutput();
 
   typedef ConstNeighborhoodIterator<ImageType> NeighborhoodIteratorType;
   typename NeighborhoodIteratorType::RadiusType radius;
   radius.Fill( 1 );
   NeighborhoodIteratorType neighborIt( radius,
                                        inputImage, inputImage->GetRequestedRegion() );
 
   for( neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt )
   {
     const PixelType centerPixelIntensity = neighborIt.GetCenterPixel();
     IndexType centerIndex = neighborIt.GetIndex();
 
     FloatImageType::IndexType cIndex;
     cIndex[0] = centerIndex[0];
     cIndex[1] = centerIndex[1];
     cIndex[2] = centerIndex[2];
     float centerFloatPixel = floatImageMasked->GetPixel(cIndex);
 
     int px = 0;
     PixelType sum = 0.0;
     bool canCalculate = true;
 
     typename OffsetVector::ConstIterator offsets;
     for( offsets = this->GetOffsets()->Begin();
          offsets != this->GetOffsets()->End(); offsets++ )
     {
       OffsetType offset = offsets.Value();
       IndexType index;
 
       index = centerIndex + offset;
 
       if(!inputImage->GetRequestedRegion().IsInside(index))
       {
         canCalculate = false;
         break;
       }
 
       PixelType offsetPixel = inputImage->GetPixel(index);
 
       FloatImageType::IndexType fIndex;
       fIndex[0] = index[0];
       fIndex[1] = index[1];
       fIndex[2] = index[2];
 
       float floatPixel = floatImageMasked->GetPixel(fIndex);
 
       //We have a nan here
       if(floatPixel != floatPixel || centerFloatPixel!= centerFloatPixel)
       {
         canCalculate = false;
         break;
       }
 
       sum += offsetPixel;
       px++;
     }
     //If we have a nan in the neighbourhood, continue
     if(!canCalculate)
       continue;
 
     PixelType mean = sum / px;
 
     double si = std::abs<double>(mean-centerPixelIntensity);
 
     run[0] = centerPixelIntensity;
 
     //Check for NaN and inf
     if(run[0] == run[0] && !std::isinf(std::abs(run[0])))
     {
       output->GetIndex( run, hIndex );
       output->IncreaseFrequencyOfIndex( hIndex, 1 );
 
       m_siMatrix[hIndex[0]] += si;
     }
     //MITK_WARN << " -> In this round we added: " << centerIndex << " with value " << centerPixelIntensity << " and si = " << si;
     //MITK_WARN << " -> Values are now siMatrix["<<hIndex[0]<<"]: " << m_siMatrix[hIndex[0]];
     //MITK_WARN << " -> Values are now niMatrix: " << output->GetFrequency(hIndex) << "/" << run;
   }
 }
 
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetPixelValueMinMax( PixelType min, PixelType max )
 {
   if( this->m_Min != min || this->m_Max != max )
   {
     itkDebugMacro( "setting Min to " << min << "and Max to " << max );
     this->m_Min = min;
     this->m_Max = max;
     this->Modified();
   }
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetDistanceValueMinMax( RealType min, RealType max )
 {
   if( this->m_MinDistance != min || this->m_MaxDistance != max )
   {
     itkDebugMacro( "setting MinDistance to " << min << "and MaxDistance to "
                    << max );
     this->m_MinDistance = min;
     this->m_MaxDistance = max;
     this->Modified();
   }
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::PrintSelf( std::ostream& os, Indent indent ) const
 {
   Superclass::PrintSelf( os,indent );
   os << indent << "Offsets: " << this->GetOffsets() << std::endl;
   os << indent << "Min: " << this->m_Min << std::endl;
   os << indent << "Max: " << this->m_Max << std::endl;
   os << indent << "Min distance: " << this->m_MinDistance << std::endl;
   os << indent << "Max distance: " << this->m_MaxDistance << std::endl;
   os << indent << "NumberOfBinsPerAxis: " << this->m_NumberOfBinsPerAxis
      << std::endl;
   os << indent << "InsidePixelValue: " << this->m_InsidePixelValue << std::endl;
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::NormalizeOffsetDirection(OffsetType &offset)
 {
   //MITK_WARN <<" -> NGTDM old offset = " << offset;
   itkDebugMacro("old offset = " << offset << std::endl);
   int sign = 1;
   bool metLastNonZero = false;
   for (int i = offset.GetOffsetDimension()-1; i>=0; i--)
   {
     if (metLastNonZero)
     {
       offset[i] *= sign;
     }
     else if (offset[i] != 0)
     {
       sign = (offset[i] > 0 ) ? 1 : -1;
       metLastNonZero = true;
       offset[i] *= sign;
     }
   }
 
   //MITK_WARN << " ->NGTDM new  offset = " << offset;
   itkDebugMacro("new  offset = " << offset << std::endl);
 }
 } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.h
index 4081be5c3a..15ddaa3bc5 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.h
@@ -1,245 +1,245 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToRunLengthFeaturesFilter_h
 #define __itkEnhancedScalarImageToRunLengthFeaturesFilter_h
 
 #include "itkDataObjectDecorator.h"
 
 #include "itkEnhancedHistogramToRunLengthFeaturesFilter.h"
 #include "itkEnhancedScalarImageToRunLengthMatrixFilter.h"
 
 namespace itk
 {
   namespace Statistics
   {
     /** \class EnhancedScalarImageToRunLengthFeaturesFilter
     *  \brief This class computes run length descriptions from an image.
     *
     * By default, run length features are computed for each spatial
     * direction and then averaged afterward, so it is possible to access the
     * standard deviations of the texture features. These values give a clue as
     * to texture anisotropy. However, doing this is much more work, because it
     * involved computing one for each offset given. To compute a single
     * matrix using the first offset, call FastCalculationsOn(). If this is called,
     * then the texture standard deviations will not be computed (and will be set
     * to zero), but texture computation will be much faster.
     *
     * This class is templated over the input image type.
     *
     * Template Parameters:
     * The image type, and the type of histogram frequency container. If you are
     * using a large number of bins per axis, a sparse frequency container may be
     * advisable.  The default is to use a dense frequency container.
     *
     * Inputs and parameters:
     * -# An image
     * -# A mask defining the region over which texture features will be
     *    calculated. (Optional)
     * -# The pixel value that defines the "inside" of the mask. (Optional, defaults
     *    to 1 if a mask is set.)
     * -# The set of features to be calculated. These features are defined
     *    in the HistogramToRunLengthFeaturesFilter class.
     * -# The number of intensity bins. (Optional, defaults to 256.)
     * -# The set of directions (offsets) to average across. (Optional, defaults to
     *    {(-1, 0), (-1, -1), (0, -1), (1, -1)} for 2D images and scales analogously
     *    for ND images.)
     * -# The pixel intensity range over which the features will be calculated.
     *    (Optional, defaults to the full dynamic range of the pixel type.)
     * -# The distance range over which the features will be calculated.
     *    (Optional, defaults to the full dynamic range of double type.)
     *
     * In general, the default parameter values should be sufficient.
     *
     * Outputs:
     * (1) The average value of each feature.
     * (2) The standard deviation in the values of each feature.
     *
     * Print references:
     * M. M. Galloway. Texture analysis using gray level run lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * run lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level run-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
-    * IJ article: http://hdl.handle.net/1926/1374
+    * IJ article: https://hdl.handle.net/1926/1374
     *
     * \sa EnhancedScalarImageToRunLengthFeaturesFilter
     * \sa ScalarImageToRunLengthMatrixFilter
     * \sa HistogramToRunLengthFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template< typename TImageType,
       typename THistogramFrequencyContainer = DenseFrequencyContainer2 >
     class EnhancedScalarImageToRunLengthFeaturesFilter:public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedScalarImageToRunLengthFeaturesFilter  Self;
       typedef ProcessObject                         Superclass;
       typedef SmartPointer< Self >                  Pointer;
       typedef SmartPointer< const Self >            ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro(EnhancedScalarImageToRunLengthFeaturesFilter, ProcessObject);
 
       /** standard New() method support */
       itkNewMacro(Self);
 
       typedef THistogramFrequencyContainer FrequencyContainerType;
       typedef TImageType                   ImageType;
       typedef typename ImageType::Pointer  ImagePointer;
 
       typedef typename ImageType::PixelType                PixelType;
       typedef typename ImageType::OffsetType               OffsetType;
       typedef VectorContainer< unsigned char, OffsetType > OffsetVector;
       typedef typename OffsetVector::Pointer               OffsetVectorPointer;
       typedef typename OffsetVector::ConstPointer          OffsetVectorConstPointer;
 
       typedef EnhancedScalarImageToRunLengthMatrixFilter<
         ImageType, FrequencyContainerType >               RunLengthMatrixFilterType;
 
       typedef typename RunLengthMatrixFilterType::HistogramType
         HistogramType;
 
       typedef EnhancedHistogramToRunLengthFeaturesFilter< HistogramType >
         RunLengthFeaturesFilterType;
 
       typedef short                                    RunLengthFeatureName;
       typedef VectorContainer<unsigned char,
         RunLengthFeatureName>                          FeatureNameVector;
       typedef typename FeatureNameVector::Pointer      FeatureNameVectorPointer;
       typedef typename FeatureNameVector::ConstPointer FeatureNameVectorConstPointer;
       typedef VectorContainer< unsigned char, double > FeatureValueVector;
       typedef typename FeatureValueVector::Pointer     FeatureValueVectorPointer;
 
       /** Smart Pointer type to a DataObject. */
       typedef DataObject::Pointer DataObjectPointer;
 
       /** Type of DataObjects used for scalar outputs */
       typedef DataObjectDecorator< FeatureValueVector >
         FeatureValueVectorDataObjectType;
 
       const FeatureValueVectorDataObjectType * GetFeatureMeansOutput() const;
 
       const FeatureValueVectorDataObjectType * GetFeatureStandardDeviationsOutput()
         const;
 
       /** Connects the input image for which the features are going to be computed
       */
       using Superclass::SetInput;
       void SetInput(const ImageType *);
 
       const ImageType * GetInput() const;
 
       /** Return the feature means and deviations.  */
       itkGetConstReferenceObjectMacro(FeatureMeans, FeatureValueVector);
       itkGetConstReferenceObjectMacro(FeatureStandardDeviations, FeatureValueVector);
 
       /** Set the desired feature set. Optional, for default value see above. */
       itkSetConstObjectMacro(RequestedFeatures, FeatureNameVector);
       itkGetConstObjectMacro(RequestedFeatures, FeatureNameVector);
 
       /** Set the  offsets over which the co-occurrence pairs will be computed.
       Optional; for default value see above. */
       itkSetConstObjectMacro(Offsets, OffsetVector);
       itkGetConstObjectMacro(Offsets, OffsetVector);
 
       /** Set number of histogram bins along each axis.
       Optional; for default value see above. */
       void SetNumberOfBinsPerAxis(unsigned int);
 
       /** Set the min and max (inclusive) pixel value that will be used for
       feature calculations. Optional; for default value see above. */
       void SetPixelValueMinMax(PixelType min, PixelType max);
 
       /** Set the min and max (inclusive) pixel value that will be used for
       feature calculations. Optional; for default value see above. */
       void SetDistanceValueMinMax( double min, double max );
 
       /** Connects the mask image for which the histogram is going to be computed.
       Optional; for default value see above. */
       void SetMaskImage(const ImageType *);
 
       const ImageType * GetMaskImage() const;
 
       /** Set the pixel value of the mask that should be considered "inside" the
       object. Optional; for default value see above. */
       void SetInsidePixelValue(PixelType InsidePixelValue);
 
       itkGetConstMacro(FastCalculations, bool);
       itkSetMacro(FastCalculations, bool);
       itkBooleanMacro(FastCalculations);
       itkGetConstMacro(CombinedFeatureCalculation, bool);
       itkSetMacro(CombinedFeatureCalculation, bool);
       itkBooleanMacro(CombinedFeatureCalculation);
 
     protected:
       EnhancedScalarImageToRunLengthFeaturesFilter();
       ~EnhancedScalarImageToRunLengthFeaturesFilter() override {}
       void PrintSelf( std::ostream & os, Indent indent ) const ITK_OVERRIDE;
 
       void FastCompute();
 
       void FullCompute();
 
       /** This method causes the filter to generate its output. */
       void GenerateData() ITK_OVERRIDE;
 
       /** Make a DataObject to be used for output output. */
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       DataObjectPointer MakeOutput(DataObjectPointerArraySizeType) ITK_OVERRIDE;
 
     private:
       typename RunLengthMatrixFilterType::Pointer m_RunLengthMatrixGenerator;
 
       FeatureValueVectorPointer     m_FeatureMeans;
       FeatureValueVectorPointer     m_FeatureStandardDeviations;
       FeatureNameVectorConstPointer m_RequestedFeatures;
       OffsetVectorConstPointer      m_Offsets;
       bool                          m_FastCalculations;
       bool                          m_CombinedFeatureCalculation;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx
index 38f6cdb772..99d51032b3 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx
@@ -1,431 +1,431 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToRunLengthFeaturesFilter_hxx
 #define __itkEnhancedScalarImageToRunLengthFeaturesFilter_hxx
 
 #include "itkEnhancedScalarImageToRunLengthFeaturesFilter.h"
 #include "itkNeighborhood.h"
 #include <itkImageRegionConstIterator.h>
 #include "vnl/vnl_math.h"
 
 namespace itk
 {
   namespace Statistics
   {
     template<typename TImage, typename THistogramFrequencyContainer>
     EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::EnhancedScalarImageToRunLengthFeaturesFilter() :
       m_CombinedFeatureCalculation(false)
     {
       this->SetNumberOfRequiredInputs( 1 );
       this->SetNumberOfRequiredOutputs( 1 );
 
       for( int i = 0; i < 2; ++i )
       {
         this->ProcessObject::SetNthOutput( i, this->MakeOutput( i ) );
       }
 
       this->m_RunLengthMatrixGenerator = RunLengthMatrixFilterType::New();
       this->m_FeatureMeans = FeatureValueVector::New();
       this->m_FeatureStandardDeviations = FeatureValueVector::New();
 
       // Set the requested features to the default value:
       // {Energy, Entropy, InverseDifferenceMoment, Inertia, ClusterShade,
       // ClusterProminence}
       FeatureNameVectorPointer requestedFeatures = FeatureNameVector::New();
       // can't directly set this->m_RequestedFeatures since it is const!
 
       requestedFeatures->push_back( RunLengthFeaturesFilterType::ShortRunEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::LongRunEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::GreyLevelNonuniformity );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::GreyLevelNonuniformityNormalized );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::RunLengthNonuniformity );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::RunLengthNonuniformityNormalized );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::LowGreyLevelRunEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::HighGreyLevelRunEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::ShortRunLowGreyLevelEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::ShortRunHighGreyLevelEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::LongRunLowGreyLevelEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::LongRunHighGreyLevelEmphasis );
       requestedFeatures->push_back( 20 );
 
       this->SetRequestedFeatures( requestedFeatures );
 
       // 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 Neighborhood<typename ImageType::PixelType,
         ImageType::ImageDimension> 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 );
       this->m_FastCalculations = false;
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     typename
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::DataObjectPointer
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed(idx) )
     {
       return FeatureValueVectorDataObjectType::New().GetPointer();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GenerateData(void)
     {
       if ( this->m_FastCalculations )
       {
         this->FastCompute();
       }
       else
       {
         this->FullCompute();
       }
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FullCompute()
     {
       int numOffsets = this->m_Offsets->size();
       if (m_CombinedFeatureCalculation)
       {
         numOffsets = 1;
       }
       int numFeatures = this->m_RequestedFeatures->size();
       double **features;
 
       features = new double *[numOffsets];
       for( int i = 0; i < numOffsets; i++ )
       {
         features[i] = new double[numFeatures];
       }
 
       unsigned long numberOfVoxels = 0;
       ImageRegionConstIterator<TImage> voxelCountIter(this->GetMaskImage(),this->GetMaskImage()->GetLargestPossibleRegion());
       while ( ! voxelCountIter.IsAtEnd() )
       {
         if (voxelCountIter.Get() > 0)
           ++numberOfVoxels;
         ++voxelCountIter;
       }
 
       // For each offset, calculate each feature
       typename OffsetVector::ConstIterator offsetIt;
       int offsetNum, featureNum;
       typedef typename RunLengthFeaturesFilterType::RunLengthFeatureName
         InternalRunLengthFeatureName;
 
       OffsetVectorPointer offsets = OffsetVector::New();
       if (m_CombinedFeatureCalculation)
       {
         for (int i = 0; i < this->m_Offsets->Size(); ++i)
         {
           offsets->push_back(m_Offsets->ElementAt(i));
         }
       }
 
 
       for( offsetIt = this->m_Offsets->Begin(), offsetNum = 0;
         offsetIt != this->m_Offsets->End(); offsetIt++, offsetNum++ )
       {
         this->m_RunLengthMatrixGenerator->SetOffset(offsetIt.Value());
         if (m_CombinedFeatureCalculation)
         {
           this->m_RunLengthMatrixGenerator->SetOffsets(offsets);
         }
         this->m_RunLengthMatrixGenerator->Update();
         typename RunLengthFeaturesFilterType::Pointer runLengthMatrixCalculator =
           RunLengthFeaturesFilterType::New();
         runLengthMatrixCalculator->SetInput(
           this->m_RunLengthMatrixGenerator->GetOutput() );
         runLengthMatrixCalculator->SetNumberOfVoxels(numberOfVoxels);
         runLengthMatrixCalculator->Update();
 
         typename FeatureNameVector::ConstIterator fnameIt;
         for( fnameIt = this->m_RequestedFeatures->Begin(), featureNum = 0;
           fnameIt != this->m_RequestedFeatures->End(); fnameIt++, featureNum++ )
         {
           features[offsetNum][featureNum] = runLengthMatrixCalculator->GetFeature(
             ( InternalRunLengthFeatureName )fnameIt.Value() );
         }
         if (m_CombinedFeatureCalculation)
         {
           break;
         }
       }
 
       // Now get the mean and deviaton of each feature across the offsets.
       this->m_FeatureMeans->clear();
       this->m_FeatureStandardDeviations->clear();
       double *tempFeatureMeans = new double[numFeatures];
       double *tempFeatureDevs = new double[numFeatures];
 
       /*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 = std::sqrt(S(n) / n) (or divide by n-1 for sample SD instead of
       population SD).
       */
 
       // Set up the initial conditions (k = 1)
       for( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         tempFeatureMeans[featureNum] = features[0][featureNum];
         tempFeatureDevs[featureNum] = 0;
       }
       // Run through the recurrence (k = 2 ... N)
       for( offsetNum = 1; offsetNum < numOffsets; offsetNum++ )
       {
         int k = offsetNum + 1;
         for( featureNum = 0; featureNum < numFeatures; featureNum++ )
         {
           double M_k_minus_1 = tempFeatureMeans[featureNum];
           double S_k_minus_1 = tempFeatureDevs[featureNum];
           double x_k = features[offsetNum][featureNum];
 
           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 );
 
           tempFeatureMeans[featureNum] = M_k;
           tempFeatureDevs[featureNum] = S_k;
         }
       }
       for( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         tempFeatureDevs[featureNum] = std::sqrt( tempFeatureDevs[featureNum] /
           numOffsets );
 
         this->m_FeatureMeans->push_back( tempFeatureMeans[featureNum] );
         this->m_FeatureStandardDeviations->push_back( tempFeatureDevs[featureNum] );
       }
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 0 ) );
       meanOutputObject->Set( this->m_FeatureMeans );
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 1 ) );
       standardDeviationOutputObject->Set( this->m_FeatureStandardDeviations );
 
       delete[] tempFeatureMeans;
       delete[] tempFeatureDevs;
       for( int i = 0; i < numOffsets; i++ )
       {
         delete[] features[i];
       }
       delete[] features;
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FastCompute()
     {
       // Compute the feature for the first offset
       typename OffsetVector::ConstIterator offsetIt = this->m_Offsets->Begin();
       this->m_RunLengthMatrixGenerator->SetOffset( offsetIt.Value() );
 
       this->m_RunLengthMatrixGenerator->Update();
       typename RunLengthFeaturesFilterType::Pointer runLengthMatrixCalculator =
         RunLengthFeaturesFilterType::New();
       runLengthMatrixCalculator->SetInput(
         this->m_RunLengthMatrixGenerator->GetOutput() );
       runLengthMatrixCalculator->Update();
 
       typedef typename RunLengthFeaturesFilterType::RunLengthFeatureName
         InternalRunLengthFeatureName;
       this->m_FeatureMeans->clear();
       this->m_FeatureStandardDeviations->clear();
       typename FeatureNameVector::ConstIterator fnameIt;
       for( fnameIt = this->m_RequestedFeatures->Begin();
         fnameIt != this->m_RequestedFeatures->End(); fnameIt++ )
       {
         this->m_FeatureMeans->push_back( runLengthMatrixCalculator->GetFeature(
           ( InternalRunLengthFeatureName )fnameIt.Value() ) );
         this->m_FeatureStandardDeviations->push_back( 0.0 );
       }
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 0 ) );
       meanOutputObject->Set( this->m_FeatureMeans );
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 1 ) );
       standardDeviationOutputObject->Set( this->m_FeatureStandardDeviations );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetInput( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 0,
         const_cast<ImageType *>( image ) );
 
       this->m_RunLengthMatrixGenerator->SetInput( image );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetNumberOfBinsPerAxis( unsigned int numberOfBins )
     {
       itkDebugMacro( "setting NumberOfBinsPerAxis to " << numberOfBins );
       this->m_RunLengthMatrixGenerator->SetNumberOfBinsPerAxis( numberOfBins );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetPixelValueMinMax( PixelType min, PixelType max )
     {
       itkDebugMacro( "setting Min to " << min << "and Max to " << max );
       this->m_RunLengthMatrixGenerator->SetPixelValueMinMax( min, max );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetDistanceValueMinMax( double min, double max )
     {
       itkDebugMacro( "setting Min to " << min << "and Max to " << max );
       this->m_RunLengthMatrixGenerator->SetDistanceValueMinMax( min, max );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetMaskImage( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 1,
         const_cast< ImageType * >( image ) );
 
       this->m_RunLengthMatrixGenerator->SetMaskImage( image );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const TImage *
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetInput() const
     {
       if ( this->GetNumberOfInputs() < 1 )
       {
         return ITK_NULLPTR;
       }
       return static_cast<const ImageType *>( this->ProcessObject::GetInput( 0 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const typename
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetFeatureMeansOutput() const
     {
       return itkDynamicCastInDebugMode<const FeatureValueVectorDataObjectType *>
         (this->ProcessObject::GetOutput( 0 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const typename
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetFeatureStandardDeviationsOutput() const
     {
       return itkDynamicCastInDebugMode< const FeatureValueVectorDataObjectType * >
         ( this->ProcessObject::GetOutput( 1 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const TImage *
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetMaskImage() const
     {
       if ( this->GetNumberOfInputs() < 2 )
       {
         return ITK_NULLPTR;
       }
       return static_cast< const ImageType *>( this->ProcessObject::GetInput( 1 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetInsidePixelValue( PixelType insidePixelValue )
     {
       itkDebugMacro( "setting InsidePixelValue to " << insidePixelValue );
       this->m_RunLengthMatrixGenerator->SetInsidePixelValue( insidePixelValue );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::PrintSelf(std::ostream & os, Indent indent) const
     {
       Superclass::PrintSelf(os, indent);
       os << indent << "RequestedFeatures: "
         << this->GetRequestedFeatures() << std::endl;
       os << indent << "FeatureStandardDeviations: "
         << this->GetFeatureStandardDeviations() << std::endl;
       os << indent << "FastCalculations: "
         << this->GetFastCalculations() << std::endl;
       os << indent << "Offsets: " << this->GetOffsets() << std::endl;
       os << indent << "FeatureMeans: " << this->GetFeatureMeans() << std::endl;
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.h
index 9a9030fb93..dfdaf31361 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.h
@@ -1,288 +1,288 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToRunLengthMatrixFilter_h
 #define __itkEnhancedScalarImageToRunLengthMatrixFilter_h
 
 #include "itkImage.h"
 #include "itkHistogram.h"
 #include "itkNumericTraits.h"
 #include "itkVectorContainer.h"
 
 namespace itk
 {
   namespace Statistics
   {
     /** \class EnhancedScalarImageToRunLengthMatrixFilter
     *  \brief This class computes a run length matrix (histogram) from
     *  a given image and a mask image if provided. Run length matrces are
     *  used for image texture description.
     *
     * This filters creates a grey-level run length matrix from a N-D scalar
     * image. This is another possible texture description.  See the following
     * references.
     * M. M. Galloway. Texture analysis using gray level run lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * run lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level run-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
     * The basic idea is as follows:
     * Given an image and an offset (e.g. (1, -1) for a 2-d image), each element
     * in the joint histogram describes the frequency for a particular distance/
     * intensity pair within a given image.  This distance/intensity pair can be
     * described as follows: we start at a given voxel which has some intensity.
     * We then "jump" to neighboring pixels in increments provided by the offset(s)
     * as long as the pixel to which we are jumping is within the same intensity
     * bin as the original voxel.  The distance component is given by the distance
     * from the original to the final voxel satisfying our jumping criteria.
     *
     * The offset (or offsets) along which the co-occurences are calculated can be
     * set by the user. Traditionally, only one offset is used per histogram, and
     * offset components in the range [-1, 1] are used. For rotation-invariant
     * features averages of features computed over several histograms with different
     * offsets are generally used, instead of computing features from one histogram
     * create with several offsets. Additionally, instead of using offsets of two or
     * more pixels in any direction, multi-resolution techniques (e.g. image
     * pyramids) are generally used to deal with texture at different spatial
     * resolutions.
     *
     * This class calculates a 2-d histogram of all the intensity/distance pairs in
     * the given image's requested region, for a given set of offsets. That is, if
     * a given offset falls outside of the requested region (or outside the mask)
     * at a particular point, that distance/intensity pair will not be added to
     * the matrix.
     *
     * The number of histogram bins on each axis can be set (defaults to 256). Also,
     * by default the histogram min and max corresponds to the largest and smallest
     * possible pixel value of that pixel type. To customize the histogram bounds
     * for a given image, the max and min pixel values that will be placed in the
     * histogram can be set manually. NB: The min and max are INCLUSIVE.
     *
     * Further, the type of histogram frequency container used is an optional
     * template parameter. By default, a dense container is used, but for images
     * with little texture or in cases where the user wants more histogram bins,
     * a sparse container can be used for the histogram instead.
     *
     * WARNING: This probably won't work for pixels of double or long-double type
     * unless you set the histogram min and max manually. This is because the largest
     * histogram bin by default has max value of the largest possible pixel value
     * plus 1. For double and long-double types, whose "RealType" as defined by the
     * NumericTraits class is the same, and thus cannot hold any larger values,
     * this would cause a float overflow.
     *
-    * IJ article: http://hdl.handle.net/1926/1374
+    * IJ article: https://hdl.handle.net/1926/1374
     *
     * \sa ScalarImageToRunLengthFeaturesFilter
     * \sa EnhancedScalarImageToRunLengthMatrixFilter
     * \sa HistogramToRunLengthFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template<typename TImageType, typename THistogramFrequencyContainer =
       DenseFrequencyContainer2>
     class EnhancedScalarImageToRunLengthMatrixFilter : public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedScalarImageToRunLengthMatrixFilter  Self;
       typedef ProcessObject                       Superclass;
       typedef SmartPointer<Self>                  Pointer;
       typedef SmartPointer<const Self>            ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro( EnhancedScalarImageToRunLengthMatrixFilter, ProcessObject );
 
       /** standard New() method support */
       itkNewMacro( Self );
 
       typedef TImageType                                      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                  RegionType;
       typedef typename ImageType::SizeType                    RadiusType;
       typedef typename ImageType::OffsetType                  OffsetType;
       typedef VectorContainer<unsigned char, OffsetType>      OffsetVector;
       typedef typename OffsetVector::Pointer                  OffsetVectorPointer;
       typedef typename ImageType::PointType                   PointType;
 
       typedef typename NumericTraits<PixelType>::RealType     MeasurementType;
       typedef typename NumericTraits<PixelType>::RealType     RealType;
 
       typedef Histogram<MeasurementType, THistogramFrequencyContainer>
         HistogramType;
       typedef typename HistogramType::Pointer                 HistogramPointer;
       typedef typename HistogramType::ConstPointer            HistogramConstPointer;
       typedef typename HistogramType::MeasurementVectorType   MeasurementVectorType;
 
       /** ImageDimension constants */
       itkStaticConstMacro( ImageDimension, unsigned int,
         TImageType::ImageDimension );
 
       /** Specify the default number of bins per axis */
       itkStaticConstMacro( DefaultBinsPerAxis, unsigned int, 256 );
 
       /**
       * Set the offsets over which the intensity/distance pairs will be computed.
       * Invoking this function clears the previous offsets.
       * Note: for each individual offset in the OffsetVector, the rightmost non-zero
       * offset element must be positive. For example, in the offset list of a 2D image,
       * (1, 0) means the offset  along x-axis. (1, 0) has to be set instead
       * of (-1, 0). This is required from the iterating order of pixel iterator.
       *
       */
       itkSetObjectMacro( Offsets, OffsetVector );
 
       /**
       * Set offset over which the intensity/distance pairs will be computed.
       * Invoking this function clears the previous offset(s).
       * Note: for each individual offset, the rightmost non-zero
       * offset element must be positive. For example, in the offset list of a 2D image,
       * (1, 0) means the offset  along x-axis. (1, 0) has to be set instead
       * of (-1, 0). This is required from the iterating order of pixel iterator.
       *
       */
       void SetOffset( const OffsetType offset );
 
       /**
       * Get the current offset(s).
       */
       itkGetModifiableObjectMacro(Offsets, OffsetVector );
 
       /** Set number of histogram bins along each axis */
       itkSetMacro( NumberOfBinsPerAxis, unsigned int );
 
       /** Get number of histogram bins along each axis */
       itkGetConstMacro( NumberOfBinsPerAxis, unsigned int );
 
       /**
       * Set the min and max (inclusive) pixel value that will be used in
       * generating the histogram.
       */
       void SetPixelValueMinMax( PixelType min, PixelType max );
 
       /** Get the min pixel value defining one dimension of the joint histogram. */
       itkGetConstMacro( Min, PixelType );
 
       /** Get the max pixel value defining one dimension of the joint histogram. */
       itkGetConstMacro( Max, PixelType );
 
       /**
       * Set the min and max (inclusive) pixel value that will be used in
       * generating the histogram.
       */
       void SetDistanceValueMinMax( RealType min, RealType max );
 
       /**
       * Get the min distance value defining one dimension of the joint histogram.
       */
       itkGetConstMacro( MinDistance, RealType );
 
       /**
       * Get the max distance value defining one dimension of the joint histogram.
       */
       itkGetConstMacro( MaxDistance, RealType );
 
       /** Method to set the input image */
       using Superclass::SetInput;
       void SetInput( const ImageType *image );
 
       /** Method to get the input image */
       const ImageType * GetInput() const;
 
       /** Method to set the mask image */
       void SetMaskImage( const ImageType *image );
 
       /** Method to get the mask image */
       const ImageType * GetMaskImage() const;
 
       /** method to get the Histogram */
       const HistogramType * GetOutput() const;
 
       /**
       * Set the pixel value of the mask that should be considered "inside" the
       * object. Defaults to 1.
       */
       itkSetMacro( InsidePixelValue, PixelType );
       itkGetConstMacro( InsidePixelValue, PixelType );
 
     protected:
       EnhancedScalarImageToRunLengthMatrixFilter();
       ~EnhancedScalarImageToRunLengthMatrixFilter() override {};
       void PrintSelf( std::ostream& os, Indent indent ) const ITK_OVERRIDE;
 
       /** Standard itk::ProcessObject subclass method. */
       typedef DataObject::Pointer DataObjectPointer;
 
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       DataObjectPointer MakeOutput( DataObjectPointerArraySizeType idx ) ITK_OVERRIDE;
 
       /** This method causes the filter to generate its output. */
       void GenerateData() ITK_OVERRIDE;
 
       /**
       * Normalize the direction of the offset before it is applied.
       * The last non-zero dimension of the offest has to be positive in order
       * to match to scanning order of the iterator. Only the sign is changed.
       * For example, the input offset (-1, 0) will be normalized as
       * (1, 0).
       * */
       void NormalizeOffsetDirection(OffsetType &offset);
 
     private:
 
       unsigned int             m_NumberOfBinsPerAxis;
       PixelType                m_Min;
       PixelType                m_Max;
       RealType                 m_MinDistance;
       RealType                 m_MaxDistance;
       PixelType                m_InsidePixelValue;
 
       MeasurementVectorType    m_LowerBound;
       MeasurementVectorType    m_UpperBound;
       OffsetVectorPointer      m_Offsets;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedScalarImageToRunLengthMatrixFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.hxx
index 8775a8aef6..4b6b03aa52 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.hxx
@@ -1,411 +1,411 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToRunLengthMatrixFilter_hxx
 #define __itkEnhancedScalarImageToRunLengthMatrixFilter_hxx
 
 #include "itkEnhancedScalarImageToRunLengthMatrixFilter.h"
 
 #include "itkConstNeighborhoodIterator.h"
 #include "itkNeighborhood.h"
 #include "vnl/vnl_math.h"
 #include "itkMacro.h"
 
 namespace itk
 {
   namespace Statistics
   {
     template<typename TImageType, typename THistogramFrequencyContainer>
     EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::EnhancedScalarImageToRunLengthMatrixFilter() :
     m_NumberOfBinsPerAxis( itkGetStaticConstMacro( DefaultBinsPerAxis ) ),
       m_Min( NumericTraits<PixelType>::NonpositiveMin() ),
       m_Max( NumericTraits<PixelType>::max() ),
       m_MinDistance( NumericTraits<RealType>::ZeroValue() ),
       m_MaxDistance( NumericTraits<RealType>::max() ),
       m_InsidePixelValue( NumericTraits<PixelType>::OneValue() )
     {
       this->SetNumberOfRequiredInputs( 1 );
       this->SetNumberOfRequiredOutputs( 1 );
 
       const unsigned int measurementVectorSize = 2;
 
       this->ProcessObject::SetNthOutput( 0, this->MakeOutput( 0 ) );
       HistogramType *output = const_cast<HistogramType *>( this->GetOutput() );
       output->SetMeasurementVectorSize( measurementVectorSize );
 
       this->m_LowerBound.SetSize( measurementVectorSize );
       this->m_UpperBound.SetSize( measurementVectorSize );
 
       this->m_LowerBound[0] = this->m_Min;
       this->m_LowerBound[1] = this->m_MinDistance;
       this->m_UpperBound[0] = this->m_Max;
       this->m_UpperBound[1] = this->m_MaxDistance;
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetOffset( const OffsetType offset )
     {
       OffsetVectorPointer offsetVector = OffsetVector::New();
       offsetVector->push_back( offset );
       this->SetOffsets( offsetVector );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetInput( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 0, const_cast<ImageType *>( image ) );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetMaskImage( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 1, const_cast<ImageType *>( image ) );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     const TImageType *
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::GetInput() const
     {
       if( this->GetNumberOfInputs() < 1 )
       {
         return ITK_NULLPTR;
       }
       return static_cast<const ImageType *>( this->ProcessObject::GetInput( 0 ) );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     const TImageType *
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::GetMaskImage() const
     {
       if( this->GetNumberOfInputs() < 2 )
       {
         return ITK_NULLPTR;
       }
       return static_cast<const ImageType *>( this->ProcessObject::GetInput( 1 ) );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     const typename EnhancedScalarImageToRunLengthMatrixFilter<TImageType,
       THistogramFrequencyContainer >::HistogramType *
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::GetOutput() const
     {
       const HistogramType *output =
         static_cast<const HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
       return output;
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     typename EnhancedScalarImageToRunLengthMatrixFilter<TImageType,
       THistogramFrequencyContainer>::DataObjectPointer
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
     {
       return HistogramType::New().GetPointer();
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::GenerateData()
     {
       HistogramType *output =
         static_cast<HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
 
       const ImageType * inputImage = this->GetInput();
 
       // First, create an appropriate histogram with the right number of bins
       // and mins and maxes correct for the image type.
       typename HistogramType::SizeType size( output->GetMeasurementVectorSize() );
 
       size.Fill( this->m_NumberOfBinsPerAxis );
       this->m_LowerBound[0] = this->m_Min;
       this->m_LowerBound[1] = this->m_MinDistance;
       this->m_UpperBound[0] = this->m_Max;
       this->m_UpperBound[1] = this->m_MaxDistance;
       output->Initialize( size, this->m_LowerBound, this->m_UpperBound );
 
       MeasurementVectorType run( output->GetMeasurementVectorSize() );
       typename HistogramType::IndexType hIndex;
 
       // Iterate over all of those pixels and offsets, adding each
       // distance/intensity pair to the histogram
 
       typedef ConstNeighborhoodIterator<ImageType> NeighborhoodIteratorType;
       typename NeighborhoodIteratorType::RadiusType radius;
       radius.Fill( 1 );
       NeighborhoodIteratorType neighborIt( radius,
         inputImage, inputImage->GetRequestedRegion() );
 
       // this temp image has the same dimension for each offset
       // moving the allocation out of loop of offsets
       // while keeping FillBuffer with boolean false in each loop
       typedef Image<bool, ImageDimension> BoolImageType;
       typename BoolImageType::Pointer alreadyVisitedImage = BoolImageType::New();
       alreadyVisitedImage->CopyInformation( inputImage );
       alreadyVisitedImage->SetRegions( inputImage->GetRequestedRegion() );
       alreadyVisitedImage->Allocate();
 
       typename OffsetVector::ConstIterator offsets;
       for( offsets = this->GetOffsets()->Begin();
         offsets != this->GetOffsets()->End(); offsets++ )
       {
         alreadyVisitedImage->FillBuffer( false );
 
         neighborIt.GoToBegin();
         OffsetType offset = offsets.Value();
 
         this->NormalizeOffsetDirection(offset);
 
         for( neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt )
         {
           const PixelType centerPixelIntensity = neighborIt.GetCenterPixel();
           if (centerPixelIntensity != centerPixelIntensity) // Check for invalid values
           {
             continue;
           }
           IndexType centerIndex = neighborIt.GetIndex();
           if( centerPixelIntensity < this->m_Min ||
             centerPixelIntensity > this->m_Max ||
             alreadyVisitedImage->GetPixel( centerIndex ) || ( this->GetMaskImage() &&
             this->GetMaskImage()->GetPixel( centerIndex ) !=
             this->m_InsidePixelValue ) )
           {
             continue; // don't put a pixel in the histogram if the value
             // is out-of-bounds or is outside the mask.
           }
 
           itkDebugMacro("===> offset = " << offset << std::endl);
 
           MeasurementType centerBinMin = this->GetOutput()->
             GetBinMinFromValue( 0, centerPixelIntensity );
           MeasurementType centerBinMax = this->GetOutput()->
             GetBinMaxFromValue( 0, centerPixelIntensity );
           MeasurementType lastBinMax = this->GetOutput()->
             GetDimensionMaxs( 0 )[ this->GetOutput()->GetSize( 0 ) - 1 ];
 
           PixelType pixelIntensity( NumericTraits<PixelType>::ZeroValue() );
           IndexType index;
 
           int steps = 0;
           index = centerIndex + offset;
           IndexType lastGoodIndex = centerIndex;
           bool runLengthSegmentAlreadyVisited = false;
 
           // Scan from the current pixel at index, following
           // the direction of offset. Run length is computed as the
           // length of continuous pixels whose pixel values are
           // in the same bin.
 
           while ( inputImage->GetRequestedRegion().IsInside(index) )
           {
             pixelIntensity = inputImage->GetPixel(index);
             // For the same offset, each run length segment can
             // only be visited once
             if (alreadyVisitedImage->GetPixel( index ) )
             {
               runLengthSegmentAlreadyVisited = true;
               break;
             }
             if (pixelIntensity != pixelIntensity)
             {
               break;
             }
 
 
             // Special attention paid to boundaries of bins.
             // For the last bin,
             // it is left close and right close (following the previous
             // gerrit patch).
             // For all
             // other bins,
             // the bin is left close and right open.
 
             if ( pixelIntensity >= centerBinMin
               && ( pixelIntensity < centerBinMax || ( pixelIntensity == centerBinMax && centerBinMax == lastBinMax ) )
               && (!this->GetMaskImage() || this->GetMaskImage()->GetPixel(index) == this->m_InsidePixelValue))
             {
               alreadyVisitedImage->SetPixel( index, true );
               lastGoodIndex = index;
               index += offset;
               steps++;
             }
             else
             {
               break;
             }
           }
 
           if ( runLengthSegmentAlreadyVisited )
           {
             MITK_INFO << "Already visited 1 " << index;
             continue;
           }
           IndexType lastGoodIndex2 = lastGoodIndex;
           index = centerIndex - offset;
           lastGoodIndex = centerIndex;
           while ( inputImage->GetRequestedRegion().IsInside(index) )
           {
             pixelIntensity = inputImage->GetPixel(index);
             if (pixelIntensity != pixelIntensity)
             {
               break;
             }
             if (alreadyVisitedImage->GetPixel( index ) )
             {
               if (pixelIntensity >= centerBinMin
                 && (pixelIntensity < centerBinMax || (pixelIntensity == centerBinMax && centerBinMax == lastBinMax)))
               {
                 runLengthSegmentAlreadyVisited = true;
               }
               break;
             }
 
             if ( pixelIntensity >= centerBinMin
               && ( pixelIntensity < centerBinMax || ( pixelIntensity == centerBinMax && centerBinMax == lastBinMax ) )
               && (!this->GetMaskImage() || this->GetMaskImage()->GetPixel(index) == this->m_InsidePixelValue))
             {
               alreadyVisitedImage->SetPixel( index, true );
               lastGoodIndex = index;
               steps++;
               index -= offset;
             }
             else
               break;
           }
           if (runLengthSegmentAlreadyVisited)
           {
             MITK_INFO << "Already visited 2 " << index;
             continue;
           }
           PointType centerPoint;
           inputImage->TransformIndexToPhysicalPoint(
             centerIndex, centerPoint );
           PointType point;
           inputImage->TransformIndexToPhysicalPoint( lastGoodIndex, point );
           PointType point2;
           inputImage->TransformIndexToPhysicalPoint( lastGoodIndex2, point2 );
 
           run[0] = centerPixelIntensity;
           run[1] = steps;
           //run[1] = point.EuclideanDistanceTo( point2 );
 
           if( run[1] >= this->m_MinDistance && run[1] <= this->m_MaxDistance )
           {
             output->GetIndex( run, hIndex );
             output->IncreaseFrequencyOfIndex( hIndex, 1 );
           }
         }
       }
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetPixelValueMinMax( PixelType min, PixelType max )
     {
       if( this->m_Min != min || this->m_Max != max )
       {
         itkDebugMacro( "setting Min to " << min << "and Max to " << max );
         this->m_Min = min;
         this->m_Max = max;
         this->Modified();
       }
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetDistanceValueMinMax( RealType min, RealType max )
     {
       if( this->m_MinDistance != min || this->m_MaxDistance != max )
       {
         itkDebugMacro( "setting MinDistance to " << min << "and MaxDistance to "
           << max );
         this->m_MinDistance = min;
         this->m_MaxDistance = max;
         this->Modified();
       }
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::PrintSelf( std::ostream& os, Indent indent ) const
     {
       Superclass::PrintSelf( os,indent );
       os << indent << "Offsets: " << this->GetOffsets() << std::endl;
       os << indent << "Min: " << this->m_Min << std::endl;
       os << indent << "Max: " << this->m_Max << std::endl;
       os << indent << "Min distance: " << this->m_MinDistance << std::endl;
       os << indent << "Max distance: " << this->m_MaxDistance << std::endl;
       os << indent << "NumberOfBinsPerAxis: " << this->m_NumberOfBinsPerAxis
         << std::endl;
       os << indent << "InsidePixelValue: " << this->m_InsidePixelValue << std::endl;
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::NormalizeOffsetDirection(OffsetType &offset)
     {
       itkDebugMacro("old offset = " << offset << std::endl);
       int sign = 1;
       bool metLastNonZero = false;
       for (int i = offset.GetOffsetDimension()-1; i>=0; i--)
       {
         if (metLastNonZero)
         {
           offset[i] *= sign;
         }
         else if (offset[i] != 0)
         {
           sign = (offset[i] > 0 ) ? 1 : -1;
           metLastNonZero = true;
           offset[i] *= sign;
         }
       }
 
       itkDebugMacro("new  offset = " << offset << std::endl);
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneFeaturesFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneFeaturesFilter.h
index c96a9d4f91..2e40883d5b 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneFeaturesFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneFeaturesFilter.h
@@ -1,241 +1,241 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToSizeZoneFeaturesFilter_h
 #define __itkEnhancedScalarImageToSizeZoneFeaturesFilter_h
 
 #include "itkDataObjectDecorator.h"
 
 #include "itkEnhancedHistogramToSizeZoneFeaturesFilter.h"
 #include "itkEnhancedScalarImageToSizeZoneMatrixFilter.h"
 
 namespace itk
 {
   namespace Statistics
   {
     /** \class EnhancedScalarImageToSizeZoneFeaturesFilter
     *  \brief This class computes run length descriptions from an image.
     *
     * By default, run length features are computed for each spatial
     * direction and then averaged afterward, so it is possible to access the
     * standard deviations of the texture features. These values give a clue as
     * to texture anisotropy. However, doing this is much more work, because it
     * involved computing one for each offset given. To compute a single
     * matrix using the first offset, call FastCalculationsOn(). If this is called,
     * then the texture standard deviations will not be computed (and will be set
     * to zero), but texture computation will be much faster.
     *
     * This class is templated over the input image type.
     *
     * Template Parameters:
     * The image type, and the type of histogram frequency container. If you are
     * using a large number of bins per axis, a sparse frequency container may be
     * advisable.  The default is to use a dense frequency container.
     *
     * Inputs and parameters:
     * -# An image
     * -# A mask defining the region over which texture features will be
     *    calculated. (Optional)
     * -# The pixel value that defines the "inside" of the mask. (Optional, defaults
     *    to 1 if a mask is set.)
     * -# The set of features to be calculated. These features are defined
     *    in the HistogramToSizeZoneFeaturesFilter class.
     * -# The number of intensity bins. (Optional, defaults to 256.)
     * -# The set of directions (offsets) to average across. (Optional, defaults to
     *    {(-1, 0), (-1, -1), (0, -1), (1, -1)} for 2D images and scales analogously
     *    for ND images.)
     * -# The pixel intensity range over which the features will be calculated.
     *    (Optional, defaults to the full dynamic range of the pixel type.)
     * -# The distance range over which the features will be calculated.
     *    (Optional, defaults to the full dynamic range of double type.)
     *
     * In general, the default parameter values should be sufficient.
     *
     * Outputs:
     * (1) The average value of each feature.
     * (2) The standard deviation in the values of each feature.
     *
     * Print references:
     * M. M. Galloway. Texture analysis using gray level run lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * run lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level run-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
-    * IJ article: http://hdl.handle.net/1926/1374
+    * IJ article: https://hdl.handle.net/1926/1374
     *
     * \sa EnhancedScalarImageToSizeZoneFeaturesFilter
     * \sa ScalarImageToSizeZoneMatrixFilter
     * \sa HistogramToSizeZoneFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template< typename TImageType,
       typename THistogramFrequencyContainer = DenseFrequencyContainer2 >
     class EnhancedScalarImageToSizeZoneFeaturesFilter:public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedScalarImageToSizeZoneFeaturesFilter  Self;
       typedef ProcessObject                         Superclass;
       typedef SmartPointer< Self >                  Pointer;
       typedef SmartPointer< const Self >            ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro(EnhancedScalarImageToSizeZoneFeaturesFilter, ProcessObject);
 
       /** standard New() method support */
       itkNewMacro(Self);
 
       typedef THistogramFrequencyContainer FrequencyContainerType;
       typedef TImageType                   ImageType;
       typedef typename ImageType::Pointer  ImagePointer;
 
       typedef typename ImageType::PixelType                PixelType;
       typedef typename ImageType::OffsetType               OffsetType;
       typedef VectorContainer< unsigned char, OffsetType > OffsetVector;
       typedef typename OffsetVector::Pointer               OffsetVectorPointer;
       typedef typename OffsetVector::ConstPointer          OffsetVectorConstPointer;
 
       typedef EnhancedScalarImageToSizeZoneMatrixFilter<
         ImageType, FrequencyContainerType >               SizeZoneMatrixFilterType;
 
       typedef typename SizeZoneMatrixFilterType::HistogramType
         HistogramType;
 
       typedef EnhancedHistogramToSizeZoneFeaturesFilter< HistogramType >
         SizeZoneFeaturesFilterType;
 
       typedef short                                    SizeZoneFeatureName;
       typedef VectorContainer<unsigned char,
         SizeZoneFeatureName>                          FeatureNameVector;
       typedef typename FeatureNameVector::Pointer      FeatureNameVectorPointer;
       typedef typename FeatureNameVector::ConstPointer FeatureNameVectorConstPointer;
       typedef VectorContainer< unsigned char, double > FeatureValueVector;
       typedef typename FeatureValueVector::Pointer     FeatureValueVectorPointer;
 
       /** Smart Pointer type to a DataObject. */
       typedef DataObject::Pointer DataObjectPointer;
 
       /** Type of DataObjects used for scalar outputs */
       typedef DataObjectDecorator< FeatureValueVector >
         FeatureValueVectorDataObjectType;
 
       const FeatureValueVectorDataObjectType * GetFeatureMeansOutput() const;
 
       const FeatureValueVectorDataObjectType * GetFeatureStandardDeviationsOutput()
         const;
 
       /** Connects the input image for which the features are going to be computed
       */
       using Superclass::SetInput;
       void SetInput(const ImageType *);
 
       const ImageType * GetInput() const;
 
       /** Return the feature means and deviations.  */
       itkGetConstReferenceObjectMacro(FeatureMeans, FeatureValueVector);
       itkGetConstReferenceObjectMacro(FeatureStandardDeviations, FeatureValueVector);
 
       /** Set the desired feature set. Optional, for default value see above. */
       itkSetConstObjectMacro(RequestedFeatures, FeatureNameVector);
       itkGetConstObjectMacro(RequestedFeatures, FeatureNameVector);
 
       /** Set the  offsets over which the co-occurrence pairs will be computed.
       Optional; for default value see above. */
       itkSetConstObjectMacro(Offsets, OffsetVector);
       itkGetConstObjectMacro(Offsets, OffsetVector);
 
       /** Set number of histogram bins along each axis.
       Optional; for default value see above. */
       void SetNumberOfBinsPerAxis(unsigned int);
 
       /** Set the min and max (inclusive) pixel value that will be used for
       feature calculations. Optional; for default value see above. */
       void SetPixelValueMinMax(PixelType min, PixelType max);
 
       /** Set the min and max (inclusive) pixel value that will be used for
       feature calculations. Optional; for default value see above. */
       void SetDistanceValueMinMax( double min, double max );
 
       /** Connects the mask image for which the histogram is going to be computed.
       Optional; for default value see above. */
       void SetMaskImage(const ImageType *);
 
       const ImageType * GetMaskImage() const;
 
       /** Set the pixel value of the mask that should be considered "inside" the
       object. Optional; for default value see above. */
       void SetInsidePixelValue(PixelType InsidePixelValue);
 
       itkGetConstMacro(FastCalculations, bool);
       itkSetMacro(FastCalculations, bool);
       itkBooleanMacro(FastCalculations);
 
     protected:
       EnhancedScalarImageToSizeZoneFeaturesFilter();
       virtual ~EnhancedScalarImageToSizeZoneFeaturesFilter() {}
       virtual void PrintSelf( std::ostream & os, Indent indent ) const ITK_OVERRIDE;
 
       void FastCompute();
 
       void FullCompute();
 
       /** This method causes the filter to generate its output. */
       virtual void GenerateData() ITK_OVERRIDE;
 
       /** Make a DataObject to be used for output output. */
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType) ITK_OVERRIDE;
 
     private:
       typename SizeZoneMatrixFilterType::Pointer m_SizeZoneMatrixGenerator;
 
       FeatureValueVectorPointer     m_FeatureMeans;
       FeatureValueVectorPointer     m_FeatureStandardDeviations;
       FeatureNameVectorConstPointer m_RequestedFeatures;
       OffsetVectorConstPointer      m_Offsets;
       bool                          m_FastCalculations;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedScalarImageToSizeZoneFeaturesFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneFeaturesFilter.hxx
index 351002f7ec..98e29defaa 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneFeaturesFilter.hxx
@@ -1,408 +1,408 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToSizeZoneFeaturesFilter_hxx
 #define __itkEnhancedScalarImageToSizeZoneFeaturesFilter_hxx
 
 #include "itkEnhancedScalarImageToSizeZoneFeaturesFilter.h"
 #include "itkNeighborhood.h"
 #include <itkImageRegionConstIterator.h>
 #include "vnl/vnl_math.h"
 
 namespace itk
 {
   namespace Statistics
   {
     template<typename TImage, typename THistogramFrequencyContainer>
     EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::EnhancedScalarImageToSizeZoneFeaturesFilter()
     {
       this->SetNumberOfRequiredInputs( 1 );
       this->SetNumberOfRequiredOutputs( 1 );
 
       for( int i = 0; i < 2; ++i )
       {
         this->ProcessObject::SetNthOutput( i, this->MakeOutput( i ) );
       }
 
       this->m_SizeZoneMatrixGenerator = SizeZoneMatrixFilterType::New();
       this->m_FeatureMeans = FeatureValueVector::New();
       this->m_FeatureStandardDeviations = FeatureValueVector::New();
 
       // Set the requested features to the default value:
       // {Energy, Entropy, InverseDifferenceMoment, Inertia, ClusterShade,
       // ClusterProminence}
       FeatureNameVectorPointer requestedFeatures = FeatureNameVector::New();
       // can't directly set this->m_RequestedFeatures since it is const!
 
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::SmallZoneEmphasis );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::LargeZoneEmphasis );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::GreyLevelNonuniformity );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::GreyLevelNonuniformityNormalized );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::SizeZoneNonuniformity );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::SizeZoneNonuniformityNormalized );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::LowGreyLevelZoneEmphasis );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::HighGreyLevelZoneEmphasis );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::SmallZoneLowGreyLevelEmphasis );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::SmallZoneHighGreyLevelEmphasis );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::LargeZoneLowGreyLevelEmphasis );
       requestedFeatures->push_back( SizeZoneFeaturesFilterType::LargeZoneHighGreyLevelEmphasis );
       requestedFeatures->push_back( 20 );
 
       this->SetRequestedFeatures( requestedFeatures );
 
       // 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 Neighborhood<typename ImageType::PixelType,
         ImageType::ImageDimension> 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 );
       this->m_FastCalculations = false;
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     typename
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::DataObjectPointer
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed(idx) )
     {
       return FeatureValueVectorDataObjectType::New().GetPointer();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GenerateData(void)
     {
       if ( this->m_FastCalculations )
       {
         this->FastCompute();
       }
       else
       {
         this->FullCompute();
       }
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FullCompute()
     {
       int numOffsets = this->m_Offsets->size();
       int numFeatures = this->m_RequestedFeatures->size();
       double **features;
 
       features = new double *[numOffsets];
       for( int i = 0; i < numOffsets; i++ )
       {
         features[i] = new double[numFeatures];
       }
 
       unsigned long numberOfVoxels = 0;
       ImageRegionConstIterator<TImage> voxelCountIter(this->GetMaskImage(),this->GetMaskImage()->GetLargestPossibleRegion());
       while ( ! voxelCountIter.IsAtEnd() )
       {
         if (voxelCountIter.Get() > 0)
           ++numberOfVoxels;
         ++voxelCountIter;
       }
 
       // For each offset, calculate each feature
       typename OffsetVector::ConstIterator offsetIt;
       int offsetNum, featureNum;
       typedef typename SizeZoneFeaturesFilterType::SizeZoneFeatureName
         InternalSizeZoneFeatureName;
 
       for( offsetIt = this->m_Offsets->Begin(), offsetNum = 0;
         offsetIt != this->m_Offsets->End(); offsetIt++, offsetNum++ )
       {
         this->m_SizeZoneMatrixGenerator->SetOffset( offsetIt.Value() );
         this->m_SizeZoneMatrixGenerator->Update();
         typename SizeZoneFeaturesFilterType::Pointer SizeZoneMatrixCalculator =
           SizeZoneFeaturesFilterType::New();
         SizeZoneMatrixCalculator->SetInput(
           this->m_SizeZoneMatrixGenerator->GetOutput() );
         SizeZoneMatrixCalculator->SetNumberOfVoxels(numberOfVoxels);
         SizeZoneMatrixCalculator->Update();
 
         typename FeatureNameVector::ConstIterator fnameIt;
         for( fnameIt = this->m_RequestedFeatures->Begin(), featureNum = 0;
           fnameIt != this->m_RequestedFeatures->End(); fnameIt++, featureNum++ )
         {
           features[offsetNum][featureNum] = SizeZoneMatrixCalculator->GetFeature(
             ( InternalSizeZoneFeatureName )fnameIt.Value() );
         }
       }
 
       // Now get the mean and deviaton of each feature across the offsets.
       this->m_FeatureMeans->clear();
       this->m_FeatureStandardDeviations->clear();
       double *tempFeatureMeans = new double[numFeatures];
       double *tempFeatureDevs = new double[numFeatures];
 
       /*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 = std::sqrt(S(n) / n) (or divide by n-1 for sample SD instead of
       population SD).
       */
 
       // Set up the initial conditions (k = 1)
       for( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         tempFeatureMeans[featureNum] = features[0][featureNum];
         tempFeatureDevs[featureNum] = 0;
       }
       // Zone through the recurrence (k = 2 ... N)
       for( offsetNum = 1; offsetNum < numOffsets; offsetNum++ )
       {
         int k = offsetNum + 1;
         for( featureNum = 0; featureNum < numFeatures; featureNum++ )
         {
           double M_k_minus_1 = tempFeatureMeans[featureNum];
           double S_k_minus_1 = tempFeatureDevs[featureNum];
           double x_k = features[offsetNum][featureNum];
 
           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 );
 
           tempFeatureMeans[featureNum] = M_k;
           tempFeatureDevs[featureNum] = S_k;
         }
       }
       for( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         tempFeatureDevs[featureNum] = std::sqrt( tempFeatureDevs[featureNum] /
           numOffsets );
 
         this->m_FeatureMeans->push_back( tempFeatureMeans[featureNum] );
         this->m_FeatureStandardDeviations->push_back( tempFeatureDevs[featureNum] );
       }
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 0 ) );
       meanOutputObject->Set( this->m_FeatureMeans );
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 1 ) );
       standardDeviationOutputObject->Set( this->m_FeatureStandardDeviations );
 
       delete[] tempFeatureMeans;
       delete[] tempFeatureDevs;
       for( int i = 0; i < numOffsets; i++ )
       {
         delete[] features[i];
       }
       delete[] features;
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FastCompute()
     {
       // Compute the feature for the first offset
       typename OffsetVector::ConstIterator offsetIt = this->m_Offsets->Begin();
       this->m_SizeZoneMatrixGenerator->SetOffset( offsetIt.Value() );
 
       this->m_SizeZoneMatrixGenerator->Update();
       typename SizeZoneFeaturesFilterType::Pointer SizeZoneMatrixCalculator =
         SizeZoneFeaturesFilterType::New();
       SizeZoneMatrixCalculator->SetInput(
         this->m_SizeZoneMatrixGenerator->GetOutput() );
       SizeZoneMatrixCalculator->Update();
 
       typedef typename SizeZoneFeaturesFilterType::SizeZoneFeatureName
         InternalSizeZoneFeatureName;
       this->m_FeatureMeans->clear();
       this->m_FeatureStandardDeviations->clear();
       typename FeatureNameVector::ConstIterator fnameIt;
       for( fnameIt = this->m_RequestedFeatures->Begin();
         fnameIt != this->m_RequestedFeatures->End(); fnameIt++ )
       {
         this->m_FeatureMeans->push_back( SizeZoneMatrixCalculator->GetFeature(
           ( InternalSizeZoneFeatureName )fnameIt.Value() ) );
         this->m_FeatureStandardDeviations->push_back( 0.0 );
       }
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 0 ) );
       meanOutputObject->Set( this->m_FeatureMeans );
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 1 ) );
       standardDeviationOutputObject->Set( this->m_FeatureStandardDeviations );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetInput( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 0,
         const_cast<ImageType *>( image ) );
 
       this->m_SizeZoneMatrixGenerator->SetInput( image );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetNumberOfBinsPerAxis( unsigned int numberOfBins )
     {
       itkDebugMacro( "setting NumberOfBinsPerAxis to " << numberOfBins );
       this->m_SizeZoneMatrixGenerator->SetNumberOfBinsPerAxis( numberOfBins );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetPixelValueMinMax( PixelType min, PixelType max )
     {
       itkDebugMacro( "setting Min to " << min << "and Max to " << max );
       this->m_SizeZoneMatrixGenerator->SetPixelValueMinMax( min, max );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetDistanceValueMinMax( double min, double max )
     {
       itkDebugMacro( "setting Min to " << min << "and Max to " << max );
       this->m_SizeZoneMatrixGenerator->SetDistanceValueMinMax( min, max );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetMaskImage( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 1,
         const_cast< ImageType * >( image ) );
 
       this->m_SizeZoneMatrixGenerator->SetMaskImage( image );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const TImage *
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetInput() const
     {
       if ( this->GetNumberOfInputs() < 1 )
       {
         return ITK_NULLPTR;
       }
       return static_cast<const ImageType *>( this->ProcessObject::GetInput( 0 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const typename
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetFeatureMeansOutput() const
     {
       return itkDynamicCastInDebugMode<const FeatureValueVectorDataObjectType *>
         (this->ProcessObject::GetOutput( 0 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const typename
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetFeatureStandardDeviationsOutput() const
     {
       return itkDynamicCastInDebugMode< const FeatureValueVectorDataObjectType * >
         ( this->ProcessObject::GetOutput( 1 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const TImage *
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetMaskImage() const
     {
       if ( this->GetNumberOfInputs() < 2 )
       {
         return ITK_NULLPTR;
       }
       return static_cast< const ImageType *>( this->ProcessObject::GetInput( 1 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetInsidePixelValue( PixelType insidePixelValue )
     {
       itkDebugMacro( "setting InsidePixelValue to " << insidePixelValue );
       this->m_SizeZoneMatrixGenerator->SetInsidePixelValue( insidePixelValue );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToSizeZoneFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::PrintSelf(std::ostream & os, Indent indent) const
     {
       Superclass::PrintSelf(os, indent);
       os << indent << "RequestedFeatures: "
         << this->GetRequestedFeatures() << std::endl;
       os << indent << "FeatureStandardDeviations: "
         << this->GetFeatureStandardDeviations() << std::endl;
       os << indent << "FastCalculations: "
         << this->GetFastCalculations() << std::endl;
       os << indent << "Offsets: " << this->GetOffsets() << std::endl;
       os << indent << "FeatureMeans: " << this->GetFeatureMeans() << std::endl;
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneMatrixFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneMatrixFilter.h
index b160e4a9e8..f8dc88f691 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneMatrixFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneMatrixFilter.h
@@ -1,279 +1,279 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToSizeZoneMatrixFilter_h
 #define __itkEnhancedScalarImageToSizeZoneMatrixFilter_h
 
 #include "itkImage.h"
 #include "itkHistogram.h"
 #include "itkNumericTraits.h"
 #include "itkVectorContainer.h"
 
 namespace itk
 {
   namespace Statistics
   {
     /** \class EnhancedScalarImageToSizeZoneMatrixFilter
     *  \brief This class computes a run length matrix (histogram) from
     *  a given image and a mask image if provided. Run length matrces are
     *  used for image texture description.
     *
     * This filters creates a grey-level run length matrix from a N-D scalar
     * image. This is another possible texture description.  See the following
     * references.
     * M. M. Galloway. Texture analysis using gray level run lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * run lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level run-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
     * The basic idea is as follows:
     * Given an image and an offset (e.g. (1, -1) for a 2-d image), each element
     * in the joint histogram describes the frequency for a particular distance/
     * intensity pair within a given image.  This distance/intensity pair can be
     * described as follows: we start at a given voxel which has some intensity.
     * We then "jump" to neighboring pixels in increments provided by the offset(s)
     * as long as the pixel to which we are jumping is within the same intensity
     * bin as the original voxel.  The distance component is given by the distance
     * from the original to the final voxel satisfying our jumping criteria.
     *
     * The offset (or offsets) along which the co-occurences are calculated can be
     * set by the user. Traditionally, only one offset is used per histogram, and
     * offset components in the range [-1, 1] are used. For rotation-invariant
     * features averages of features computed over several histograms with different
     * offsets are generally used, instead of computing features from one histogram
     * create with several offsets. Additionally, instead of using offsets of two or
     * more pixels in any direction, multi-resolution techniques (e.g. image
     * pyramids) are generally used to deal with texture at different spatial
     * resolutions.
     *
     * This class calculates a 2-d histogram of all the intensity/distance pairs in
     * the given image's requested region, for a given set of offsets. That is, if
     * a given offset falls outside of the requested region (or outside the mask)
     * at a particular point, that distance/intensity pair will not be added to
     * the matrix.
     *
     * The number of histogram bins on each axis can be set (defaults to 256). Also,
     * by default the histogram min and max corresponds to the largest and smallest
     * possible pixel value of that pixel type. To customize the histogram bounds
     * for a given image, the max and min pixel values that will be placed in the
     * histogram can be set manually. NB: The min and max are INCLUSIVE.
     *
     * Further, the type of histogram frequency container used is an optional
     * template parameter. By default, a dense container is used, but for images
     * with little texture or in cases where the user wants more histogram bins,
     * a sparse container can be used for the histogram instead.
     *
     * WARNING: This probably won't work for pixels of double or long-double type
     * unless you set the histogram min and max manually. This is because the largest
     * histogram bin by default has max value of the largest possible pixel value
     * plus 1. For double and long-double types, whose "RealType" as defined by the
     * NumericTraits class is the same, and thus cannot hold any larger values,
     * this would cause a float overflow.
     *
-    * IJ article: http://hdl.handle.net/1926/1374
+    * IJ article: https://hdl.handle.net/1926/1374
     *
     * \sa ScalarImageToSizeZoneFeaturesFilter
     * \sa EnhancedScalarImageToSizeZoneMatrixFilter
     * \sa HistogramToSizeZoneFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template<typename TImageType, typename THistogramFrequencyContainer =
       DenseFrequencyContainer2>
     class EnhancedScalarImageToSizeZoneMatrixFilter : public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedScalarImageToSizeZoneMatrixFilter  Self;
       typedef ProcessObject                       Superclass;
       typedef SmartPointer<Self>                  Pointer;
       typedef SmartPointer<const Self>            ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro( EnhancedScalarImageToSizeZoneMatrixFilter, ProcessObject );
 
       /** standard New() method support */
       itkNewMacro( Self );
 
       typedef TImageType                                      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                  RegionType;
       typedef typename ImageType::SizeType                    RadiusType;
       typedef typename ImageType::OffsetType                  OffsetType;
       typedef VectorContainer<unsigned char, OffsetType>      OffsetVector;
       typedef typename OffsetVector::Pointer                  OffsetVectorPointer;
       typedef typename ImageType::PointType                   PointType;
 
       typedef typename NumericTraits<PixelType>::RealType     MeasurementType;
       typedef typename NumericTraits<PixelType>::RealType     RealType;
 
       typedef Histogram<MeasurementType, THistogramFrequencyContainer>
         HistogramType;
       typedef typename HistogramType::Pointer                 HistogramPointer;
       typedef typename HistogramType::ConstPointer            HistogramConstPointer;
       typedef typename HistogramType::MeasurementVectorType   MeasurementVectorType;
 
       /** ImageDimension constants */
       itkStaticConstMacro( ImageDimension, unsigned int,
         TImageType::ImageDimension );
 
       /** Specify the default number of bins per axis */
       itkStaticConstMacro( DefaultBinsPerAxis, unsigned int, 256 );
 
       /**
       * Set the offsets over which the intensity/distance pairs will be computed.
       * Invoking this function clears the previous offsets.
       * Note: for each individual offset in the OffsetVector, the rightmost non-zero
       * offset element must be positive. For example, in the offset list of a 2D image,
       * (1, 0) means the offset  along x-axis. (1, 0) has to be set instead
       * of (-1, 0). This is required from the iterating order of pixel iterator.
       *
       */
       itkSetObjectMacro( Offsets, OffsetVector );
 
       /**
       * Set offset over which the intensity/distance pairs will be computed.
       * Invoking this function clears the previous offset(s).
       * Note: for each individual offset, the rightmost non-zero
       * offset element must be positive. For example, in the offset list of a 2D image,
       * (1, 0) means the offset  along x-axis. (1, 0) has to be set instead
       * of (-1, 0). This is required from the iterating order of pixel iterator.
       *
       */
       void SetOffset( const OffsetType offset );
 
       /**
       * Get the current offset(s).
       */
       itkGetModifiableObjectMacro(Offsets, OffsetVector );
 
       /** Set number of histogram bins along each axis */
       itkSetMacro( NumberOfBinsPerAxis, unsigned int );
 
       /** Get number of histogram bins along each axis */
       itkGetConstMacro( NumberOfBinsPerAxis, unsigned int );
 
       /**
       * Set the min and max (inclusive) pixel value that will be used in
       * generating the histogram.
       */
       void SetPixelValueMinMax( PixelType min, PixelType max );
 
       /** Get the min pixel value defining one dimension of the joint histogram. */
       itkGetConstMacro( Min, PixelType );
 
       /** Get the max pixel value defining one dimension of the joint histogram. */
       itkGetConstMacro( Max, PixelType );
 
       /**
       * Set the min and max (inclusive) pixel value that will be used in
       * generating the histogram.
       */
       void SetDistanceValueMinMax( RealType min, RealType max );
 
       /**
       * Get the min distance value defining one dimension of the joint histogram.
       */
       itkGetConstMacro( MinDistance, RealType );
 
       /**
       * Get the max distance value defining one dimension of the joint histogram.
       */
       itkGetConstMacro( MaxDistance, RealType );
 
       /** Method to set the input image */
       using Superclass::SetInput;
       void SetInput( const ImageType *image );
 
       /** Method to get the input image */
       const ImageType * GetInput() const;
 
       /** Method to set the mask image */
       void SetMaskImage( const ImageType *image );
 
       /** Method to get the mask image */
       const ImageType * GetMaskImage() const;
 
       /** method to get the Histogram */
       const HistogramType * GetOutput() const;
 
       /**
       * Set the pixel value of the mask that should be considered "inside" the
       * object. Defaults to 1.
       */
       itkSetMacro( InsidePixelValue, PixelType );
       itkGetConstMacro( InsidePixelValue, PixelType );
 
     protected:
       EnhancedScalarImageToSizeZoneMatrixFilter();
       virtual ~EnhancedScalarImageToSizeZoneMatrixFilter() {};
       virtual void PrintSelf( std::ostream& os, Indent indent ) const ITK_OVERRIDE;
 
       /** Standard itk::ProcessObject subclass method. */
       typedef DataObject::Pointer DataObjectPointer;
 
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       virtual DataObjectPointer MakeOutput( DataObjectPointerArraySizeType idx ) ITK_OVERRIDE;
 
       /** This method causes the filter to generate its output. */
       virtual void GenerateData() ITK_OVERRIDE;
 
     private:
 
       unsigned int             m_NumberOfBinsPerAxis;
       PixelType                m_Min;
       PixelType                m_Max;
       RealType                 m_MinDistance;
       RealType                 m_MaxDistance;
       PixelType                m_InsidePixelValue;
 
       MeasurementVectorType    m_LowerBound;
       MeasurementVectorType    m_UpperBound;
       OffsetVectorPointer      m_Offsets;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedScalarImageToSizeZoneMatrixFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneMatrixFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneMatrixFilter.hxx
index 7113889382..80ecac0cd5 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneMatrixFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToSizeZoneMatrixFilter.hxx
@@ -1,405 +1,405 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToSizeZoneMatrixFilter_hxx
 #define __itkEnhancedScalarImageToSizeZoneMatrixFilter_hxx
 
 #include "itkEnhancedScalarImageToSizeZoneMatrixFilter.h"
 
 #include "itkConstNeighborhoodIterator.h"
 #include "itkNeighborhood.h"
 #include "vnl/vnl_math.h"
 #include "itkMacro.h"
 #include "itkRescaleIntensityImageFilter.h"
 #include "itkMaskImageFilter.h"
 #include "itkLabelStatisticsImageFilter.h"
 #include "itkScalarConnectedComponentImageFilter.h"
 #include "itkRelabelComponentImageFilter.h"
 #include "itkCastImageFilter.h"
 
 #include <mitkLogMacros.h>
 
 namespace itk
 {
 namespace Statistics
 {
 template<typename TImageType, typename THistogramFrequencyContainer>
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::EnhancedScalarImageToSizeZoneMatrixFilter() :
   m_NumberOfBinsPerAxis( itkGetStaticConstMacro( DefaultBinsPerAxis ) ),
   m_Min( NumericTraits<PixelType>::NonpositiveMin() ),
   m_Max( NumericTraits<PixelType>::max() ),
   m_MinDistance( NumericTraits<RealType>::ZeroValue() ),
   m_MaxDistance( NumericTraits<RealType>::max() ),
   m_InsidePixelValue( NumericTraits<PixelType>::OneValue() )
 {
   this->SetNumberOfRequiredInputs( 1 );
   this->SetNumberOfRequiredOutputs( 1 );
 
   const unsigned int measurementVectorSize = 2;
 
   this->ProcessObject::SetNthOutput( 0, this->MakeOutput( 0 ) );
   HistogramType *output = const_cast<HistogramType *>( this->GetOutput() );
   output->SetMeasurementVectorSize( measurementVectorSize );
 
   this->m_LowerBound.SetSize( measurementVectorSize );
   this->m_UpperBound.SetSize( measurementVectorSize );
 
   this->m_LowerBound[0] = this->m_Min;
   this->m_LowerBound[1] = this->m_MinDistance;
   this->m_UpperBound[0] = this->m_Max;
   this->m_UpperBound[1] = this->m_MaxDistance;
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetOffset( const OffsetType offset )
 {
   OffsetVectorPointer offsetVector = OffsetVector::New();
   offsetVector->push_back( offset );
   this->SetOffsets( offsetVector );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetInput( const ImageType *image )
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 0, const_cast<ImageType *>( image ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetMaskImage( const ImageType *image )
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 1, const_cast<ImageType *>( image ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 const TImageType *
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetInput() const
 {
   if( this->GetNumberOfInputs() < 1 )
   {
     return ITK_NULLPTR;
   }
   return static_cast<const ImageType *>( this->ProcessObject::GetInput( 0 ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 const TImageType *
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetMaskImage() const
 {
   if( this->GetNumberOfInputs() < 2 )
   {
     return ITK_NULLPTR;
   }
   return static_cast<const ImageType *>( this->ProcessObject::GetInput( 1 ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 const typename EnhancedScalarImageToSizeZoneMatrixFilter<TImageType,
 THistogramFrequencyContainer >::HistogramType *
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetOutput() const
 {
   const HistogramType *output =
       static_cast<const HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
   return output;
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 typename EnhancedScalarImageToSizeZoneMatrixFilter<TImageType,
 THistogramFrequencyContainer>::DataObjectPointer
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
 {
   return HistogramType::New().GetPointer();
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GenerateData()
 {
   HistogramType *output =
       static_cast<HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
 
   const ImageType * inputImage = this->GetInput();
   const ImageType * maskImage = this->GetMaskImage();
 
   // First, create an appropriate histogram with the right number of bins
   // and mins and maxes correct for the image type.
   typename HistogramType::SizeType size( output->GetMeasurementVectorSize() );
 
   size.Fill( this->m_NumberOfBinsPerAxis );
   this->m_LowerBound[0] = this->m_Min;
   this->m_LowerBound[1] = this->m_MinDistance;
   this->m_UpperBound[0] = this->m_Max;
   this->m_UpperBound[1] = this->m_MaxDistance;
 
   output->Initialize( size, this->m_LowerBound, this->m_UpperBound );
 
   MeasurementVectorType run( output->GetMeasurementVectorSize() );
   typename HistogramType::IndexType hIndex;
 
   //Cast the image to a float image - with no respect to the incoming image
   //to prevent some non-templated itk issues
   typedef itk::Image<float, 3> FloatImageType;
   typedef itk::CastImageFilter<ImageType, FloatImageType> CastFilterType;
 
   typename CastFilterType::Pointer caster = CastFilterType::New();
   caster->SetInput(inputImage);
   caster->Update();
   typename FloatImageType::Pointer floatImage = caster->GetOutput();
 
   //MITK_WARN << "InputImage casted.";
 
   //Cast the mask to an unsigned short image - with no respect to the incomimg maskimage
   //to prevent some non-templated itk issues
   typedef unsigned short                 LabelPixelType;
   typedef itk::Image<LabelPixelType, 3 > LabelImageType;
 
   typedef itk::CastImageFilter<ImageType, LabelImageType> MaskCastFilterType;
   typename MaskCastFilterType::Pointer maskCaster = MaskCastFilterType::New();
   maskCaster->SetInput(maskImage);
   maskCaster->Update();
 
   //MITK_WARN << "MaskImage casted.";
 
   //Set all values out of the mask to (m_Min + m_Max) / 2.
   typedef itk::MaskImageFilter< FloatImageType, LabelImageType, FloatImageType > MaskFilterType;
   typename MaskFilterType::Pointer maskFilter = MaskFilterType::New();
   maskFilter->SetInput(floatImage);
   maskFilter->SetMaskImage(maskCaster->GetOutput());
   maskFilter->SetOutsideValue((m_Max + m_Min) / 2);
   maskFilter->Update();
 
   //MITK_WARN << "InputImage masked.";
 
   //Rescale intensity to match the size of the histogram
   typedef itk::Image< unsigned int, 3 >     OutputImageType;
 
   typedef itk::RescaleIntensityImageFilter< FloatImageType,OutputImageType> RescalerType;
   typename RescalerType::Pointer rescaler = RescalerType::New();
   //We use 0 for nans, all valid numbers will be 1 < x < size
   rescaler->SetOutputMinimum(  1  );
   rescaler->SetOutputMaximum( size[0] );
   rescaler->SetInput(maskFilter->GetOutput());
   rescaler->Update();
 
   typename OutputImageType::Pointer rescaled = rescaler->GetOutput();
 
   //MITK_WARN << "Intensities rescaled.";
 
   //Write back the nans because they get lost during rescaling
 
   int xx = inputImage->GetLargestPossibleRegion().GetSize()[0];
   int yy = inputImage->GetLargestPossibleRegion().GetSize()[1];
   int zz = inputImage->GetLargestPossibleRegion().GetSize()[2];
 
   for (int x = 0; x < xx; x++)
   {
     for (int y = 0; y < yy; y++)
     {
       for (int z = 0; z < zz; z++)
       {
         FloatImageType::IndexType indexF;
         indexF[0] = x;
         indexF[1] = y;
         indexF[2] = z;
 
         OutputImageType::IndexType indexO;
         indexO[0] = x;
         indexO[1] = y;
         indexO[2] = z;
 
         //Is Pixel NaN?
         if(floatImage->GetPixel(indexF) != floatImage->GetPixel(indexF))
         {
           rescaled->SetPixel(indexO,0);
         }
       }
     }
   }
   //All nans are now 0, the valid values are within [1,numberOfBins]
 
   /*
   OutputImageType::IndexType indexO;
   indexO[0] = 0;
   indexO[1] = 2;
   indexO[2] = 1;
   MITK_WARN << "is 0: " << rescaled->GetPixel(indexO);
   indexO[0] = 0;
   indexO[1] = 0;
   indexO[2] = 0;
   MITK_WARN << "is 1: " << rescaled->GetPixel(indexO);
   */
 
   PixelType distanceThreshold = 1 - mitk::eps;
 
 
   //Calculate the connected components
   typedef itk::ScalarConnectedComponentImageFilter <OutputImageType, OutputImageType, LabelImageType >
       ConnectedComponentImageFilterType;
 
   typename ConnectedComponentImageFilterType::Pointer connected = ConnectedComponentImageFilterType::New ();
   connected->SetInput(rescaled);
   connected->SetMaskImage(maskCaster->GetOutput());
   connected->SetDistanceThreshold(distanceThreshold);
   connected->Update();
 
   /*
   indexO[0] = 0;
   indexO[1] = 2;
   indexO[2] = 1;
   MITK_WARN << "is 0: " << (connected->GetOutput())->GetPixel(indexO);
   indexO[0] = 0;
   indexO[1] = 0;
   indexO[2] = 0;
   MITK_WARN << "is 1: " << (connected->GetOutput())->GetPixel(indexO);
 
   MITK_WARN << "Connected components calculated.";
   */
 
   //Relabel the components
   typedef itk::RelabelComponentImageFilter <OutputImageType, OutputImageType > RelabelFilterType;
   typename RelabelFilterType::Pointer relabel = RelabelFilterType::New();
 
   typename RelabelFilterType::ObjectSizeType minSize = 1;
 
   relabel->SetInput(connected->GetOutput());
   relabel->SetMinimumObjectSize(minSize);
   relabel->Update();
 
   //MITK_WARN << "Components relabeled.";
 
   //Get the stats of the componentes
   typedef itk::LabelStatisticsImageFilter< FloatImageType, OutputImageType> LabelStatisticsImageFilterType;
   typename LabelStatisticsImageFilterType::Pointer labelStatisticsImageFilter =
       LabelStatisticsImageFilterType::New();
   labelStatisticsImageFilter->SetLabelInput( relabel->GetOutput() );
   labelStatisticsImageFilter->SetInput(floatImage);
   labelStatisticsImageFilter->UseHistogramsOn(); // needed to compute median
   labelStatisticsImageFilter->Update();
 
   /*
   std::cout << "Number of labels: "
             << labelStatisticsImageFilter->GetNumberOfLabels() << std::endl;
   std::cout << std::endl;
   */
   typedef typename LabelStatisticsImageFilterType::ValidLabelValuesContainerType ValidLabelValuesType;
 
   for(typename ValidLabelValuesType::const_iterator vIt = labelStatisticsImageFilter->GetValidLabelValues().begin();
       vIt != labelStatisticsImageFilter->GetValidLabelValues().end();
       ++vIt)
   {
     if ( labelStatisticsImageFilter->HasLabel(*vIt) )
     {
       LabelPixelType labelValue = *vIt;
 
       run[0] = labelStatisticsImageFilter->GetMean( labelValue );
       run[1] = labelStatisticsImageFilter->GetCount( labelValue );
 
       //Check for NaN and inf
       if(run[0] == run[0] && !std::isinf(std::abs(run[0])))
       {
         output->GetIndex( run, hIndex );
         output->IncreaseFrequencyOfIndex( hIndex, 1 );
 
         /*
         MITK_INFO << "Adding a region:";
         MITK_INFO << "\tmin: "
                   << labelStatisticsImageFilter->GetMinimum( labelValue );
         MITK_INFO << "\tmax: "
                   << labelStatisticsImageFilter->GetMaximum( labelValue );
         MITK_INFO << "\tmean: "
                   << labelStatisticsImageFilter->GetMean( labelValue );
         MITK_INFO << "\tcount: "
                   << labelStatisticsImageFilter->GetCount( labelValue );
         */
       }
     }
   }
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetPixelValueMinMax( PixelType min, PixelType max )
 {
   if( this->m_Min != min || this->m_Max != max )
   {
     itkDebugMacro( "setting Min to " << min << "and Max to " << max );
     this->m_Min = min;
     this->m_Max = max;
     this->Modified();
   }
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetDistanceValueMinMax( RealType min, RealType max )
 {
   if( this->m_MinDistance != min || this->m_MaxDistance != max )
   {
     itkDebugMacro( "setting MinDistance to " << min << "and MaxDistance to "
                    << max );
     this->m_MinDistance = min;
     this->m_MaxDistance = max;
     this->Modified();
   }
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToSizeZoneMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::PrintSelf( std::ostream& os, Indent indent ) const
 {
   Superclass::PrintSelf( os,indent );
   os << indent << "Offsets: " << this->GetOffsets() << std::endl;
   os << indent << "Min: " << this->m_Min << std::endl;
   os << indent << "Max: " << this->m_Max << std::endl;
   os << indent << "Min distance: " << this->m_MinDistance << std::endl;
   os << indent << "Max distance: " << this->m_MaxDistance << std::endl;
   os << indent << "NumberOfBinsPerAxis: " << this->m_NumberOfBinsPerAxis
      << std::endl;
   os << indent << "InsidePixelValue: " << this->m_InsidePixelValue << std::endl;
 }
 } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToTextureFeaturesFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToTextureFeaturesFilter.h
index f42ddf4fa7..a3383d9723 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToTextureFeaturesFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToTextureFeaturesFilter.h
@@ -1,245 +1,245 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToTextureFeaturesFilter_h
 #define __itkEnhancedScalarImageToTextureFeaturesFilter_h
 
 #include "itkDataObjectDecorator.h"
 
 #include "itkEnhancedHistogramToTextureFeaturesFilter.h"
 #include "itkScalarImageToCooccurrenceMatrixFilter.h"
 
 namespace itk
 {
   namespace Statistics
   {
     /** \class EnhancedScalarImageToTextureFeaturesFilter
     *  \brief This class computes texture descriptions from an image.
     *
     * This class computes features that summarize the texture of a given image.
     * The texture features are computed a la Haralick, and have proven to be useful
     * in image classification for biological and medical imaging.
     * This class computes the texture features of an image (optionally in a
     * masked region), averaged across several spatial directions so that they are
     * invariant to rotation.
     *
     * By default, texure features are computed for each spatial
     * direction and then averaged afterward, so it is possible to access the standard
     * deviations of the texture features. These values give a clue as to texture
     * anisotropy. However, doing this is much more work, because it involved computing
     * one GLCM for each offset given. To compute a single GLCM using the first offset ,
     * call FastCalculationsOn(). If this is called, then the texture standard deviations
     * will not be computed (and will be set to zero), but texture computation will
     * be much faster.
     *
     * This class is templated over the input image type.
     *
     * Template Parameters:
     * The image type, and the type of histogram frequency container. If you are using
     * a large number of bins per axis, a sparse frequency container may be advisable.
     * The default is to use a dense frequency container.
     *
     * Inputs and parameters:
     * -# An image
     * -# A mask defining the region over which texture features will be
     *    calculated. (Optional)
     * -# The pixel value that defines the "inside" of the mask. (Optional, defaults
     *    to 1 if a mask is set.)
     * -# The set of features to be calculated. These features are defined
     *    in the GreyLevelCooccurrenceMatrixTextureCoefficientsCalculator class. (Optional,
     *    defaults to {Energy, Entropy, InverseDifferenceMoment, Inertia, ClusterShade,
     *    ClusterProminence}, as in Conners, Trivedi and Harlow.)
     * -# The number of intensity bins. (Optional, defaults to 256.)
     * -# The set of directions (offsets) to average across. (Optional, defaults to
     *    {(-1, 0), (-1, -1), (0, -1), (1, -1)} for 2D images and scales analogously for ND
     *    images.)
     * -# The pixel intensity range over which the features will be calculated.
     *    (Optional, defaults to the full dynamic range of the pixel type.)
     *
     * In general, the default parameter values should be sufficient.
     *
     * Outputs:
     * (1) The average value of each feature.
     * (2) The standard deviation in the values of each feature.
     *
     * Web reference:
-    * http://www.fp.ucalgary.ca/mhallbey/tutorial.htm
+    * https://prism.ucalgary.ca/handle/1880/51900
     *
     * 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.
     *
     * Haralick, R.M. 1979. Statistical and Structural Approaches to Texture.
     * Proceedings of the IEEE, 67:786-804.
     *
     * R.W. Conners and C.A. Harlow. A Theoretical Comaprison of Texture Algorithms.
     * IEEE Transactions on Pattern Analysis and Machine Intelligence,  2:204-222, 1980.
     *
     * R.W. Conners, M.M. Trivedi, and C.A. Harlow. Segmentation of a High-Resolution
     * Urban Scene using Texture  Operators. Computer Vision, Graphics and Image
     * Processing, 25:273-310,  1984.
     *
     * \sa ScalarImageToCooccurrenceMatrixFilter
     * \sa HistogramToTextureFeaturesFilter
     *
     * Author: Zachary Pincus
     * \ingroup ITKStatistics
     */
 
     template< typename TImageType,
       typename THistogramFrequencyContainer = DenseFrequencyContainer2 >
     class EnhancedScalarImageToTextureFeaturesFilter:public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedScalarImageToTextureFeaturesFilter Self;
       typedef ProcessObject                      Superclass;
       typedef SmartPointer< Self >               Pointer;
       typedef SmartPointer< const Self >         ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro(EnhancedScalarImageToTextureFeaturesFilter, ProcessObject);
 
       /** standard New() method support */
       itkNewMacro(Self);
 
       typedef THistogramFrequencyContainer FrequencyContainerType;
       typedef TImageType                   ImageType;
       typedef typename ImageType::Pointer  ImagePointer;
 
       typedef typename ImageType::PixelType                PixelType;
       typedef typename ImageType::OffsetType               OffsetType;
       typedef VectorContainer< unsigned char, OffsetType > OffsetVector;
       typedef typename OffsetVector::Pointer               OffsetVectorPointer;
       typedef typename OffsetVector::ConstPointer          OffsetVectorConstPointer;
 
       typedef ScalarImageToCooccurrenceMatrixFilter<
         ImageType, FrequencyContainerType >               CooccurrenceMatrixFilterType;
 
       typedef typename CooccurrenceMatrixFilterType::HistogramType HistogramType;
       typedef EnhancedHistogramToTextureFeaturesFilter< HistogramType >    TextureFeaturesFilterType;
 
       typedef short                                                  TextureFeatureName;
       typedef VectorContainer< unsigned char, TextureFeatureName >   FeatureNameVector;
 
       typedef typename FeatureNameVector::Pointer      FeatureNameVectorPointer;
       typedef typename FeatureNameVector::ConstPointer FeatureNameVectorConstPointer;
       typedef VectorContainer< unsigned char, double > FeatureValueVector;
       typedef typename FeatureValueVector::Pointer     FeatureValueVectorPointer;
 
       /** Smart Pointer type to a DataObject. */
       typedef DataObject::Pointer DataObjectPointer;
 
       /** Type of DataObjects used for scalar outputs */
       typedef DataObjectDecorator< FeatureValueVector >
         FeatureValueVectorDataObjectType;
 
       const FeatureValueVectorDataObjectType * GetFeatureMeansOutput() const;
 
       const FeatureValueVectorDataObjectType * GetFeatureStandardDeviationsOutput() const;
 
       /** Connects the input image for which the features are going to be computed
       */
       using Superclass::SetInput;
       void SetInput(const ImageType *);
 
       const ImageType * GetInput() const;
 
       /** Return the feature means and deviations.  */
       itkGetConstReferenceObjectMacro(FeatureMeans, FeatureValueVector);
       itkGetConstReferenceObjectMacro(FeatureStandardDeviations, FeatureValueVector);
 
       /** Set the desired feature set. Optional, for default value see above. */
       itkSetConstObjectMacro(RequestedFeatures, FeatureNameVector);
       itkGetConstObjectMacro(RequestedFeatures, FeatureNameVector);
 
       /** Set the  offsets over which the co-occurrence pairs will be computed.
       Optional; for default value see above. */
       itkSetConstObjectMacro(Offsets, OffsetVector);
       itkGetConstObjectMacro(Offsets, OffsetVector);
 
       /** Set number of histogram bins along each axis.
       Optional; for default value see above. */
       void SetNumberOfBinsPerAxis(unsigned int);
 
       /** Set the min and max (inclusive) pixel value that will be used for
       feature calculations. Optional; for default value see above. */
       void SetPixelValueMinMax(PixelType min, PixelType max);
 
       /** Connects the mask image for which the histogram is going to be computed.
       Optional; for default value see above. */
       void SetMaskImage(const ImageType *);
 
       const ImageType * GetMaskImage() const;
 
       /** Set the pixel value of the mask that should be considered "inside" the
       object. Optional; for default value see above. */
       void SetInsidePixelValue(PixelType InsidePixelValue);
 
       itkGetConstMacro(FastCalculations, bool);
       itkSetMacro(FastCalculations, bool);
       itkBooleanMacro(FastCalculations);
 
     protected:
       EnhancedScalarImageToTextureFeaturesFilter();
       ~EnhancedScalarImageToTextureFeaturesFilter() override {}
       void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
 
       void FastCompute();
 
       void FullCompute();
 
       /** This method causes the filter to generate its output. */
       void GenerateData() ITK_OVERRIDE;
 
       /** Make a DataObject to be used for output output. */
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       DataObjectPointer MakeOutput(DataObjectPointerArraySizeType) ITK_OVERRIDE;
 
     private:
       typename CooccurrenceMatrixFilterType::Pointer m_GLCMGenerator;
 
       typename TextureFeaturesFilterType::Pointer    m_GLCMCalculator;
 
       FeatureValueVectorPointer     m_FeatureMeans;
       FeatureValueVectorPointer     m_FeatureStandardDeviations;
       FeatureNameVectorConstPointer m_RequestedFeatures;
       OffsetVectorConstPointer      m_Offsets;
       bool                          m_FastCalculations;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedScalarImageToTextureFeaturesFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToTextureFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToTextureFeaturesFilter.hxx
index 889a55ebdf..b082a2da7f 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToTextureFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToTextureFeaturesFilter.hxx
@@ -1,341 +1,341 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 *
 *  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
+*         https://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 __itkEnhancedScalarImageToTextureFeaturesFilter_hxx
 #define __itkEnhancedScalarImageToTextureFeaturesFilter_hxx
 
 #include "itkEnhancedScalarImageToTextureFeaturesFilter.h"
 #include "itkNeighborhood.h"
 #include "vnl/vnl_math.h"
 
 namespace itk
 {
   namespace Statistics
   {
     template< typename TImage, typename THistogramFrequencyContainer >
     EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::EnhancedScalarImageToTextureFeaturesFilter()
     {
       this->SetNumberOfRequiredInputs(1);
       this->SetNumberOfRequiredOutputs(1);
 
       for ( int i = 0; i < 2; ++i )
       {
         this->ProcessObject::SetNthOutput( i, this->MakeOutput(i) );
       }
 
       this->m_GLCMGenerator = CooccurrenceMatrixFilterType::New();
       this->m_GLCMCalculator = TextureFeaturesFilterType::New();
       this->m_GLCMCalculator->SetInput( this->m_GLCMGenerator->GetOutput() );
       this->m_FeatureMeans = FeatureValueVector::New();
       this->m_FeatureStandardDeviations = FeatureValueVector::New();
 
       // Set the requested features to the default value:
       // {Energy, Entropy, InverseDifferenceMoment, Inertia, ClusterShade,
       // ClusterProminence}
       FeatureNameVectorPointer requestedFeatures = FeatureNameVector::New();
       // can't directly set m_RequestedFeatures since it is const!
       requestedFeatures->push_back(TextureFeaturesFilterType::Energy);
       requestedFeatures->push_back(TextureFeaturesFilterType::Entropy);
       requestedFeatures->push_back(TextureFeaturesFilterType::InverseDifferenceMoment);
       requestedFeatures->push_back(TextureFeaturesFilterType::Inertia);
       requestedFeatures->push_back(TextureFeaturesFilterType::ClusterShade);
       requestedFeatures->push_back(TextureFeaturesFilterType::ClusterProminence);
       this->SetRequestedFeatures(requestedFeatures);
 
       // 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 Neighborhood< typename ImageType::PixelType, ImageType::ImageDimension > 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();
       OffsetType          offset;
       OffsetVectorPointer offsets = OffsetVector::New();
       for ( unsigned int d = 0; d < centerIndex; d++ )
       {
         offset = hood.GetOffset(d);
         offsets->push_back(offset);
       }
       this->SetOffsets(offsets);
       m_FastCalculations = false;
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     typename
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::DataObjectPointer
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed(idx) )
     {
       return FeatureValueVectorDataObjectType::New().GetPointer();
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     void
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::GenerateData(void)
     {
       if ( m_FastCalculations )
       {
         this->FastCompute();
       }
       else
       {
         this->FullCompute();
       }
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     void
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::FullCompute(void)
     {
       int      numOffsets = m_Offsets->size();
       int      numFeatures = m_RequestedFeatures->size();
       double **features;
 
       features = new double *[numOffsets];
       for ( int i = 0; i < numOffsets; i++ )
       {
         features[i] = new double[numFeatures];
       }
 
       // For each offset, calculate each feature
       typename OffsetVector::ConstIterator offsetIt;
       int offsetNum, featureNum;
       typedef typename TextureFeaturesFilterType::TextureFeatureName InternalTextureFeatureName;
 
       for ( offsetIt = m_Offsets->Begin(), offsetNum = 0;
         offsetIt != m_Offsets->End(); offsetIt++, offsetNum++ )
       {
         this->m_GLCMGenerator->SetOffset( offsetIt.Value() );
         this->m_GLCMCalculator->Update();
 
         typename FeatureNameVector::ConstIterator fnameIt;
         for ( fnameIt = m_RequestedFeatures->Begin(), featureNum = 0;
           fnameIt != m_RequestedFeatures->End(); fnameIt++, featureNum++ )
         {
           features[offsetNum][featureNum] = this->m_GLCMCalculator->GetFeature( (InternalTextureFeatureName)fnameIt.Value() );
         }
       }
 
       // Now get the mean and deviaton of each feature across the offsets.
       m_FeatureMeans->clear();
       m_FeatureStandardDeviations->clear();
       double *tempFeatureMeans = new double[numFeatures];
       double *tempFeatureDevs = new double[numFeatures];
 
       /*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 = std::sqrt(S(n) / n) (or divide by n-1 for sample SD instead of
       population SD).
       */
 
       // Set up the initial conditions (k = 1)
       for ( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         tempFeatureMeans[featureNum] = features[0][featureNum];
         tempFeatureDevs[featureNum] = 0;
       }
       // Run through the recurrence (k = 2 ... N)
       for ( offsetNum = 1; offsetNum < numOffsets; offsetNum++ )
       {
         int k = offsetNum + 1;
         for ( featureNum = 0; featureNum < numFeatures; featureNum++ )
         {
           double M_k_minus_1 = tempFeatureMeans[featureNum];
           double S_k_minus_1 = tempFeatureDevs[featureNum];
           double x_k = features[offsetNum][featureNum];
 
           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 );
 
           tempFeatureMeans[featureNum] = M_k;
           tempFeatureDevs[featureNum] = S_k;
         }
       }
       for ( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         tempFeatureDevs[featureNum] = std::sqrt(tempFeatureDevs[featureNum] / numOffsets);
 
         m_FeatureMeans->push_back(tempFeatureMeans[featureNum]);
         m_FeatureStandardDeviations->push_back(tempFeatureDevs[featureNum]);
       }
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode< FeatureValueVectorDataObjectType * >( this->ProcessObject::GetOutput(0) );
       meanOutputObject->Set(m_FeatureMeans);
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode< FeatureValueVectorDataObjectType * >( this->ProcessObject::GetOutput(1) );
       standardDeviationOutputObject->Set(m_FeatureStandardDeviations);
 
       delete[] tempFeatureMeans;
       delete[] tempFeatureDevs;
       for ( int i = 0; i < numOffsets; i++ )
       {
         delete[] features[i];
       }
       delete[] features;
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     void
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::FastCompute(void)
     {
       // Compute the feature for the first offset
       typename OffsetVector::ConstIterator offsetIt = m_Offsets->Begin();
       this->m_GLCMGenerator->SetOffset( offsetIt.Value() );
       this->m_GLCMCalculator->Update();
 
       typedef typename TextureFeaturesFilterType::TextureFeatureName InternalTextureFeatureName;
       m_FeatureMeans->clear();
       m_FeatureStandardDeviations->clear();
       typename FeatureNameVector::ConstIterator fnameIt;
       for ( fnameIt = m_RequestedFeatures->Begin();
         fnameIt != m_RequestedFeatures->End(); fnameIt++ )
       {
         m_FeatureMeans->push_back( this->m_GLCMCalculator->GetFeature( (InternalTextureFeatureName)fnameIt.Value() ) );
         m_FeatureStandardDeviations->push_back(0.0);
       }
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode< FeatureValueVectorDataObjectType * >( this->ProcessObject::GetOutput(0) );
       meanOutputObject->Set(m_FeatureMeans);
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode< FeatureValueVectorDataObjectType * >( this->ProcessObject::GetOutput(1) );
       standardDeviationOutputObject->Set(m_FeatureStandardDeviations);
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     void
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::SetInput(const ImageType *image)
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 0,
         const_cast< ImageType * >( image ) );
 
       m_GLCMGenerator->SetInput(image);
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     void
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::SetNumberOfBinsPerAxis(
       unsigned int numberOfBins)
     {
       itkDebugMacro("setting NumberOfBinsPerAxis to " << numberOfBins);
       m_GLCMGenerator->SetNumberOfBinsPerAxis(numberOfBins);
       this->Modified();
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     void
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::SetPixelValueMinMax(PixelType min,
       PixelType max)
     {
       itkDebugMacro("setting Min to " << min << "and Max to " << max);
       m_GLCMGenerator->SetPixelValueMinMax(min, max);
       this->Modified();
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     void
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::SetMaskImage(const ImageType *image)
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 1,
         const_cast< ImageType * >( image ) );
 
       m_GLCMGenerator->SetMaskImage(image);
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     const TImage *
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >
       ::GetInput() const
     {
       return itkDynamicCastInDebugMode< const ImageType * >( this->GetPrimaryInput() );
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     const typename
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::GetFeatureMeansOutput() const
     {
       return itkDynamicCastInDebugMode< const FeatureValueVectorDataObjectType * >( this->ProcessObject::GetOutput(0) );
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     const typename
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >
       ::GetFeatureStandardDeviationsOutput() const
     {
       return itkDynamicCastInDebugMode< const FeatureValueVectorDataObjectType * >( this->ProcessObject::GetOutput(1) );
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     const TImage *
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >
       ::GetMaskImage() const
     {
       return static_cast< const ImageType * >( this->ProcessObject::GetInput(1) );
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     void
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::SetInsidePixelValue(
       PixelType insidePixelValue)
     {
       itkDebugMacro("setting InsidePixelValue to " << insidePixelValue);
       m_GLCMGenerator->SetInsidePixelValue(insidePixelValue);
       this->Modified();
     }
 
     template< typename TImage, typename THistogramFrequencyContainer >
     void
       EnhancedScalarImageToTextureFeaturesFilter< TImage, THistogramFrequencyContainer >::PrintSelf(std::ostream & os,
       Indent indent) const
     {
       Superclass::PrintSelf(os, indent);
       os << indent << "RequestedFeatures: " << this->GetRequestedFeatures() << std::endl;
       os << indent << "FeatureStandardDeviations: " << this->GetFeatureStandardDeviations() << std::endl;
       os << indent << "FastCalculations: " << this->GetFastCalculations() << std::endl;
       os << indent << "Offsets: " << this->GetOffsets() << std::endl;
       os << indent << "FeatureMeans: " << this->GetFeatureMeans() << std::endl;
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/src/mitkCLResultXMLWriter.cpp b/Modules/Classification/CLUtilities/src/mitkCLResultXMLWriter.cpp
index c884a41381..500ff88d23 100644
--- a/Modules/Classification/CLUtilities/src/mitkCLResultXMLWriter.cpp
+++ b/Modules/Classification/CLUtilities/src/mitkCLResultXMLWriter.cpp
@@ -1,321 +1,321 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkCLResultXMLWriter.h>
 
 #include <iostream>
 #include <locale>
 #include <iomanip>
 #include <ctime>
 #include <sstream>
 
 #include <mitkDICOMTagPath.h>
 #include <mitkDICOMProperty.h>
 #include <mitkLocaleSwitch.h>
 #include <mitkIOMetaInformationPropertyConstants.h>
 #include <mitkDICOMIOMetaInformationPropertyConstants.h>
 
 #include <tinyxml2.h>
 
 template <class charT>
 class punct_facet : public std::numpunct<charT> {
 public:
   punct_facet(charT sep) :
     m_Sep(sep)
   {
 
   }
 protected:
   charT do_decimal_point() const override { return m_Sep; }
 private:
   charT m_Sep;
 };
 
 void AddPropertyAsNode(const mitk::Image* image, const std::string& key, const std::string& tag, tinyxml2::XMLElement* rootNode)
 {
   auto prop = image->GetProperty(key.c_str());
   if (prop.IsNotNull())
   {
     auto* doc = rootNode->GetDocument();
     auto propNode = doc->NewElement(tag.c_str());
     auto* valueText = doc->NewText(prop->GetValueAsString().c_str());
     propNode->InsertEndChild(valueText);
 
     rootNode->InsertEndChild(propNode);
   }
 }
 
 void AddSeriesInstanceUID(const mitk::Image* image, tinyxml2::XMLElement* xmlNode)
 {
   AddPropertyAsNode(image, mitk::DICOMTagPathToPropertyName(mitk::DICOMTagPath(0x0020, 0x000e)), "mp:seriesInstanceUID", xmlNode);
 }
 
 void AddFilePath(const mitk::Image* image, tinyxml2::XMLElement* xmlNode)
 {
   AddPropertyAsNode(image, mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_INPUTLOCATION()), "mp:filePath", xmlNode);
 }
 
 void AddSOPInstanceUIDs(const mitk::Image* image, tinyxml2::XMLElement* xmlNode)
 {
   auto prop = image->GetProperty(mitk::DICOMTagPathToPropertyName(mitk::DICOMTagPath(0x0008, 0x0018)).c_str());
   auto dicomProp = dynamic_cast<const mitk::DICOMProperty*>(prop.GetPointer());
   auto* doc = xmlNode->GetDocument();
   if (dicomProp != nullptr)
   {
     auto* instanceUIDsNode = doc->NewElement("mp:sopInstanceUIDs");
     xmlNode->InsertEndChild(instanceUIDsNode);
 
     if (dicomProp->IsUniform())
     {
       auto* instanceUIDNode = doc->NewElement("mp:sopInstanceUID");
       auto* valueText = doc->NewText(dicomProp->GetValueAsString().c_str());
       instanceUIDNode->InsertEndChild(valueText);
       instanceUIDsNode->InsertEndChild(instanceUIDNode);
     }
     else
     {
       const auto timeSteps = dicomProp->GetAvailableTimeSteps();
       for (auto timeStep : timeSteps)
       {
         const auto slices = dicomProp->GetAvailableSlices(timeStep);
         for (auto slice : slices)
         {
           auto instanceUIDNode = doc->NewElement("mp:sopInstanceUID");
           instanceUIDNode->SetAttribute("z", static_cast<int>(slice));
           instanceUIDNode->SetAttribute("t", static_cast<int>(timeStep));
           auto* valueText = doc->NewText(dicomProp->GetValue(timeStep, slice).c_str());
           instanceUIDNode->InsertEndChild(valueText);
           instanceUIDsNode->InsertEndChild(instanceUIDNode);
         }
       }
     }
   }
 }
 
 void AddDateAndTime(tinyxml2::XMLElement* rootNode)
 {
   auto* doc = rootNode->GetDocument();
   auto* dateNode = doc->NewElement("mp:generationDate");
   auto time = std::time(nullptr);
   std::ostringstream sstream;
   sstream << std::put_time(std::localtime(&time), "%Y%m%d");
   auto* valueText = doc->NewText(sstream.str().c_str());
   dateNode->InsertEndChild(valueText);
 
   rootNode->InsertEndChild(dateNode);
 
   auto* timeNode = doc->NewElement("mp:generationTime");
   std::ostringstream timestream;
   timestream << std::put_time(std::localtime(&time), "%H%M%S");
   valueText = doc->NewText(timestream.str().c_str());
   timeNode->InsertEndChild(valueText);
 
   rootNode->InsertEndChild(timeNode);
 }
 
 void AddParameters(const std::map<std::string, us::Any>& parameters, tinyxml2::XMLElement* paramsNode)
 {
   auto* doc = paramsNode->GetDocument();
   for (const auto& param : parameters)
   {
     mitk::LocaleSwitch lswitch("C");
     auto paramNode = doc->NewElement("mp:parameter");
     paramNode->SetAttribute("name", param.first.c_str());
     auto* valueText = doc->NewText(param.second.ToString().c_str());
     paramNode->InsertEndChild(valueText);
     paramsNode->InsertEndChild(paramNode);
   }
 }
 
 void AddFeatures(const mitk::AbstractGlobalImageFeature::FeatureListType& features, tinyxml2::XMLElement* featsNode)
 {
   auto* doc = featsNode->GetDocument();
   for (const auto& feat : features)
   {
     auto featNode = doc->NewElement("mp:feature");
     featNode->SetAttribute("name", feat.first.name.c_str());
     featNode->SetAttribute("version", feat.first.version.c_str());
     featNode->SetAttribute("class", feat.first.featureClass.c_str());
     featNode->SetAttribute("setting", feat.first.settingID.c_str());
     std::ostringstream sstream;
     sstream.imbue(std::locale("C"));
     sstream << feat.second;
     auto* valueText = doc->NewText(sstream.str().c_str());
     featNode->InsertEndChild(valueText);
     featsNode->InsertEndChild(featNode);
   }
 }
 
 void AddFeatureSettings(const mitk::AbstractGlobalImageFeature::FeatureListType& features, tinyxml2::XMLElement* featSettingsNode)
 {
   auto* doc = featSettingsNode->GetDocument();
   std::list<std::string> coveredSettings;
   for (const auto& feat : features)
   {
     auto finding = std::find(coveredSettings.begin(), coveredSettings.end(), feat.first.settingID);
     if (finding == coveredSettings.end())
     {
       auto featSettingNode = doc->NewElement("mp:featureSetting");
       featSettingsNode->InsertEndChild(featSettingNode);
       featSettingNode->SetAttribute("name", feat.first.settingID.c_str());
       AddParameters(feat.first.parameters, featSettingNode);
       coveredSettings.push_back(feat.first.settingID);
     }
   }
 }
 
 void AddReaderInfo(const mitk::Image* image, tinyxml2::XMLElement* imageNode)
 {
   auto* doc = imageNode->GetDocument();
   auto ioNode = doc->NewElement("mp:IOReader");
   imageNode->InsertEndChild(ioNode);
   AddPropertyAsNode(image, mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_DESCRIPTION()), "mp:description", ioNode);
   AddPropertyAsNode(image, mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_VERSION()), "mp:version", ioNode);
   AddPropertyAsNode(image, mitk::PropertyKeyPathToPropertyName(mitk::DICOMIOMetaInformationPropertyConstants::READER_CONFIGURATION()), "mp:configuration", ioNode);
   AddPropertyAsNode(image, mitk::PropertyKeyPathToPropertyName(mitk::DICOMIOMetaInformationPropertyConstants::READER_GDCM()), "mp:gdcmVersion", ioNode);
   AddPropertyAsNode(image, mitk::PropertyKeyPathToPropertyName(mitk::DICOMIOMetaInformationPropertyConstants::READER_DCMTK()), "mp:dcmtkVersion", ioNode);
 }
 
 void WriteDocument(std::ostream& stream, const mitk::Image* image, const mitk::Image* mask,
   const mitk::AbstractGlobalImageFeature::FeatureListType& features, const std::string& methodName,
   const std::string& organisation, const std::string& version, const std::string& pipelineUID,
   const std::map<std::string, us::Any>& cliArgs)
 {
   tinyxml2::XMLDocument doc;
   doc.InsertEndChild(doc.NewDeclaration());
 
   auto* rootNode = doc.NewElement("mp:measurement");
-  rootNode->SetAttribute("xmlns:mp", "http://www.mitk.org/Phenotyping");
+  rootNode->SetAttribute("xmlns:mp", "https://www.mitk.org/Phenotyping");
   doc.InsertEndChild(rootNode);
 
   auto* methodNode = doc.NewElement("mp:measurementMethod");
   rootNode->InsertEndChild(methodNode);
 
   auto* methodNameNode = doc.NewElement("mp:name");
   auto* valueText = doc.NewText(methodName.c_str());
   methodNameNode->InsertEndChild(valueText);
   methodNode->InsertEndChild(methodNameNode);
 
   auto* organisationNode = doc.NewElement("mp:organisation");
   valueText = doc.NewText(organisation.c_str());
   organisationNode->InsertEndChild(valueText);
   methodNode->InsertEndChild(organisationNode);
 
   auto* versionNode = doc.NewElement("mp:version");
   valueText = doc.NewText(version.c_str());
   versionNode->InsertEndChild(valueText);
   methodNode->InsertEndChild(versionNode);
 
   auto* imageNode = doc.NewElement("mp:image");
   rootNode->InsertEndChild(imageNode);
 
   AddSeriesInstanceUID(image, imageNode);
   AddFilePath(image, imageNode);
   AddSOPInstanceUIDs(image, imageNode);
   AddReaderInfo(image,imageNode);
 
 
   auto* maskNode = doc.NewElement("mp:mask");
   rootNode->InsertEndChild(maskNode);
 
   AddSeriesInstanceUID(mask, maskNode);
   AddFilePath(mask, maskNode);
   AddSOPInstanceUIDs(mask, maskNode);
   AddReaderInfo(mask, maskNode);
 
   //todo mask reader meta info
 
   AddDateAndTime(rootNode);
 
   auto* pipelineNode = doc.NewElement("mp:pipelineUID");
   valueText = doc.NewText(pipelineUID.c_str());
   pipelineNode->InsertEndChild(valueText);
   rootNode->InsertEndChild(pipelineNode);
 
   auto* paramsNode = doc.NewElement("mp:parameters");
   rootNode->InsertEndChild(paramsNode);
   AddParameters(cliArgs, paramsNode);
 
   auto* featsNode = doc.NewElement("mp:features");
   rootNode->InsertEndChild(featsNode);
 
   AddFeatures(features, featsNode);
 
   auto* featSettingsNode = doc.NewElement("mp:featureSettings");
   rootNode->InsertEndChild(featSettingsNode);
   AddFeatureSettings(features, featSettingsNode);
 
   tinyxml2::XMLPrinter printer;
   doc.Print(&printer);
 
   stream << printer.CStr();
 }
 
 void mitk::cl::CLResultXMLWriter::SetImage(const Image* image)
 {
   m_Image = image;
 }
 
 void mitk::cl::CLResultXMLWriter::SetMask(const Image* mask)
 {
   m_Mask = mask;
 }
 
 void mitk::cl::CLResultXMLWriter::SetFeatures(const mitk::AbstractGlobalImageFeature::FeatureListType& features)
 {
   m_Features = features;
 }
 
 void mitk::cl::CLResultXMLWriter::SetMethodName(const std::string& name)
 {
   m_MethodName = name;
 }
 
 void mitk::cl::CLResultXMLWriter::SetMethodVersion(const std::string& version)
 {
   m_MethodVersion = version;
 }
 
 void mitk::cl::CLResultXMLWriter::SetOrganisation(const std::string& orga)
 {
   m_Organisation = orga;
 }
 
 void mitk::cl::CLResultXMLWriter::SetPipelineUID(const std::string& pipelineUID)
 {
   m_PipelineUID = pipelineUID;
 }
 
 void mitk::cl::CLResultXMLWriter::SetCLIArgs(const std::map<std::string, us::Any>& args)
 {
   m_CLIArgs = args;
 }
 
 void mitk::cl::CLResultXMLWriter::write(const std::string& filePath) const
 {
   std::ofstream resultFile;
   resultFile.open(filePath.c_str());
   if (resultFile.is_open())
   {
     this->write(resultFile);
     resultFile.close();
   }
   else
   {
     MITK_ERROR << "Cannot write xml results. Unable to open file: \""<<filePath<<"\"";
   }
 }
 
 void mitk::cl::CLResultXMLWriter::write(std::ostream& stream) const
 {
   WriteDocument(stream, m_Image, m_Mask, m_Features, m_MethodName, m_Organisation, m_MethodVersion, m_PipelineUID, m_CLIArgs);
 }
diff --git a/Modules/CommandLine/include/mitkCommandLineParser.h b/Modules/CommandLine/include/mitkCommandLineParser.h
index 24cd81b25a..c83544cad7 100644
--- a/Modules/CommandLine/include/mitkCommandLineParser.h
+++ b/Modules/CommandLine/include/mitkCommandLineParser.h
@@ -1,391 +1,391 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 /*=========================================================================
 
   Library:   CTK
 
   Copyright (c) Kitware Inc.
 
   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
+      https://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 __mitkCommandLineParser_h
 #define __mitkCommandLineParser_h
 
 #include <map>
 #include <usAny.h>
 
 #include <MitkCommandLineExports.h>
 #include <mitkVersion.h>
 
 /**
  *
  * The MITK command line parser, based on the CTK command line parser.
  *
  * Use this class to add information about the command line arguments
  * your program understands and to easily parse them from a given list
  * of strings.
  *
  * This parser provides the following features:
  *
  * <ul>
  * <li>Add arguments by supplying a long name and/or a short name.
  *     Arguments are validated using a regular expression. They can have
  *     a default value and a help string.</li>
  * <li>Deprecated arguments.</li>
  * <li>Custom regular expressions for argument validation.</li>
  * <li>Set different argument name prefixes for native platform look and feel.</li>
  * <li>Create a help text for the command line arguments with support for
  *     grouping arguments.</li>
  * </ul>
  *
  * The main difference between the MITK command line parser and the CTK command line
  * parser is that the former does not depend on Qt. Apart from that an image type was
  * added and XML output improved for automatic GUI generation.
  *
  * std::out is used for output to keep dependencies to a minimum.
  */
 
 class MITKCOMMANDLINE_EXPORT mitkCommandLineParser
 {
 public:
   enum Type
   {
     String = 0,
     Bool = 1,
     StringList = 2,
     Int = 3,
     Float = 4,
     Directory = 5,
     File = 6,
     Image = 7
   };
 
   enum Channel
   {
     None = 0,
     Input = 1,
     Output = 2
   };
 
   typedef std::vector<std::string> StringContainerType;
 
   mitkCommandLineParser();
 
   ~mitkCommandLineParser();
 
   /**
  * Parse a given list of command line arguments.
  *
  * This method parses a list of string elements considering the known arguments
  * added by calls to <code>addArgument()</code>. If any one of the argument
  * values does not match the corresponding regular expression,
  * <code>ok</code> is set to false and an empty map object is returned.
  *
  * The keys in the returned map object correspond to the long argument string,
  * if it is not empty. Otherwise, the short argument string is used as key. The
  * us::Any values can safely be converted to the type specified in the
  * <code>addArgument()</code> method call.
  *
  * @param arguments A StringContainerType containing command line arguments.
  * @param ok A pointer to a boolean variable. Will be set to <code>true</code>
  *        if all regular expressions matched, <code>false</code> otherwise.
  * @return A map object mapping the long argument (if empty, the short one)
  *         to a us::Any containing the value.
  */
 
   std::map<std::string, us::Any> parseArguments(const StringContainerType &arguments, bool *ok = nullptr);
 
   /**
   * Convenient method allowing to parse a given list of command line arguments.
   * @see parseArguments(const StringContainerType &, bool*)
   */
   std::map<std::string, us::Any> parseArguments(int argc, char **argv, bool *ok = nullptr);
 
   /**
  * Returns a detailed error description if a call to <code>parseArguments()</code>
  * failed.
  *
  * @return The error description, empty if no error occured.
  * @see parseArguments(const StringContainerType&, bool*)
  */
   std::string errorString() const;
 
   /**
  * This method returns all unparsed arguments, i.e. all arguments
  * for which no long or short name has been registered via a call
  * to <code>addArgument()</code>.
  *
  * @see addArgument()
  *
  * @return A list containing unparsed arguments.
  */
   const StringContainerType &unparsedArguments() const;
 
   /**
  * Checks if the given argument has been added via a call
  * to <code>addArgument()</code>.
  *
  * @see addArgument()
  *
  * @param argument The argument to be checked.
  * @return <code>true</code> if the argument was added, <code>false</code>
  *         otherwise.
  */
   bool argumentAdded(const std::string &argument) const;
 
   /**
  * Checks if the given argument has been parsed successfully by a previous
  * call to <code>parseArguments()</code>.
  *
  * @param argument The argument to be checked.
  * @return <code>true</code> if the argument was parsed, <code>false</code>
  *         otherwise.
  */
   bool argumentParsed(const std::string &argument) const;
 
   /**
  * Adds a command line argument. An argument can have a long name
  * (like --long-argument-name), a short name (like -l), or both. The type
  * of the argument can be specified by using the <code>type</code> parameter.
  * The following types are supported:
  *
  * <table>
  * <tr><td><b>Type</b></td><td><b># of parameters</b></td><td><b>Default regular expr</b></td>
  *        <td><b>Example</b></td></tr>
  * <tr><td>us::Any::String</td><td>1</td><td>.*</td><td>--test-string StringParameter</td></tr>
  * <tr><td>us::Any::Bool</td><td>0</td><td>does not apply</td><td>--enable-something</td></tr>
  * <tr><td>us::Any::StringList</td><td>-1</td><td>.*</td><td>--test-list string1 string2</td></tr>
  * <tr><td>us::Any::Int</td><td>1</td><td>-?[0-9]+</td><td>--test-int -5</td></tr>
  * </table>
  *
  * The regular expressions are used to validate the parameters of command line
  * arguments. You can restrict the valid set of parameters by calling
  * <code>setExactMatchRegularExpression()</code> for your argument.
  *
  * Optionally, a help string and a default value can be provided for the argument. If
  * the us::Any type of the default value does not match <code>type</code>, an
  * exception is thrown. Arguments with default values are always returned by
  * <code>parseArguments()</code>.
  *
  * You can also declare an argument deprecated, by setting <code>deprecated</code>
  * to <code>true</code>. Alternatively you can add a deprecated argument by calling
  * <code>addDeprecatedArgument()</code>.
  *
  * If the long or short argument has already been added, or if both are empty strings,
  * the method call has no effect.
  *
  * @param longarg The long argument name.
  * @param shortarg The short argument name.
  * @param type The argument type (see the list above for supported types).
  * @param argLabel The label of this argument, when auto generated interface is used.
  * @param argHelp A help string describing the argument.
  * @param defaultValue A default value for the argument.
  * @param optional
  * @param ignoreRest All arguments after the current one will be ignored.
  * @param deprecated Declares the argument deprecated.
  * @param channel
  *
  * @see setExactMatchRegularExpression()
  * @see addDeprecatedArgument()
  * @throws std::logic_error If the us::Any type of <code>defaultValue</code>
  *         does not match <code>type</code>, a <code>std::logic_error</code> is thrown.
  */
   void addArgument(const std::string &longarg,
                    const std::string &shortarg,
                    Type type,
                    const std::string &argLabel,
                    const std::string &argHelp = std::string(),
                    const us::Any &defaultValue = us::Any(),
                    bool optional = true,
                    bool ignoreRest = false,
                    bool deprecated = false,
                    mitkCommandLineParser::Channel channel = mitkCommandLineParser::Channel::None);
 
   /**
  * Adds a deprecated command line argument. If a deprecated argument is provided
  * on the command line, <code>argHelp</code> is displayed in the console and
  * processing continues with the next argument.
  *
  * Deprecated arguments are grouped separately at the end of the help text
  * returned by <code>helpText()</code>.
  *
  * @param longarg The long argument name.
  * @param shortarg The short argument name.
  * @param argLabel
  * @param argHelp A help string describing alternatives to the deprecated argument.
  */
   void addDeprecatedArgument(const std::string &longarg,
                              const std::string &shortarg,
                              const std::string &argLabel,
                              const std::string &argHelp);
 
 
   /**
   * Returns the vector of current Command line Parameter
   *
   */
   std::vector < std::map<std::string, us::Any> > getArgumentList();
 
   /**
  * Sets a custom regular expression for validating argument parameters. The method
  * <code>errorString()</code> can be used the get the last error description.
  *
  * @param argument The previously added long or short argument name.
  * @param expression A regular expression which the arugment parameters must match.
  * @param exactMatchFailedMessage An error message explaining why the parameter did
  *        not match.
  *
  * @return <code>true</code> if the argument was found and the regular expression was set,
  *         <code>false</code> otherwise.
  *
  * @see errorString()
  */
   bool setExactMatchRegularExpression(const std::string &argument,
                                       const std::string &expression,
                                       const std::string &exactMatchFailedMessage);
 
   /**
  * The field width for the argument names without the help text.
  *
  * @return The argument names field width in the help text.
  */
   std::string::size_type fieldWidth() const;
 
   /**
  * Creates a help text containing properly formatted argument names and help strings
  * provided by calls to <code>addArgument()</code>. The arguments can be grouped by
  * using <code>beginGroup()</code> and <code>endGroup()</code>.
  *
  * @return The formatted help text.
  */
   std::string helpText() const;
 
   /**
  * Sets the argument prefix for long and short argument names. This can be used
  * to create native command line arguments without changing the calls to
  * <code>addArgument()</code>. For example on Unix-based systems, long argument
  * names start with "--" and short names with "-", while on Windows argument names
  * always start with "/".
  *
  * Note that all methods in mitkCommandLineParser which take an argument name
  * expect the name as it was supplied to <code>addArgument</code>.
  *
  * Example usage:
  *
  * \code
  * ctkCommandLineParser parser;
  * parser.setArgumentPrefix("--", "-");
  * parser.addArgument("long-argument", "l", us::Any::String);
  * StringContainerType args;
  * args << "program name" << "--long-argument Hi";
  * parser.parseArguments(args);
  * \endcode
  *
  * @param longPrefix The prefix for long argument names.
  * @param shortPrefix The prefix for short argument names.
  */
   void setArgumentPrefix(const std::string &longPrefix, const std::string &shortPrefix);
 
   /**
  * Begins a new group for documenting arguments. All newly added arguments via
  * <code>addArgument()</code> will be put in the new group. You can close the
  * current group by calling <code>endGroup()</code> or be opening a new group.
  *
  * Note that groups cannot be nested and all arguments which do not belong to
  * a group will be listed at the top of the text created by <code>helpText()</code>.
  *
  * @param description The description of the group
  */
   void beginGroup(const std::string &description);
 
   /**
  * Ends the current group.
  *
  * @see beginGroup(const std::string&)
  */
   void endGroup();
 
   /**
  * Can be used to teach the parser to stop parsing the arguments and return False when
  * an unknown argument is encountered. By default <code>StrictMode</code> is disabled.
  *
  * @see parseArguments(const StringContainerType &, bool*)
  */
   void setStrictModeEnabled(bool strictMode);
 
   /**
    * Is used to generate an XML output for any commandline program.
    */
   void generateXmlOutput();
 
   /**
    * Is used to set the title of the auto generated interface.
    *
    * @param title The title of the app.
    */
   void setTitle(std::string title);
   /**
    * Is used to set the contributor for the help view in the auto generated interface.
    *
    * @param contributor Contributor of the app.
    */
   void setContributor(std::string contributor);
   /**
    * Is used to categorize the apps in the commandline module.
    *
    * @param category The category of the app.
    */
   void setCategory(std::string category);
   /**
    * Is used as the help text in the auto generated interface.
    *
    * @param description A short description for the app.
    */
   void setDescription(std::string description);
   /**
    * Is used to group several Parameters in one groupbox in the auto generated interface.
    * Default name is "Parameters", with the tooltip: "Groupbox containing parameters."
    *
    * To change the group of several arguments, call this method before the arguments are added.
    *
    * @param name The name of the groupbox.
    * @param tooltip The tooltip of the groupbox.
    */
   void changeParameterGroup(std::string name, std::string tooltip);
 
 protected:
   class ctkInternal;
   ctkInternal *Internal;
 
   std::string Title;
   std::string Contributor;
   std::string Category;
   std::string Description;
   std::string ParameterGroupName;
   std::string ParameterGroupDescription;
 };
 
 
 
 #endif
diff --git a/Modules/CommandLine/src/mitkCommandLineParser.cpp b/Modules/CommandLine/src/mitkCommandLineParser.cpp
index 7b663c3464..cf60f88d99 100644
--- a/Modules/CommandLine/src/mitkCommandLineParser.cpp
+++ b/Modules/CommandLine/src/mitkCommandLineParser.cpp
@@ -1,1056 +1,1056 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 /*=========================================================================
 
   Library:   CTK
 
   Copyright (c) Kitware Inc.
 
   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
+      https://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.
 
 =========================================================================*/
 
 // STL includes
 #include <iostream>
 #include <stdexcept>
 
 // MITK includes
 #include "mitkCommandLineParser.h"
 
 using namespace std;
 
 namespace
 {
 // --------------------------------------------------------------------------
 class CommandLineParserArgumentDescription
 {
 public:
   CommandLineParserArgumentDescription(const string &longArg,
                                        const string &longArgPrefix,
                                        const string &shortArg,
                                        const string &shortArgPrefix,
                                        mitkCommandLineParser::Type type,
                                        const string &argHelp,
                                        const string &argLabel,
                                        const us::Any &defaultValue,
                                        bool ignoreRest,
                                        bool deprecated,
                                        bool optional,
                                        mitkCommandLineParser::Channel channel,
                                        string &argGroup,
                                        string &groupDescription)
     : LongArg(longArg),
       LongArgPrefix(longArgPrefix),
       ShortArg(shortArg),
       ShortArgPrefix(shortArgPrefix),
       ArgHelp(argHelp),
       ArgLabel(argLabel),
       ArgGroup(argGroup),
       ArgGroupDescription(groupDescription),
       IgnoreRest(ignoreRest),
       NumberOfParametersToProcess(0),
       Deprecated(deprecated),
       Optional(optional),
       Channel(channel),
       DefaultValue(defaultValue),
       Value(type),
       ValueType(type)
   {
     Value = defaultValue;
 
     switch (type)
     {
     case mitkCommandLineParser::String:
     {
       NumberOfParametersToProcess = 1;
     }
       break;
     case mitkCommandLineParser::Bool:
     {
       NumberOfParametersToProcess = 0;
     }
       break;
     case mitkCommandLineParser::StringList:
     {
       NumberOfParametersToProcess = -1;
     }
       break;
     case mitkCommandLineParser::Int:
     {
       NumberOfParametersToProcess = 1;
     }
       break;
     case mitkCommandLineParser::Float:
     {
       NumberOfParametersToProcess = 1;
     }
       break;
 
     case mitkCommandLineParser::Directory:
     {
       NumberOfParametersToProcess = 1;
     }
       break;
 
     case mitkCommandLineParser::File:
     {
       NumberOfParametersToProcess = 1;
     }
       break;
     case mitkCommandLineParser::Image:
     {
       NumberOfParametersToProcess = 1;
     }
       break;
 
     default:
       std::cout << "Type not supported: " << static_cast<int>(type);
     }
   }
 
   ~CommandLineParserArgumentDescription() {}
   bool addParameter(const string &value);
 
   string helpText();
 
   string LongArg;
   string LongArgPrefix;
   string ShortArg;
   string ShortArgPrefix;
   string ArgHelp;
   string ArgLabel;
   string ArgGroup;
   string ArgGroupDescription;
   bool IgnoreRest;
   int NumberOfParametersToProcess;
   bool Deprecated;
   bool Optional;
   mitkCommandLineParser::Channel Channel;
 
   us::Any DefaultValue;
   us::Any Value;
   mitkCommandLineParser::Type ValueType;
 };
 
 // --------------------------------------------------------------------------
 bool CommandLineParserArgumentDescription::addParameter(const string &value)
 {
   switch (ValueType)
   {
   case mitkCommandLineParser::String:
   {
     Value = value;
   }
     break;
   case mitkCommandLineParser::Bool:
   {
     if (value.compare("true") == 0)
       Value = true;
     else
       Value = false;
   }
     break;
   case mitkCommandLineParser::StringList:
   {
     try
     {
       mitkCommandLineParser::StringContainerType list =
           us::any_cast<mitkCommandLineParser::StringContainerType>(Value);
       list.push_back(value);
       Value = list;
     }
     catch (...)
     {
       mitkCommandLineParser::StringContainerType list;
       list.push_back(value);
       Value = list;
     }
   }
     break;
   case mitkCommandLineParser::Int:
   {
     stringstream ss(value);
     int i;
     ss >> i;
     Value = i;
   }
     break;
   case mitkCommandLineParser::Float:
   {
     stringstream ss(value);
     float f;
     ss >> f;
     Value = f;
   }
     break;
 
   case mitkCommandLineParser::Directory:
   case mitkCommandLineParser::Image:
   case mitkCommandLineParser::File:
   {
     Value = value;
   }
     break;
 
   default:
     return false;
   }
 
   return true;
 }
 
 // --------------------------------------------------------------------------
 string CommandLineParserArgumentDescription::helpText()
 {
   string text;
 
   string shortAndLongArg;
   if (!this->ShortArg.empty())
   {
     shortAndLongArg = "  ";
     shortAndLongArg += this->ShortArgPrefix;
     shortAndLongArg += this->ShortArg;
   }
 
   if (!this->LongArg.empty())
   {
     if (this->ShortArg.empty())
       shortAndLongArg.append("  ");
     else
       shortAndLongArg.append(", ");
 
     shortAndLongArg += this->LongArgPrefix;
     shortAndLongArg += this->LongArg;
   }
 
   text = text + shortAndLongArg + ", " + this->ArgHelp;
 
   if (this->Optional)
     text += " (optional)";
 
   if (!this->DefaultValue.Empty())
   {
     if (this->ValueType == 1)
     {
       if (this->DefaultValue.ToString() == "0")
         text = text + ", (default: false)";
       else
         text = text + ", (default: true)";
     }
     else
       text = text + ", (default: " + this->DefaultValue.ToString() + ")";
   }
   string value_type = "Unknown";
   switch (this->ValueType)
   {
   case 0:
   {
     value_type = "String";
     break;
   }
   case 1:
   {
     value_type = "Bool";
     break;
   }
   case 2:
   {
     value_type = "StringList";
     break;
   }
   case 3:
   {
     value_type = "Int";
     break;
   }
   case 4:
   {
     value_type = "Float";
     break;
   }
   case 5:
   {
     value_type = "Directory";
     break;
   }
   case 6:
   {
     value_type = "File";
     break;
   }
   case 7:
   {
     value_type = "Image";
   }
   }
   text = text + ", Type: " + value_type;
   if (this->Channel == mitkCommandLineParser::Input)
     text = text + ", Channel: input";
   else if (this->Channel == mitkCommandLineParser::Output)
     text = text + ", Channel: output";
   text += "\n";
   return text;
 }
 }
 
 // --------------------------------------------------------------------------
 // ctkCommandLineParser::ctkInternal class
 
 // --------------------------------------------------------------------------
 class mitkCommandLineParser::ctkInternal
 {
 public:
   ctkInternal() : Debug(false), FieldWidth(0), StrictMode(false) {}
   ~ctkInternal() {}
   CommandLineParserArgumentDescription *argumentDescription(const string &argument);
 
   vector<CommandLineParserArgumentDescription *> ArgumentDescriptionList;
   map<string, CommandLineParserArgumentDescription *> ArgNameToArgumentDescriptionMap;
   map<string, vector<CommandLineParserArgumentDescription *>> GroupToArgumentDescriptionListMap;
 
   StringContainerType UnparsedArguments;
   StringContainerType ProcessedArguments;
   string ErrorString;
   bool Debug;
   string::size_type FieldWidth;
   string LongPrefix;
   string ShortPrefix;
   string CurrentGroup;
   string DisableQSettingsLongArg;
   string DisableQSettingsShortArg;
   bool StrictMode;
 };
 
 // --------------------------------------------------------------------------
 // ctkCommandLineParser::ctkInternal methods
 
 // --------------------------------------------------------------------------
 CommandLineParserArgumentDescription *mitkCommandLineParser::ctkInternal::argumentDescription(const string &argument)
 {
   string unprefixedArg = argument;
 
   if (!LongPrefix.empty() && argument.compare(0, LongPrefix.size(), LongPrefix) == 0)
   {
     // Case when (ShortPrefix + UnPrefixedArgument) matches LongPrefix
     if (argument == LongPrefix && !ShortPrefix.empty() && argument.compare(0, ShortPrefix.size(), ShortPrefix) == 0)
     {
       unprefixedArg = argument.substr(ShortPrefix.size(), argument.size());
     }
     else
     {
       unprefixedArg = argument.substr(LongPrefix.size(), argument.size());
     }
   }
   else if (!ShortPrefix.empty() && argument.compare(0, ShortPrefix.size(), ShortPrefix) == 0)
   {
     unprefixedArg = argument.substr(ShortPrefix.size(), argument.size());
   }
   else if (!LongPrefix.empty() && !ShortPrefix.empty())
   {
     return nullptr;
   }
 
   if (ArgNameToArgumentDescriptionMap.count(unprefixedArg))
   {
     return this->ArgNameToArgumentDescriptionMap[unprefixedArg];
   }
   return nullptr;
 }
 
 // --------------------------------------------------------------------------
 // ctkCommandLineParser methods
 
 // --------------------------------------------------------------------------
 mitkCommandLineParser::mitkCommandLineParser()
 {
   this->Internal = new ctkInternal();
   this->Category = string();
   this->Title = string();
   this->Contributor = string();
   this->Description = string();
   this->ParameterGroupName = "Parameters";
   this->ParameterGroupDescription = "Parameters";
 }
 
 // --------------------------------------------------------------------------
 mitkCommandLineParser::~mitkCommandLineParser()
 {
   delete this->Internal;
 }
 
 // --------------------------------------------------------------------------
 map<string, us::Any> mitkCommandLineParser::parseArguments(const StringContainerType &arguments, bool *ok)
 {
   // Reset
   this->Internal->UnparsedArguments.clear();
   this->Internal->ProcessedArguments.clear();
   this->Internal->ErrorString.clear();
   // foreach (CommandLineParserArgumentDescription* desc, this->Internal->ArgumentDescriptionList)
   for (unsigned int i = 0; i < Internal->ArgumentDescriptionList.size(); i++)
   {
     CommandLineParserArgumentDescription *desc = Internal->ArgumentDescriptionList.at(i);
     desc->Value = us::Any(desc->ValueType);
     if (!desc->DefaultValue.Empty())
     {
       desc->Value = desc->DefaultValue;
     }
   }
   bool error = false;
   bool ignoreRest = false;
   CommandLineParserArgumentDescription *currentArgDesc = nullptr;
   vector<CommandLineParserArgumentDescription *> parsedArgDescriptions;
   for (unsigned int i = 1; i < arguments.size(); ++i)
   {
     string argument = arguments.at(i);
 
     if (this->Internal->Debug)
     {
       std::cout << "Processing" << argument;
     }
     if (!argument.compare("--version"))
     {
       std::cout << "Git commit hash: " << MITK_REVISION << std::endl;
       std::cout << "Git branch name: " << MITK_REVISION_NAME << "\n" << std::endl;
     }
 
     if (!argument.compare("--xml") || !argument.compare("-xml") || !argument.compare("--XML") ||
         !argument.compare("-XML"))
     {
       this->generateXmlOutput();
       return map<string, us::Any>();
     }
 
     // should argument be ignored ?
     if (ignoreRest)
     {
       if (this->Internal->Debug)
       {
         std::cout << "  Skipping: IgnoreRest flag was been set";
       }
       this->Internal->UnparsedArguments.push_back(argument);
       continue;
     }
 
     // Skip if the argument does not start with the defined prefix
     if (!(argument.compare(0, Internal->LongPrefix.size(), Internal->LongPrefix) == 0 ||
           argument.compare(0, Internal->ShortPrefix.size(), Internal->ShortPrefix) == 0))
     {
       if (this->Internal->StrictMode)
       {
         this->Internal->ErrorString = "Unknown argument ";
         this->Internal->ErrorString += argument;
         error = true;
         break;
       }
       if (this->Internal->Debug)
       {
         std::cout << "  Skipping: It does not start with the defined prefix";
       }
       this->Internal->UnparsedArguments.push_back(argument);
       continue;
     }
 
     // Skip if argument has already been parsed ...
     bool alreadyProcessed = false;
     for (const auto &alreadyHandledArgument : Internal->ProcessedArguments)
       if (argument.compare(alreadyHandledArgument) == 0)
       {
         alreadyProcessed = true;
         break;
       }
 
     if (alreadyProcessed)
     {
       if (this->Internal->StrictMode)
       {
         this->Internal->ErrorString = "Argument ";
         this->Internal->ErrorString += argument;
         this->Internal->ErrorString += " already processed !";
         error = true;
         break;
       }
       if (this->Internal->Debug)
       {
         std::cout << "  Skipping: Already processed !";
       }
       continue;
     }
 
     // Retrieve corresponding argument description
     currentArgDesc = this->Internal->argumentDescription(argument);
 
     // Is there a corresponding argument description ?
     if (currentArgDesc)
     {
       // If the argument is deprecated, print the help text but continue processing
       if (currentArgDesc->Deprecated)
       {
         std::cout << "Deprecated argument " << argument << ": " << currentArgDesc->ArgHelp;
       }
       else
       {
         parsedArgDescriptions.push_back(currentArgDesc);
       }
 
       this->Internal->ProcessedArguments.push_back(currentArgDesc->ShortArg);
       this->Internal->ProcessedArguments.push_back(currentArgDesc->LongArg);
       int numberOfParametersToProcess = currentArgDesc->NumberOfParametersToProcess;
       ignoreRest = currentArgDesc->IgnoreRest;
       if (this->Internal->Debug && ignoreRest)
       {
         std::cout << "  IgnoreRest flag is True";
       }
 
       // Is the number of parameters associated with the argument being processed known ?
       if (numberOfParametersToProcess == 0)
       {
         currentArgDesc->addParameter("true");
       }
       else if (numberOfParametersToProcess > 0)
       {
         string missingParameterError = "Argument %1 has %2 value(s) associated whereas exacly %3 are expected.";
         for (int j = 1; j <= numberOfParametersToProcess; ++j)
         {
           if (i + j >= arguments.size())
           {
             // this->Internal->ErrorString =
             //         missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
             // if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
             if (ok)
             {
               *ok = false;
             }
             return map<string, us::Any>();
           }
           string parameter = arguments.at(i + j);
           if (this->Internal->Debug)
           {
             std::cout << "  Processing parameter" << j << ", value:" << parameter;
           }
           if (this->argumentAdded(parameter))
           {
             // this->Internal->ErrorString =
             //         missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
             // if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
             if (ok)
             {
               *ok = false;
             }
             return map<string, us::Any>();
           }
           if (!currentArgDesc->addParameter(parameter))
           {
             // this->Internal->ErrorString = string(
             //             "Value(s) associated with argument %1 are incorrect. %2").
             //         arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
             // if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
             if (ok)
             {
               *ok = false;
             }
             return map<string, us::Any>();
           }
         }
         // Update main loop increment
         i = i + numberOfParametersToProcess;
       }
       else if (numberOfParametersToProcess == -1)
       {
         if (this->Internal->Debug)
         {
           std::cout << "  Proccessing StringList ...";
         }
         int j = 1;
         while (j + i < arguments.size())
         {
           if (this->argumentAdded(arguments.at(j + i)))
           {
             if (this->Internal->Debug)
             {
               std::cout << "  No more parameter for" << argument;
             }
             break;
           }
           string parameter = arguments.at(j + i);
 
           if (parameter.compare(0, Internal->LongPrefix.size(), Internal->LongPrefix) == 0 ||
               parameter.compare(0, Internal->ShortPrefix.size(), Internal->ShortPrefix) == 0)
           {
             j--;
             break;
           }
 
           if (this->Internal->Debug)
           {
             std::cout << "  Processing parameter" << j << ", value:" << parameter;
           }
           if (!currentArgDesc->addParameter(parameter))
           {
             // this->Internal->ErrorString = string(
             //             "Value(s) associated with argument %1 are incorrect. %2").
             //         arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
             // if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
             if (ok)
             {
               *ok = false;
             }
             return map<string, us::Any>();
           }
           j++;
         }
         // Update main loop increment
         i = i + j;
       }
     }
     else
     {
       if (this->Internal->StrictMode)
       {
         this->Internal->ErrorString = "Unknown argument ";
         this->Internal->ErrorString += argument;
         error = true;
         break;
       }
       if (this->Internal->Debug)
       {
         std::cout << "  Skipping: Unknown argument";
       }
       this->Internal->UnparsedArguments.push_back(argument);
     }
   }
 
   if (ok)
   {
     *ok = !error;
   }
 
   map<string, us::Any> parsedArguments;
 
   int obligatoryArgs = 0;
   vector<CommandLineParserArgumentDescription *>::iterator it;
   for (it = Internal->ArgumentDescriptionList.begin(); it != Internal->ArgumentDescriptionList.end(); ++it)
   {
     CommandLineParserArgumentDescription *desc = *it;
 
     if (!desc->Optional)
       obligatoryArgs++;
   }
 
   int parsedObligatoryArgs = 0;
   for (it = parsedArgDescriptions.begin(); it != parsedArgDescriptions.end(); ++it)
   {
     CommandLineParserArgumentDescription *desc = *it;
 
     string key;
     if (!desc->LongArg.empty())
     {
       key = desc->LongArg;
     }
     else
     {
       key = desc->ShortArg;
     }
 
     if (!desc->Optional)
       parsedObligatoryArgs++;
 
     std::pair<string, us::Any> elem;
     elem.first = key;
     elem.second = desc->Value;
     parsedArguments.insert(elem);
   }
 
   if (obligatoryArgs > parsedObligatoryArgs)
   {
     parsedArguments.clear();
     cout << helpText();
   }
 
   return parsedArguments;
 }
 
 // -------------------------------------------------------------------------
 map<string, us::Any> mitkCommandLineParser::parseArguments(int argc, char **argv, bool *ok)
 {
   std::cout << "Running Command Line Utility *" << Title << "*" << std::endl;
   StringContainerType arguments;
 
   // Create a StringContainerType of arguments
   for (int i = 0; i < argc; ++i)
     arguments.push_back(argv[i]);
 
   return this->parseArguments(arguments, ok);
 }
 
 // -------------------------------------------------------------------------
 string mitkCommandLineParser::errorString() const
 {
   return this->Internal->ErrorString;
 }
 
 // -------------------------------------------------------------------------
 const mitkCommandLineParser::StringContainerType &mitkCommandLineParser::unparsedArguments() const
 {
   return this->Internal->UnparsedArguments;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::addArgument(const string &longarg,
                                         const string &shortarg,
                                         Type type,
                                         const string &argLabel,
                                         const string &argHelp,
                                         const us::Any &defaultValue,
                                         bool optional,
                                         bool ignoreRest,
                                         bool deprecated,
                                         mitkCommandLineParser::Channel channel)
 {
   if (longarg.empty() && shortarg.empty())
   {
     return;
   }
 
   /* Make sure it's not already added */
   bool added = (this->Internal->ArgNameToArgumentDescriptionMap.count(longarg) != 0);
   if (added)
   {
     return;
   }
 
   added = (this->Internal->ArgNameToArgumentDescriptionMap.count(shortarg) != 0);
   if (added)
   {
     return;
   }
 
   auto argDesc = new CommandLineParserArgumentDescription(longarg,
                                                           this->Internal->LongPrefix,
                                                           shortarg,
                                                           this->Internal->ShortPrefix,
                                                           type,
                                                           argHelp,
                                                           argLabel,
                                                           defaultValue,
                                                           ignoreRest,
                                                           deprecated,
                                                           optional,
                                                           channel,
                                                           ParameterGroupName,
                                                           ParameterGroupDescription);
 
   std::string::size_type argWidth = 0;
   if (!longarg.empty())
   {
     this->Internal->ArgNameToArgumentDescriptionMap[longarg] = argDesc;
     argWidth += longarg.size() + this->Internal->LongPrefix.size();
   }
   if (!shortarg.empty())
   {
     this->Internal->ArgNameToArgumentDescriptionMap[shortarg] = argDesc;
     argWidth += shortarg.size() + this->Internal->ShortPrefix.size() + 2;
   }
   argWidth += 5;
 
   // Set the field width for the arguments
   if (argWidth > this->Internal->FieldWidth)
   {
     this->Internal->FieldWidth = argWidth;
   }
 
   this->Internal->ArgumentDescriptionList.push_back(argDesc);
   this->Internal->GroupToArgumentDescriptionListMap[this->Internal->CurrentGroup].push_back(argDesc);
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::addDeprecatedArgument(const string &longarg,
                                                   const string &shortarg,
                                                   const string &argLabel,
                                                   const string &argHelp)
 {
   addArgument(longarg, shortarg, StringList, argLabel, argHelp, us::Any(), false, true, false);
 }
 
 // --------------------------------------------------------------------------
 std::vector < std::map<std::string, us::Any> > mitkCommandLineParser::getArgumentList()
 {
   std::vector < std::map<std::string, us::Any> > parameterList;
   //for (CommandLineParserArgumentDescription* argument : this->Internal->ArgumentDescriptionList)
   for (std::size_t i = 0; i< this->Internal->ArgumentDescriptionList.size(); ++i)
   {
     CommandLineParserArgumentDescription* argument = this->Internal->ArgumentDescriptionList[i];
     std::map<std::string, us::Any> tmpMap;
     //tmpMap["helptext"] = us::Any(argument->helpText);
     tmpMap["longarg"] = us::Any(argument->LongArg);
     tmpMap["longargprefix"] = us::Any(argument->LongArgPrefix);
     tmpMap["shortarg"] = us::Any(argument->ShortArg);
     tmpMap["shortargprefix"] = us::Any(argument->ShortArgPrefix);
     tmpMap["arghelp"] = us::Any(argument->ArgHelp);
     tmpMap["arglabel"] = us::Any(argument->ArgLabel);
     tmpMap["arggroup"] = us::Any(argument->ArgGroup);
     tmpMap["arggroupdescription"] = us::Any(argument->ArgGroupDescription);
     tmpMap["ignorerest"] = us::Any(argument->IgnoreRest);
     tmpMap["numberofparameterstoprocess"] = us::Any(argument->NumberOfParametersToProcess);
     tmpMap["deprecated"] = us::Any(argument->Deprecated);
     tmpMap["optional"] = us::Any(argument->Optional);
     tmpMap["defaultvalue"] = argument->DefaultValue;
     tmpMap["value"] = argument->Value;
     tmpMap["valuetype"] = us::Any(argument->ValueType);
     tmpMap["channel"] = us::Any(argument->Channel);
     parameterList.push_back(tmpMap);
   }
   return parameterList;
 }
 
 // --------------------------------------------------------------------------
 std::string::size_type mitkCommandLineParser::fieldWidth() const
 {
   return this->Internal->FieldWidth;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::beginGroup(const string &description)
 {
   this->Internal->CurrentGroup = description;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::endGroup()
 {
   this->Internal->CurrentGroup.clear();
 }
 
 // --------------------------------------------------------------------------
 string mitkCommandLineParser::helpText() const
 {
   string text;
   vector<CommandLineParserArgumentDescription *> deprecatedArgs;
 
   text = "Command Line Utility *" + Title + "* in Category *" + Category + "*\n";
   text += Description + "\n";
   text += Contributor + "\n\n";
   text += "Use --xml to generate an XML description parsable as a CTK Command Line Module Plugin.\n";
   text += "Use --version to print MITK revision information.\n";
 
   // Loop over grouped argument descriptions
   map<string, vector<CommandLineParserArgumentDescription *>>::iterator it;
   for (it = Internal->GroupToArgumentDescriptionListMap.begin();
        it != Internal->GroupToArgumentDescriptionListMap.end();
        ++it)
   {
     if (!(*it).first.empty())
     {
       text = text + "\n" + (*it).first + "\n";
     }
 
     vector<CommandLineParserArgumentDescription *>::iterator it2;
     for (it2 = (*it).second.begin(); it2 != (*it).second.end(); ++it2)
     {
       CommandLineParserArgumentDescription *argDesc = *it2;
       if (argDesc->Deprecated)
       {
         deprecatedArgs.push_back(argDesc);
       }
       else
       {
         text += argDesc->helpText();
       }
     }
   }
 
   if (!deprecatedArgs.empty())
   {
     text += "\nDeprecated arguments:\n";
     vector<CommandLineParserArgumentDescription *>::iterator it2;
     for (it2 = deprecatedArgs.begin(); it2 != deprecatedArgs.end(); ++it2)
     {
       CommandLineParserArgumentDescription *argDesc = *it2;
       text += argDesc->helpText();
     }
   }
 
   return text;
 }
 
 // --------------------------------------------------------------------------
 bool mitkCommandLineParser::argumentAdded(const string &argument) const
 {
   return (this->Internal->ArgNameToArgumentDescriptionMap.count(argument) != 0);
 }
 
 // --------------------------------------------------------------------------
 bool mitkCommandLineParser::argumentParsed(const string &argument) const
 {
   for (unsigned int i = 0; i < Internal->ProcessedArguments.size(); i++)
     if (argument.compare(Internal->ProcessedArguments.at(i)) == 0)
       return true;
   return false;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::setArgumentPrefix(const string &longPrefix, const string &shortPrefix)
 {
   this->Internal->LongPrefix = longPrefix;
   this->Internal->ShortPrefix = shortPrefix;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::setStrictModeEnabled(bool strictMode)
 {
   this->Internal->StrictMode = strictMode;
 }
 
 
 void mitkCommandLineParser::generateXmlOutput()
 {
   std::stringstream xml;
 
   xml << "<executable>" << endl;
   xml << "<category>" << Category << "</category>" << endl;
   xml << "<title>" << Title << "</title>" << endl;
   xml << "<description>" << Description << "</description>" << endl;
   xml << "<contributor>" << Contributor << "</contributor>" << endl;
   xml << "<parameters>" << endl;
 
   std::vector<CommandLineParserArgumentDescription *>::iterator it;
 
   std::string lastParameterGroup = "";
   for (it = this->Internal->ArgumentDescriptionList.begin(); it != this->Internal->ArgumentDescriptionList.end(); it++)
   {
     std::string type;
     switch ((*it)->ValueType)
     {
     case mitkCommandLineParser::String:
       type = "string";
       break;
 
     case mitkCommandLineParser::Bool:
       type = "boolean";
       break;
 
     case mitkCommandLineParser::StringList:
       type = "string-vector";
       break;
 
     case mitkCommandLineParser::Int:
       type = "integer";
       break;
 
     case mitkCommandLineParser::Float:
       type = "float";
       break;
 
     case mitkCommandLineParser::Directory:
       type = "directory";
       break;
 
     case mitkCommandLineParser::Image:
       type = "image";
       break;
 
     case mitkCommandLineParser::File:
       type = "file";
       break;
     }
 
     if (lastParameterGroup.compare((*it)->ArgGroup))
     {
       if (it != this->Internal->ArgumentDescriptionList.begin())
       {
         xml << "</parameters>" << endl;
         xml << "<parameters>" << endl;
       }
       xml << "<label>" << (*it)->ArgGroup << "</label>" << endl;
       xml << "<description>" << (*it)->ArgGroupDescription << "</description>" << endl;
       lastParameterGroup = (*it)->ArgGroup;
     }
 
     // Skip help item, as it's no use in GUI
     if ((*it)->ShortArg == "h")
       continue;
 
     auto name = (*it)->LongArg;
     if (name.empty())
       name = (*it)->ShortArg;
 
     xml << "<" << type << ">" << endl;
     xml << "<name>" << name << "</name>" << endl;
     xml << "<description>" << (*it)->ArgHelp << "</description>" << endl;
     xml << "<label>" << (*it)->ArgLabel << "</label>" << endl;
     if (!(*it)->DefaultValue.Empty())
       xml << "<default>" << (*it)->DefaultValue.ToString() << "</default>" << endl;
 
     xml << "<longflag>" << (*it)->LongArg << "</longflag>" << endl;
     xml << "<flag>" << (*it)->ShortArg << "</flag>" << endl;
 
     if (((*it)->ValueType == mitkCommandLineParser::File ||
          (*it)->ValueType == mitkCommandLineParser::Directory ||
          (*it)->ValueType == mitkCommandLineParser::Image) &&
         (*it)->Channel == mitkCommandLineParser::Channel::Input)
     {
       xml << "<channel>input</channel>" << endl;
     }
     else if (((*it)->ValueType == mitkCommandLineParser::File ||
               (*it)->ValueType == mitkCommandLineParser::Directory ||
               (*it)->ValueType == mitkCommandLineParser::Image) &&
              (*it)->Channel == mitkCommandLineParser::Channel::Output)
     {
       xml << "<channel>output</channel>" << endl;
     }
     else if ((*it)->Channel == mitkCommandLineParser::Channel::Output ||
              (*it)->Channel == mitkCommandLineParser::Channel::Input)
     {
       std::cout << "Only the types Directory, File or Image may be flagged as Input or Output! Ignoring flag for parameter " + name << std::endl;
     }
     xml << "</" << type << ">" << endl;
   }
 
   xml << "</parameters>" << endl;
   xml << "</executable>" << endl;
 
   cout << xml.str();
 }
 
 void mitkCommandLineParser::setTitle(string title)
 {
   Title = title;
 }
 void mitkCommandLineParser::setContributor(string contributor)
 {
   Contributor = contributor;
 }
 
 void mitkCommandLineParser::setCategory(string category)
 {
   Category = category;
 }
 
 void mitkCommandLineParser::setDescription(string description)
 {
   Description = description;
 }
 
 void mitkCommandLineParser::changeParameterGroup(string name, string tooltip)
 {
   ParameterGroupName = name;
   ParameterGroupDescription = tooltip;
 }
diff --git a/Modules/Core/resource/Interactions/Legacy/DisplayConfigMITKTools.xml b/Modules/Core/resource/Interactions/Legacy/DisplayConfigMITKTools.xml
index 4836b9b51b..61c49425df 100644
--- a/Modules/Core/resource/Interactions/Legacy/DisplayConfigMITKTools.xml
+++ b/Modules/Core/resource/Interactions/Legacy/DisplayConfigMITKTools.xml
@@ -1,49 +1,49 @@
 <!--
 * - MITK : The legacy handling for Tools.
     Describes which events should trigger an event_variant.
     The corresponding event_variants and their actions are declared in DisplayConfig.xml (in /Resources/Interactions).
     If no event_variant is specified here, this action is disabled during the activation of a tool.
     So if an action here conflicts with you tool you can comment out this section.
     ! Alternatively you can also just change the event description, so that the actions are triggered by different mouse/key events
     during Tool use. !
-    Refer to 'How to create a Config-File' http://docs.mitk.org/nightly/Step10Page.html for details.
+    Refer to 'How to create a Config-File' https://docs.mitk.org/nightly/Step10Page.html for details.
 
 *   - middle mouse button : panning
 *   - right mouse button  : zooming
 *   - wheel               : scrolling
 -->
 <config>
   <!-- Zoom sensitivity -->
   <param name="zoomFactor" value="5"/>
   <!-- Zoom either by moving mouse leftright or updown -->
   <param name="zoomDirection" value="leftright"/>
   <!-- react to an event, even tough is was already processed by a DataInteractor-->
   <param name="alwaysReact" value="false"/>
   <!-- Moving -->
   <event_variant class="MousePressEvent" name="StartMove">
     <attribute name="EventButton" value="MiddleMouseButton"/>
   </event_variant>
   <event_variant class="MouseReleaseEvent" name="EndMoving">
     <attribute name="EventButton" value="MiddleMouseButton"/>
   </event_variant>
   <event_variant class="MouseMoveEvent" name="Moving">
     <attribute name="ButtonState" value="MiddleMouseButton"/>
   </event_variant>
   <!-- Zooming -->
   <event_variant class="MousePressEvent" name="StartZoom">
     <attribute name="EventButton" value="RightMouseButton"/>
   </event_variant>
    <event_variant class="MouseMoveEvent" name="Zooming">
     <attribute name="ButtonState" value="RightMouseButton"/>
   </event_variant>
   <event_variant class="MouseReleaseEvent" name="EndZooming">
     <attribute name="EventButton" value="RightMouseButton"/>
   </event_variant>
   <!-- Scrolling trough planes -->
   <event_variant class="MouseWheelEvent" name="PlaneUP">
     <attribute name="ScrollDirection" value="up"/>
   </event_variant>
   <event_variant class="MouseWheelEvent" name="PlaneDown">
     <attribute name="ScrollDirection" value="down"/>
   </event_variant>
 </config>
diff --git a/Modules/Core/resource/mitkAnatomicalStructureColorPresets.xml b/Modules/Core/resource/mitkAnatomicalStructureColorPresets.xml
index aacfce3746..5e6bb30325 100644
--- a/Modules/Core/resource/mitkAnatomicalStructureColorPresets.xml
+++ b/Modules/Core/resource/mitkAnatomicalStructureColorPresets.xml
@@ -1,760 +1,760 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <!--
 * Source
   Based on: https://www.slicer.org/slicerWiki/index.php/Documentation/4.5/SlicerApplication/LookupTables/GenericAnatomyColors
   Authors: Michael Halle, Florin Talos, Ron Kikinis, Steve Pieper, Nicole Aucoin, Marianna Jakab
 *Coding scheme:
-  http://dicom.nema.org/medical/dicom/current/output/html/part16.html
+  https://dicom.nema.org/medical/dicom/current/output/html/part16.html
 *Modifier
-    http://dicom.nema.org/dicom/2013/output/chtml/part16/chapter_B.html#sect_CID_2
+    https://dicom.nema.org/dicom/2013/output/chtml/part16/chapter_B.html#sect_CID_2
 -->
 <mitkAnatomicalStructureColorPresets file_version="0.1" >
   <preset name="Abdomen">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D4000" coding_scheme="SRT" code_name="Abdomen"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Adenohypophysis">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-B1100" coding_scheme="SRT" code_name="Adenohypophysis"/>
     <color rgb_r="60" rgb_g="143" rgb_b="83"/>
   </preset>
   <preset name="Adrenal gland">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-B3000" coding_scheme="SRT" code_name="Adrenal Gland"/>
     <color rgb_r="249" rgb_g="186" rgb_b="150"/>
   </preset>
   <preset name="Adrenal gland (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-B3000" coding_scheme="SRT" code_name="Adrenal Gland">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="249" rgb_g="186" rgb_b="150"/>
   </preset>
   <preset name="Adrenal gland (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-B3000" coding_scheme="SRT" code_name="Adrenal Gland">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="249" rgb_g="186" rgb_b="150"/>
   </preset>
   <preset name="Amygdala">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-A3230" coding_scheme="SRT" code_name="Amygdala"/>
     <color rgb_r="98" rgb_g="153" rgb_b="112"/>
   </preset>
     <preset name="Amygdala (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-A3230" coding_scheme="SRT" code_name="Amygdala">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="98" rgb_g="153" rgb_b="112"/>
   </preset>
   <preset name="Amygdala (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-A3230" coding_scheme="SRT" code_name="Amygdala">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="98" rgb_g="153" rgb_b="112"/>
   </preset>
   <preset name="Anus">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-59900" coding_scheme="SRT" code_name="Anus"/>
     <color rgb_r="255" rgb_g="224" rgb_b="199"/>
   </preset>
   <preset name="Aorta">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-42000" coding_scheme="SRT" code_name="Aorta"/>
     <color rgb_r="224" rgb_g="97" rgb_b="76"/>
   </preset>
   <preset name="Aortic valve">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-35400" coding_scheme="SRT" code_name="Aortic Valve"/>
     <color rgb_r="218" rgb_g="123" rgb_b="97"/>
   </preset>
   <preset name="Appendix">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-59200" coding_scheme="SRT" code_name="Appendix"/>
     <color rgb_r="161" rgb_g="107" rgb_b="54"/> <!-- Old color scheme-->
   </preset>
   <preset name="Artery">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-41066" coding_scheme="SRT" code_name="Artery"/>
     <color rgb_r="216" rgb_g="101" rgb_b="79"/>
   </preset>
   <preset name="Bile ">
     <category code_value="T-D0080" coding_scheme="SRT" code_name="Body Substance"/>
     <type code_value="T-60650" coding_scheme="SRT" code_name="Bile"/>
     <color rgb_r="0" rgb_g="145" rgb_b="30"/>
   </preset>
   <preset name="Bile duct">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-60610" coding_scheme="SRT" code_name="Bile Duct"/>
     <color rgb_r="0" rgb_g="145" rgb_b="30"/>
   </preset>
   <preset name="Bladder">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-74000" coding_scheme="SRT" code_name="Bladder"/>
     <color rgb_r="222" rgb_g="154" rgb_b="132"/>
   </preset>
   <preset name="Blood clot">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-35000" coding_scheme="SRT" code_name="Blood Clot"/>
     <color rgb_r="145" rgb_g="60" rgb_b="66"/>
   </preset>
   <preset name="Blood vessel">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-40000" coding_scheme="SRT" code_name="Blood Vessel"/>
     <color rgb_r="255" rgb_g="49" rgb_b="49"/> <!-- Old color scheme-->
   </preset>
   <preset name="Bone">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-D016E" coding_scheme="SRT" code_name="Bone"/>
     <color rgb_r="241" rgb_g="214" rgb_b="145"/>
   </preset>
   <preset name="Brain">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-A0100" coding_scheme="SRT" code_name="Brain"/>
     <color rgb_r="250" rgb_g="250" rgb_b="225"/>
   </preset>
   <preset name="Bronchi">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-A0100" coding_scheme="SRT" code_name="Bronchi"/>
     <color rgb_r="175" rgb_g="216" rgb_b="244"/>
   </preset>
   <preset name="Capillary">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-40050" coding_scheme="SRT" code_name="Capillary"/>
     <color rgb_r="183" rgb_g="156" rgb_b="220"/>
   </preset>
   <preset name="Cartilage">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-D021B" coding_scheme="SRT" code_name="Cartilage"/>
     <color rgb_r="111" rgb_g="184" rgb_b="210"/>
   </preset>
   <preset name="Cerebellar white matter">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-A6080" coding_scheme="SRT" code_name="Cerebellar White Matter"/>
     <color rgb_r="194" rgb_g="195" rgb_b="164"/>
   </preset>
   <preset name="Cerebral grey matter">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-A2020" coding_scheme="SRT" code_name="Cerebral Grey Matter"/>
     <color rgb_r="128" rgb_g="174" rgb_b="128"/>
   </preset>
   <preset name="Cerebral white matter">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-A2030" coding_scheme="SRT" code_name="Cerebral White Matter"/>
     <color rgb_r="250" rgb_g="250" rgb_b="225"/>
   </preset>
   <preset name="Chest">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D3000" coding_scheme="SRT" code_name="Chest"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Colon">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-59302" coding_scheme="SRT" code_name="Colon"/>
     <color rgb_r="204" rgb_g="168" rgb_b="143"/>
   </preset>
   <preset name="Coccyx">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-11BF0" coding_scheme="SRT" code_name="Coccyx"/>
     <color rgb_r="255" rgb_g="255" rgb_b="153"/>
   </preset>
   <preset name="Duodenum">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-58200" coding_scheme="SRT" code_name="Duodenum"/>
     <color rgb_r="255" rgb_g="253" rgb_b="229"/>
   </preset>
   <preset name="Cyst">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-3340A" coding_scheme="SRT" code_name="Cyst"/>
     <color rgb_r="205" rgb_g="205" rgb_b="100"/>
   </preset>
   <preset name="Edema">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-36300" coding_scheme="SRT" code_name="Edema"/>
     <color rgb_r="140" rgb_g="224" rgb_b="228"/>
   </preset>
   <preset name="Elbow">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D06CA" coding_scheme="SRT" code_name="Elbow"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Elbow (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D06CA" coding_scheme="SRT" code_name="Elbow">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Elbow (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D06CA" coding_scheme="SRT" code_name="Elbow">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Embolus">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-35300" coding_scheme="SRT" code_name="Embolus"/>
     <color rgb_r="150" rgb_g="98" rgb_b="83"/>
   </preset>
   <preset name="Esophagus">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-56000" coding_scheme="SRT" code_name="Esophagus"/>
     <color rgb_r="211" rgb_g="171" rgb_b="143"/>
   </preset>
   <preset name="Eyeball">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-AA636" coding_scheme="SRT" code_name="Fundus of Eye"/>
     <color rgb_r="194" rgb_g="142" rgb_b="0"/>
   </preset>
   <preset name="Eyeball (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-AA636" coding_scheme="SRT" code_name="Fundus of Eye">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="194" rgb_g="142" rgb_b="0"/>
   </preset>
   <preset name="Eyeball (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-AA636" coding_scheme="SRT" code_name="Fundus of Eye">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="194" rgb_g="142" rgb_b="0"/>
   </preset>
   <preset name="Fallopian tube">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D6101" coding_scheme="SRT" code_name="Fallopian Tube"/>
     <color rgb_r="255" rgb_g="190" rgb_b="165"/>
   </preset>
   <preset name="Fallopian tube (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D6101" coding_scheme="SRT" code_name="Fallopian Tube">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="255" rgb_g="190" rgb_b="165"/>
   </preset>
   <preset name="Fallopian tube (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D6101" coding_scheme="SRT" code_name="Fallopian Tube">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="255" rgb_g="190" rgb_b="165"/>
   </preset>
   <preset name="Fat">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="F-03D38" coding_scheme="SRT" code_name="Body Fat"/>
     <color rgb_r="230" rgb_g="220" rgb_b="70"/>
   </preset>
   <preset name="Feces">
     <category code_value="T-D0080" coding_scheme="SRT" code_name="Body Substance"/>
     <type code_value="T-59666" coding_scheme="SRT" code_name="Feces"/>
     <color rgb_r="78" rgb_g="63" rgb_b="0"/>
   </preset>
   <preset name="Foot">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D9700" coding_scheme="SRT" code_name="Foot"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Foot (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D9700" coding_scheme="SRT" code_name="Foot">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
     <preset name="Foot (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D9700" coding_scheme="SRT" code_name="Foot">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Gallbladder">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-63002" coding_scheme="SRT" code_name="Gallbladder"/>
     <color rgb_r="139" rgb_g="150" rgb_b="98"/>
   </preset>
   <preset name="Gas">
     <category code_value="T-D0080" coding_scheme="SRT" code_name="Body Substance"/>
     <type code_value="C-10080" coding_scheme="SRT" code_name="Gas"/>
     <color rgb_r="218" rgb_g="255" rgb_b="255"/>
   </preset>
   <preset name="Hand">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D8701" coding_scheme="SRT" code_name="Hand"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Hand (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D8701" coding_scheme="SRT" code_name="Hand">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Hand (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D8701" coding_scheme="SRT" code_name="Hand">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Heart">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-32000" coding_scheme="SRT" code_name="Heart"/>
     <color rgb_r="206" rgb_g="110" rgb_b="84"/>
   </preset>
   <preset name="Hemorrhage">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-37000" coding_scheme="SRT" code_name="Hemorrhage"/>
     <color rgb_r="188" rgb_g="65" rgb_b="28"/>
   </preset>
   <preset name="Hip">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D2503" coding_scheme="SRT" code_name="Hip Region"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Hip (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D2503" coding_scheme="SRT" code_name="Hip Region">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Hip (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D2503" coding_scheme="SRT" code_name="Hip Region">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Kidney">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-71000" coding_scheme="SRT" code_name="Kidney"/>
     <color rgb_r="185" rgb_g="102" rgb_b="83"/>
   </preset>
   <preset name="Kidney (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-71000" coding_scheme="SRT" code_name="Kidney">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="185" rgb_g="102" rgb_b="83"/>
   </preset>
   <preset name="Kidney (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-71000" coding_scheme="SRT" code_name="Kidney">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="185" rgb_g="102" rgb_b="83"/>
   </preset>
   <preset name="Knee">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D03BA" coding_scheme="SRT" code_name="Knee Region"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Knee (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D03BA" coding_scheme="SRT" code_name="Knee Region">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Knee (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D03BA" coding_scheme="SRT" code_name="Knee Region">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Larynx">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-2410C" coding_scheme="SRT" code_name="Larynx"/>
     <color rgb_r="150" rgb_g="208" rgb_b="243"/>
   </preset>
   <preset name="Ligament">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-18010" coding_scheme="SRT" code_name="Ligament"/>
     <color rgb_r="183" rgb_g="214" rgb_b="211"/>
   </preset>
   <preset name="Lesion">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-01100" coding_scheme="SRT" code_name="Lesion"/>
     <color rgb_r="221" rgb_g="130" rgb_b="101"/>
   </preset>
   <preset name="Liver">
     <category  code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-62000" coding_scheme="SRT" code_name="Liver"/>
     <color rgb_r="221" rgb_g="130" rgb_b="101"/>
   </preset>
   <preset name="Lung">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-28000" coding_scheme="SRT" code_name="Lung"/>
     <color rgb_r="197" rgb_g="165" rgb_b="145"/>
   </preset>
   <preset name="Lung (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-28000" coding_scheme="SRT" code_name="Lung">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="197" rgb_g="165" rgb_b="145"/>
   </preset>
   <preset name="Lung (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-28000" coding_scheme="SRT" code_name="Lung">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="197" rgb_g="165" rgb_b="145"/>
   </preset>
   <preset name="Lymph node">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-C4000" coding_scheme="SRT" code_name="Lymph Node"/>
     <color rgb_r="68" rgb_g="172" rgb_b="100"/>
   </preset>
   <preset name="Lymph node of head">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-C4100" coding_scheme="SRT" code_name="Lymph Node of Head"/>
     <color rgb_r="68" rgb_g="172" rgb_b="100"/>
   </preset>
   <preset name="Lymph node of head and neck">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-C4004" coding_scheme="SRT" code_name="Lymph Node of Head and Neck"/>
     <color rgb_r="68" rgb_g="172" rgb_b="100"/>
   </preset>
   <preset name="Lymphatic vessel">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-C6010" coding_scheme="SRT" code_name="Lymphatic Vessel"/>
     <color rgb_r="111" rgb_g="197" rgb_b="131"/>
   </preset>
   <preset name="Mandible">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-11180" coding_scheme="SRT" code_name="Mandible"/>
     <color rgb_r="222" rgb_g="198" rgb_b="101"/>
   </preset>
   <preset name="Mass">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-03000" coding_scheme="SRT" code_name="Mass"/>
     <color rgb_r="144" rgb_g="238" rgb_b="144"/>
   </preset>
   <preset name="Mediastinum">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D3300" coding_scheme="SRT" code_name="Mediastinum"/>
     <color rgb_r="255" rgb_g="244" rgb_b="209"/>
   </preset>
   <preset name="Mitral valve">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-35300" coding_scheme="SRT" code_name="Mitral Valve"/>
     <color rgb_r="159" rgb_g="63" rgb_b="27"/>
   </preset>
   <preset name="Muscle">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-13001" coding_scheme="SRT" code_name="Muscle"/>
     <color rgb_r="192" rgb_g="104" rgb_b="88"/>
   </preset>
   <preset name="Necrosis">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-54000" coding_scheme="SRT" code_name="Necrosis"/>
     <color rgb_r="216" rgb_g="191" rgb_b="216"/>
   </preset>
   <preset name="Needle">
     <category code_value="A-00004" coding_scheme="SRT" code_name="Physical Object"/>
     <type code_value="A-30360" coding_scheme="SRT" code_name="Needle"/>
     <color rgb_r="240" rgb_g="255" rgb_b="30"/>
   </preset>
   <preset name="Neoplasm, primary">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-80003" coding_scheme="SRT" code_name="Neoplasm, Primary"/>
     <color rgb_r="128" rgb_g="174" rgb_b="128"/>
   </preset>
    <preset name="Neoplasm, secondary">
     <category code_value="M-01000" coding_scheme="SRT" code_name="Morphologically Altered Structure"/>
     <type code_value="M-80006" coding_scheme="SRT" code_name="Neoplasm, Secondary"/>
     <color rgb_r="241" rgb_g="214" rgb_b="145"/>
   </preset>
   <preset name="Nerve">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-D0598" coding_scheme="SRT" code_name="Nerve"/>
     <color rgb_r="244" rgb_g="214" rgb_b="49"/>
   </preset>
   <preset name="Nose">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-21003" coding_scheme="SRT" code_name="Nose"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Organ">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-1A310" coding_scheme="SRT" code_name="Organ"/>
     <color rgb_r="221" rgb_g="130" rgb_b="101"/>
   </preset>
   <preset name="Ovary">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-87000" coding_scheme="SRT" code_name="Ovary"/>
     <color rgb_r="213" rgb_g="141" rgb_b="113"/>
   </preset>
   <preset name="Ovary (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-87000" coding_scheme="SRT" code_name="Ovary">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="213" rgb_g="141" rgb_b="113"/>
   </preset>
   <preset name="Ovary (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-87000" coding_scheme="SRT" code_name="Ovary">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="213" rgb_g="141" rgb_b="113"/>
   </preset>
   <preset name="Pancreas">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D4034" coding_scheme="SRT" code_name="Pancreas"/>
     <color rgb_r="249" rgb_g="180" rgb_b="111"/>
   </preset>
   <preset name="Pelvis">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-12375" coding_scheme="SRT" code_name="Pelvis"/>
     <color rgb_r="255" rgb_g="255" rgb_b="153"/><!-- Old color scheme-->
   </preset>
   <preset name="Penis">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-91000" coding_scheme="SRT" code_name="Penis"/>
     <color rgb_r="255" rgb_g="222" rgb_b="199"/><!-- Old color scheme-->
   </preset>
   <preset name="Pericardium">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-39000" coding_scheme="SRT" code_name="Pericardium"/>
     <color rgb_r="255" rgb_g="244" rgb_b="209"/>
   </preset>
   <preset name="Peritioneum">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D4400" coding_scheme="SRT" code_name="Peritioneum"/>
     <color rgb_r="255" rgb_g="255" rgb_b="220"/>
   </preset>
   <preset name="Pharynx">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-55002" coding_scheme="SRT" code_name="Pharynx"/>
     <color rgb_r="184" rgb_g="105" rgb_b="108"/>
   </preset>
   <preset name="Prostate">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-92000" coding_scheme="SRT" code_name="Prostate"/>
     <color rgb_r="230" rgb_g="158" rgb_b="140"/>
   </preset>
   <preset name="Right ventricle">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-32500" coding_scheme="SRT" code_name="Right Ventricle"/>
     <color rgb_r="181" rgb_g="85" rgb_b="57"/>
   </preset>
   <preset name="Rectum">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-59600" coding_scheme="SRT" code_name="Rectum"/>
     <color rgb_r="161" rgb_g="107" rgb_b="54"/><!-- Old color scheme-->
   </preset>
   <preset name="Sacrum">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-11AD0" coding_scheme="SRT" code_name="Sacrum"/>
     <color rgb_r="255" rgb_g="255" rgb_b="153"/><!-- Old color scheme-->
   </preset>
   <preset name="Seminal vesicle">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-93000" coding_scheme="SRT" code_name="Seminal Vesicle"/>
     <color rgb_r="245" rgb_g="172" rgb_b="147"/>
   </preset>
   <preset name="Seminal vesicle (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-93000" coding_scheme="SRT" code_name="Seminal Vesicle">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="245" rgb_g="172" rgb_b="147"/>
   </preset>
   <preset name="Seminal vesicle (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-93000" coding_scheme="SRT" code_name="Seminal Vesicle">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="245" rgb_g="172" rgb_b="147"/>
   </preset>
   <preset name="Shoulder">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D2220" coding_scheme="SRT" code_name="Shoulder"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Shoulder (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D2220" coding_scheme="SRT" code_name="Shoulder">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Shoulder (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D2220" coding_scheme="SRT" code_name="Shoulder">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Skin">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-01000" coding_scheme="SRT" code_name="Skin"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Skull">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-11100" coding_scheme="SRT" code_name="Skull"/>
     <color rgb_r="241" rgb_g="213" rgb_b="144"/>
   </preset>
   <preset name="Small intestine">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-58000" coding_scheme="SRT" code_name="Small Intestine"/>
     <color rgb_r="205" rgb_g="167" rgb_b="142"/>
   </preset>
   <preset name="Spinal cord">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-A7013" coding_scheme="SRT" code_name="Spinal Cord"/>
     <color rgb_r="244" rgb_g="214" rgb_b="49"/>
   </preset>
   <preset name="Spleen">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-C3000" coding_scheme="SRT" code_name="Spleen"/>
     <color rgb_r="157" rgb_g="108" rgb_b="162"/>
   </preset>
   <preset name="Sternum">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-11210" coding_scheme="SRT" code_name="Sternum"/>
     <color rgb_r="244" rgb_g="217" rgb_b="154"/>
   </preset>
   <preset name="Stomach">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-57001" coding_scheme="SRT" code_name="Stomach"/>
     <color rgb_r="216" rgb_g="132" rgb_b="105"/>
   </preset>
   <preset name="Teeth">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-5401E" coding_scheme="SRT" code_name="Tooth"/>
     <color rgb_r="255" rgb_g="250" rgb_b="220"/>
   </preset>
   <preset name="Tendon">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-17010" coding_scheme="SRT" code_name="Tendon"/>
     <color rgb_r="152" rgb_g="189" rgb_b="207"/>
   </preset>
   <preset name="Testicle">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-94000" coding_scheme="SRT" code_name="Testis"/>
     <color rgb_r="199" rgb_g="232" rgb_b="255"/><!-- Old color scheme-->
   </preset>
   <preset name="Testis (right)">
     <category  code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-94000" coding_scheme="SRT" code_name="Testis">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="199" rgb_g="232" rgb_b="255"/><!-- Old color scheme-->
   </preset>
   <preset name="Testis (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-94000" coding_scheme="SRT" code_name="Testis">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="199" rgb_g="232" rgb_b="255"/><!-- Old color scheme-->
   </preset>
   <preset name="Thalamus">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D0593" coding_scheme="SRT" code_name="Thalamus"/>
     <color rgb_r="122" rgb_g="101" rgb_b="38"/>
   </preset>
   <preset name="Thalamus (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D0593" coding_scheme="SRT" code_name="Thalamus">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="122" rgb_g="101" rgb_b="38"/>
   </preset>
     <preset name="Thalamus (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D0593" coding_scheme="SRT" code_name="Thalamus">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="122" rgb_g="101" rgb_b="38"/>
   </preset>  
   <preset name="Thymus">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-C8000" coding_scheme="SRT" code_name="Thymus"/>
     <color rgb_r="47" rgb_g="150" rgb_b="103"/>
   </preset>
   <preset name="Thyroid gland">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-B0004" coding_scheme="SRT" code_name="Thyroid Gland"/>
     <color rgb_r="62" rgb_g="162" rgb_b="114"/>
   </preset>
   <preset name="Tissue">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <color rgb_r="128" rgb_g="174" rgb_b="128"/>
   </preset>
   <preset name="Tongue">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-5300D" coding_scheme="SRT" code_name="Tongue"/>
     <color rgb_r="166" rgb_g="84" rgb_b="94"/>
   </preset>
   <preset name="Trachea">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-25000" coding_scheme="SRT" code_name="Trachea"/>
     <color rgb_r="182" rgb_g="228" rgb_b="255"/>
   </preset>
   <preset name="Urethra">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-75001" coding_scheme="SRT" code_name="Urethra"/>
     <color rgb_r="124" rgb_g="186" rgb_b="223"/>
   </preset>
   <preset name="Urine">
     <category code_value="T-D0080" coding_scheme="SRT" code_name="Body Substance"/>
     <type code_value="T-70060" coding_scheme="SRT" code_name="Urine"/>
     <color rgb_r="214" rgb_g="230" rgb_b="130"/>
   </preset>
   <preset name="Urinary bladder">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-74000" coding_scheme="SRT" code_name="Bladder"/>
     <color rgb_r="222" rgb_g="154" rgb_b="132"/>
   </preset>
   <preset name="Uterus">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-83000" coding_scheme="SRT" code_name="Uterus"/>
     <color rgb_r="255" rgb_g="181" rgb_b="158"/>
   </preset>
   <preset name="Vagina">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-82003" coding_scheme="SRT" code_name="Vagina"/>
     <color rgb_r="193" rgb_g="123" rgb_b="103"/>
   </preset>
   <preset name="Vein">
     <category code_value="T-D0050" coding_scheme="SRT" code_name="Tissue"/>
     <type code_value="T-4806E" coding_scheme="SRT" code_name="Vein"/>
     <color rgb_r="0" rgb_g="151" rgb_b="206"/>
   </preset>
   <preset name="Vertebra">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-11510" coding_scheme="SRT" code_name="Vertebra"/>
     <color rgb_r="255" rgb_g="255" rgb_b="153"/> <!-- Old color scheme-->
   </preset>
   <preset name="Wrist">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D0787" coding_scheme="SRT" code_name="Wrist Region"/>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Wrist (right)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D0787" coding_scheme="SRT" code_name="Wrist Region">
       <modifier code_value="G-A100" coding_scheme="SRT" code_name="Right"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
   <preset name="Wrist (left)">
     <category code_value="T-D000A" coding_scheme="SRT" code_name="Anatomical Structure"/>
     <type code_value="T-D0787" coding_scheme="SRT" code_name="Wrist Region">
       <modifier code_value="G-A101" coding_scheme="SRT" code_name="Left"/>
     </type>
     <color rgb_r="177" rgb_g="122" rgb_b="101"/>
   </preset>
 </mitkAnatomicalStructureColorPresets>
diff --git a/Modules/Core/test/mitkPlaneGeometryTest.cpp b/Modules/Core/test/mitkPlaneGeometryTest.cpp
index f255f79b46..bf61cc4606 100644
--- a/Modules/Core/test/mitkPlaneGeometryTest.cpp
+++ b/Modules/Core/test/mitkPlaneGeometryTest.cpp
@@ -1,1093 +1,1093 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkAffineTransform3D.h"
 #include "mitkBaseGeometry.h"
 #include "mitkGeometry3D.h"
 #include "mitkInteractionConst.h"
 #include "mitkLine.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkRotationOperation.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkThinPlateSplineCurvedGeometry.h"
 
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_quaternion.hxx>
 
 #include <fstream>
 #include <iomanip>
 #include <mitkIOUtil.h>
 #include <mitkImage.h>
 
 static const mitk::ScalarType testEps = 1E-9; // the epsilon used in this test == at least float precision.
 
 class mitkPlaneGeometryTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkPlaneGeometryTestSuite);
   MITK_TEST(TestInitializeStandardPlane);
   MITK_TEST(TestProjectPointOntoPlane);
   MITK_TEST(TestPlaneGeometryCloning);
   MITK_TEST(TestInheritance);
   MITK_TEST(TestSetExtendInMM);
   MITK_TEST(TestRotate);
   MITK_TEST(TestClone);
   MITK_TEST(TestPlaneComparison);
   MITK_TEST(TestAxialInitialization);
   MITK_TEST(TestCoronalInitialization);
   MITK_TEST(TestSagittalInitialization);
   MITK_TEST(TestLefthandedCoordinateSystem);
   MITK_TEST(TestDominantAxesError);
   MITK_TEST(TestCheckRotationMatrix);
 
   // Currently commented out, see See bug 15990
   // MITK_TEST(testPlaneGeometryInitializeOrder);
   MITK_TEST(TestIntersectionPoint);
   MITK_TEST(TestCase1210);
 
   CPPUNIT_TEST_SUITE_END();
 
 private:
   // private test members that are initialized by setUp()
   mitk::PlaneGeometry::Pointer planegeometry;
   mitk::Point3D origin;
   mitk::Vector3D right, bottom, normal, spacing;
   mitk::ScalarType width, height;
   mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
 
 public:
   void setUp() override
   {
     planegeometry = mitk::PlaneGeometry::New();
     width = 100;
     widthInMM = width;
     height = 200;
     heightInMM = height;
     thicknessInMM = 1.0;
     mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
     mitk::FillVector3D(right, widthInMM, 0, 0);
     mitk::FillVector3D(bottom, 0, heightInMM, 0);
     mitk::FillVector3D(normal, 0, 0, thicknessInMM);
     mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
 
     planegeometry->InitializeStandardPlane(right, bottom);
     planegeometry->SetOrigin(origin);
     planegeometry->SetSpacing(spacing);
   }
 
   void tearDown() override {}
   // This test verifies inheritance behaviour, this test will fail if the behaviour changes in the future
   void TestInheritance()
   {
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
     mitk::Geometry3D::Pointer g3d = dynamic_cast<mitk::Geometry3D *>(plane.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Planegeometry should not be castable to Geometry 3D", g3d.IsNull());
 
     mitk::BaseGeometry::Pointer base = dynamic_cast<mitk::BaseGeometry *>(plane.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Planegeometry should be castable to BaseGeometry", base.IsNotNull());
 
     g3d = mitk::Geometry3D::New();
     base = dynamic_cast<mitk::BaseGeometry *>(g3d.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Geometry3D should be castable to BaseGeometry", base.IsNotNull());
 
     mitk::SlicedGeometry3D::Pointer sliced = mitk::SlicedGeometry3D::New();
     g3d = dynamic_cast<mitk::Geometry3D *>(sliced.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("SlicedGeometry3D should not be castable to Geometry3D", g3d.IsNull());
 
     mitk::ThinPlateSplineCurvedGeometry::Pointer thin = mitk::ThinPlateSplineCurvedGeometry::New();
     plane = dynamic_cast<mitk::PlaneGeometry *>(thin.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("AbstractTransformGeometry should be castable to PlaneGeometry", plane.IsNotNull());
 
     plane = mitk::PlaneGeometry::New();
     mitk::AbstractTransformGeometry::Pointer atg = dynamic_cast<mitk::AbstractTransformGeometry *>(plane.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("PlaneGeometry should not be castable to AbstractTransofrmGeometry", atg.IsNull());
   }
 
   void TestDominantAxesError()
   {
     auto image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("NotQuiteARotationMatrix.nrrd"));
     auto matrix = image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().transpose();
     std::vector< int > axes = mitk::PlaneGeometry::CalculateDominantAxes(matrix);
     CPPUNIT_ASSERT_MESSAGE("Domiant axes cannot be determined in this dataset. Output should be default ordering.", axes.at(0)==0 && axes.at(1)==1 && axes.at(2)==2);
   }
 
   void TestCheckRotationMatrix()
   {
     auto image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("NotQuiteARotationMatrix.nrrd"));
     bool is_rotation = mitk::PlaneGeometry::CheckRotationMatrix(image->GetGeometry()->GetIndexToWorldTransform(), 1e-8);
     CPPUNIT_ASSERT_MESSAGE("Since the test data matrix is not quite a rotation matrix, this should be detected.", !is_rotation);
   }
 
   void TestLefthandedCoordinateSystem()
   {
     /**
      * @brief This method tests InitializeStandardPlane() and IndexToWorld()
      * with a left-handed coordinate orientation or indexToWorldMatrix.
      *
      * Of course this test does not use standard Parameters, which are right-handed.
-     * See also discussion of bug #11477: http://bugs.mitk.org/show_bug.cgi?id=11477
+     * See also discussion of bug #11477: https://phabricator.mitk.org/T11477
      */
     planegeometry = mitk::PlaneGeometry::New();
     width = 100;
     widthInMM = 5;
     height = 200;
     heightInMM = 3;
     thicknessInMM = 1.0;
     mitk::FillVector3D(right, widthInMM, 0, 0);
     mitk::FillVector3D(bottom, 0, heightInMM, 0);
     // This one negative sign results in lefthanded coordinate orientation and det(matrix) < 0.
     mitk::FillVector3D(normal, 0, 0, -thicknessInMM);
 
     mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
 
     mitk::AffineTransform3D::MatrixType matrix;
     mitk::AffineTransform3D::MatrixType::InternalMatrixType &vnl_matrix = matrix.GetVnlMatrix();
 
     vnl_matrix.set_column(0, right);
     vnl_matrix.set_column(1, bottom);
     vnl_matrix.set_column(2, normal);
 
     // making sure that we didn't screw up this special test case or else fail deadly:
     assert(vnl_determinant(vnl_matrix) < 0.0);
 
     transform->SetIdentity();
     transform->SetMatrix(matrix);
 
     planegeometry->InitializeStandardPlane(width, height, transform); // Crux of the matter.
     CPPUNIT_ASSERT_MESSAGE(
       "Testing if IndexToWorldMatrix is correct after InitializeStandardPlane( width, height, transform ) ",
       mitk::MatrixEqualElementWise(planegeometry->GetIndexToWorldTransform()->GetMatrix(), matrix));
 
     mitk::Point3D p_index;
     p_index[0] = 10.;
     p_index[1] = 10.;
     p_index[2] = 0.;
     mitk::Point3D p_world;
     mitk::Point3D p_expectedResult;
     p_expectedResult[0] = 50.;
     p_expectedResult[1] = 30.;
     p_expectedResult[2] = 0.;
 
     ((mitk::BaseGeometry::Pointer)planegeometry)->IndexToWorld(p_index, p_world); // Crux of the matter.
     CPPUNIT_ASSERT_MESSAGE("Testing if IndexToWorld(a,b) function works correctly with lefthanded matrix ",
                            mitk::Equal(p_world, p_expectedResult, testEps));
   }
 
   // See bug 1210
   // Test does not use standard Parameters
   void TestCase1210()
   {
     mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
 
     mitk::Point3D origin;
     mitk::Vector3D right, down, spacing;
 
     mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
     mitk::FillVector3D(right, 1.015625, 1.015625, 1.1999969482421875);
 
     mitk::FillVector3D(down, 1.4012984643248170709237295832899161312802619418765e-45, 0, 0);
     mitk::FillVector3D(spacing,
                        0,
                        1.4713633875410579244699160624544119378442750389703e-43,
                        9.2806360452222355258639080851310540729807238879469e-32);
 
     std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing = nullptr): " << std::endl;
     CPPUNIT_ASSERT_NO_THROW(planegeometry->InitializeStandardPlane(right, down, &spacing));
     /*
     std::cout << "Testing width, height and thickness (in units): ";
     if((mitk::Equal(planegeometry->GetExtent(0),width)==false) ||
     (mitk::Equal(planegeometry->GetExtent(1),height)==false) ||
     (mitk::Equal(planegeometry->GetExtent(2),1)==false)
     )
     {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
     }
     std::cout<<"[PASSED]"<<std::endl;
 
     std::cout << "Testing width, height and thickness (in mm): ";
     if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM)==false) ||
     (mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM)==false) ||
     (mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM)==false)
     )
     {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
     }
      */
   }
 
   /**
    * @brief This method tests method IntersectionPoint
    *
    * See also bug #7151. (ref 2 this test: iggy)
    * This test was written due to incorrect calculation of the intersection point
    * between a given line and plane. This only occured when the pointdistance of
    * the line was less than 1.
    * Test Behavour:
    * ==============
    * we have a given line and a given plane.
    * we let the line intersect the plane.
    * when testing several positions on the line the resulting intersection point must be the same
    * we test a position where the distance between the correspoinding points is < 0 and another position where the
    * distance is > 0.
    *
    */
   // Test does not use standard Parameters
   void TestIntersectionPoint()
   {
     // init plane with its parameter
     mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
 
     mitk::Point3D origin;
     origin[0] = 0.0;
     origin[1] = 2.0;
     origin[2] = 0.0;
 
     mitk::Vector3D normal;
     normal[0] = 0.0;
     normal[1] = 1.0;
     normal[2] = 0.0;
 
     myPlaneGeometry->InitializePlane(origin, normal);
 
     // generate points and line for intersection testing
     // point distance of given line > 1
     mitk::Point3D pointP1;
     pointP1[0] = 2.0;
     pointP1[1] = 1.0;
     pointP1[2] = 0.0;
 
     mitk::Point3D pointP2;
     pointP2[0] = 2.0;
     pointP2[1] = 4.0;
     pointP2[2] = 0.0;
 
     mitk::Vector3D lineDirection;
     lineDirection[0] = pointP2[0] - pointP1[0];
     lineDirection[1] = pointP2[1] - pointP1[1];
     lineDirection[2] = pointP2[2] - pointP1[2];
 
     mitk::Line3D xingline(pointP1, lineDirection);
     mitk::Point3D calcXingPoint;
     myPlaneGeometry->IntersectionPoint(xingline, calcXingPoint);
 
     // point distance of given line < 1
     mitk::Point3D pointP3;
     pointP3[0] = 2.0;
     pointP3[1] = 2.2;
     pointP3[2] = 0.0;
 
     mitk::Point3D pointP4;
     pointP4[0] = 2.0;
     pointP4[1] = 1.7;
     pointP4[2] = 0.0;
 
     mitk::Vector3D lineDirection2;
     lineDirection2[0] = pointP4[0] - pointP3[0];
     lineDirection2[1] = pointP4[1] - pointP3[1];
     lineDirection2[2] = pointP4[2] - pointP3[2];
 
     mitk::Line3D xingline2(pointP3, lineDirection2);
     mitk::Point3D calcXingPoint2;
     myPlaneGeometry->IntersectionPoint(xingline2, calcXingPoint2);
 
     // intersection points must be the same
     CPPUNIT_ASSERT_MESSAGE("Failed to calculate Intersection Point", calcXingPoint == calcXingPoint2);
   }
 
   /**
    * @brief This method tests method ProjectPointOntoPlane.
    *
    * See also bug #3409.
    */
   // Test does not use standard Parameters
   void TestProjectPointOntoPlane()
   {
     mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
 
     // create normal
     mitk::Vector3D normal;
     normal[0] = 0.0;
     normal[1] = 0.0;
     normal[2] = 1.0;
 
     // create origin
     mitk::Point3D origin;
     origin[0] = -27.582859;
     origin[1] = 50;
     origin[2] = 200.27742;
 
     // initialize plane geometry
     myPlaneGeometry->InitializePlane(origin, normal);
 
     // output to descripe the test
     std::cout << "Testing PlaneGeometry according to bug #3409" << std::endl;
     std::cout << "Our normal is: " << normal << std::endl;
     std::cout << "So ALL projected points should have exactly the same z-value!" << std::endl;
 
     // create a number of points
     mitk::Point3D myPoints[5];
     myPoints[0][0] = -27.582859;
     myPoints[0][1] = 50.00;
     myPoints[0][2] = 200.27742;
 
     myPoints[1][0] = -26.58662;
     myPoints[1][1] = 50.00;
     myPoints[1][2] = 200.19026;
 
     myPoints[2][0] = -26.58662;
     myPoints[2][1] = 50.00;
     myPoints[2][2] = 200.33124;
 
     myPoints[3][0] = 104.58662;
     myPoints[3][1] = 452.12313;
     myPoints[3][2] = 866.41236;
 
     myPoints[4][0] = -207.58662;
     myPoints[4][1] = 312.00;
     myPoints[4][2] = -300.12346;
 
     // project points onto plane
     mitk::Point3D myProjectedPoints[5];
     for (unsigned int i = 0; i < 5; ++i)
     {
       myProjectedPoints[i] = myPlaneGeometry->ProjectPointOntoPlane(myPoints[i]);
     }
 
     // compare z-values with z-value of plane (should be equal)
     bool allPointsOnPlane = true;
     for (auto &myProjectedPoint : myProjectedPoints)
     {
       if (fabs(myProjectedPoint[2] - origin[2]) > mitk::sqrteps)
       {
         allPointsOnPlane = false;
       }
     }
     CPPUNIT_ASSERT_MESSAGE("All points lie not on the same plane", allPointsOnPlane);
   }
 
   void TestPlaneGeometryCloning()
   {
     mitk::PlaneGeometry::Pointer geometry2D = createPlaneGeometry();
 
     try
     {
       mitk::PlaneGeometry::Pointer clone = geometry2D->Clone();
       itk::Matrix<mitk::ScalarType, 3, 3> matrix = clone->GetIndexToWorldTransform()->GetMatrix();
       CPPUNIT_ASSERT_MESSAGE("Test if matrix element exists...", matrix[0][0] == 31);
 
       double origin = geometry2D->GetOrigin()[0];
       CPPUNIT_ASSERT_MESSAGE("First Point of origin as expected...", mitk::Equal(origin, 8));
 
       double spacing = geometry2D->GetSpacing()[0];
       CPPUNIT_ASSERT_MESSAGE("First Point of spacing as expected...", mitk::Equal(spacing, 31));
     }
     catch (...)
     {
       CPPUNIT_FAIL("Error during access on a member of cloned geometry");
     }
     // direction [row] [coloum]
     MITK_TEST_OUTPUT(<< "Casting a rotated 2D ITK Image to a MITK Image and check if Geometry is still same");
   }
 
   void TestPlaneGeometryInitializeOrder()
   {
     mitk::Vector3D mySpacing;
     mySpacing[0] = 31;
     mySpacing[1] = 0.1;
     mySpacing[2] = 5.4;
     mitk::Point3D myOrigin;
     myOrigin[0] = 8;
     myOrigin[1] = 9;
     myOrigin[2] = 10;
     mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
     itk::Matrix<mitk::ScalarType, 3, 3> transMatrix;
     transMatrix.Fill(0);
     transMatrix[0][0] = 1;
     transMatrix[1][1] = 2;
     transMatrix[2][2] = 4;
 
     myTransform->SetMatrix(transMatrix);
 
     mitk::PlaneGeometry::Pointer geometry2D1 = mitk::PlaneGeometry::New();
     geometry2D1->SetIndexToWorldTransform(myTransform);
     geometry2D1->SetSpacing(mySpacing);
     geometry2D1->SetOrigin(myOrigin);
 
     mitk::PlaneGeometry::Pointer geometry2D2 = mitk::PlaneGeometry::New();
     geometry2D2->SetSpacing(mySpacing);
     geometry2D2->SetOrigin(myOrigin);
     geometry2D2->SetIndexToWorldTransform(myTransform);
 
     mitk::PlaneGeometry::Pointer geometry2D3 = mitk::PlaneGeometry::New();
     geometry2D3->SetIndexToWorldTransform(myTransform);
     geometry2D3->SetSpacing(mySpacing);
     geometry2D3->SetOrigin(myOrigin);
     geometry2D3->SetIndexToWorldTransform(myTransform);
 
     CPPUNIT_ASSERT_MESSAGE("Origin of Geometry 1 matches that of Geometry 2.",
                            mitk::Equal(geometry2D1->GetOrigin(), geometry2D2->GetOrigin()));
     CPPUNIT_ASSERT_MESSAGE("Origin of Geometry 1 match those of Geometry 3.",
                            mitk::Equal(geometry2D1->GetOrigin(), geometry2D3->GetOrigin()));
     CPPUNIT_ASSERT_MESSAGE("Origin of Geometry 2 match those of Geometry 3.",
                            mitk::Equal(geometry2D2->GetOrigin(), geometry2D3->GetOrigin()));
 
     CPPUNIT_ASSERT_MESSAGE("Spacing of Geometry 1 match those of Geometry 2.",
                            mitk::Equal(geometry2D1->GetSpacing(), geometry2D2->GetSpacing()));
     CPPUNIT_ASSERT_MESSAGE("Spacing of Geometry 1 match those of Geometry 3.",
                            mitk::Equal(geometry2D1->GetSpacing(), geometry2D3->GetSpacing()));
     CPPUNIT_ASSERT_MESSAGE("Spacing of Geometry 2 match those of Geometry 3.",
                            mitk::Equal(geometry2D2->GetSpacing(), geometry2D3->GetSpacing()));
 
     CPPUNIT_ASSERT_MESSAGE("Transformation of Geometry 1 match those of Geometry 2.",
                            compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(),
                                          geometry2D2->GetIndexToWorldTransform()->GetMatrix()));
     CPPUNIT_ASSERT_MESSAGE("Transformation of Geometry 1 match those of Geometry 3.",
                            compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(),
                                          geometry2D3->GetIndexToWorldTransform()->GetMatrix()));
     CPPUNIT_ASSERT_MESSAGE("Transformation of Geometry 2 match those of Geometry 3.",
                            compareMatrix(geometry2D2->GetIndexToWorldTransform()->GetMatrix(),
                                          geometry2D3->GetIndexToWorldTransform()->GetMatrix()));
   }
 
   void TestInitializeStandardPlane()
   {
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: width",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: height",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: depth",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: width in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: heght in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: depth in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: AxisVectorRight",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: AxisVectorBottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: AxisVectorNormal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     mitk::Vector3D spacing;
     thicknessInMM = 1.5;
     normal.Normalize();
     normal *= thicknessInMM;
     mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
     planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: width",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: height",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: depth",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: width in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: height in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: depth in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: AxisVectorRight",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: AxisVectorBottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: AxisVectorNormal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     ;
   }
 
   void TestSetExtendInMM()
   {
     normal.Normalize();
     normal *= thicknessInMM;
     planegeometry->SetExtentInMM(2, thicknessInMM);
     CPPUNIT_ASSERT_MESSAGE("Testing SetExtentInMM(2, ...), querying by GetExtentInMM(2): ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing SetExtentInMM(2, ...), querying by GetAxisVector(2) and comparing to normal: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     planegeometry->SetOrigin(origin);
     CPPUNIT_ASSERT_MESSAGE("Testing SetOrigin", mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() after SetOrigin: Right",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() after SetOrigin: Bottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() after SetOrigin: Normal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   }
 
   void TestRotate()
   {
     // Changing the IndexToWorldTransform to a rotated version by SetIndexToWorldTransform() (keep origin):
     mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
     mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
     vnlmatrix = planegeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
     mitk::VnlVector axis(3);
     mitk::FillVector3D(axis, 1.0, 1.0, 1.0);
     axis.normalize();
     vnl_quaternion<mitk::ScalarType> rotation(axis, 0.223);
     vnlmatrix = rotation.rotation_matrix_transpose() * vnlmatrix;
     mitk::Matrix3D matrix;
     matrix = vnlmatrix;
     transform->SetMatrix(matrix);
     transform->SetOffset(planegeometry->GetIndexToWorldTransform()->GetOffset());
 
     right.SetVnlVector(rotation.rotation_matrix_transpose() * right.GetVnlVector());
     bottom.SetVnlVector(rotation.rotation_matrix_transpose() * bottom.GetVnlVector());
     normal.SetVnlVector(rotation.rotation_matrix_transpose() * normal.GetVnlVector());
     planegeometry->SetIndexToWorldTransform(transform);
 
     // The origin changed,because m_Origin=m_IndexToWorldTransform->GetOffset()+GetAxisVector(2)*0.5
     // and the AxisVector changes due to the rotation. In other words: the rotation was done around
     // the corner of the box, not around the planes origin. Now change it to a rotation around
     // the origin, simply by re-setting the origin to the original one:
     planegeometry->SetOrigin(origin);
 
     CPPUNIT_ASSERT_MESSAGE("Testing whether SetIndexToWorldTransform kept origin: ",
                            mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
 
     mitk::Point2D point;
     point[0] = 4;
     point[1] = 3;
     mitk::Point2D dummy;
     planegeometry->WorldToIndex(point, dummy);
     planegeometry->IndexToWorld(dummy, dummy);
     CPPUNIT_ASSERT_MESSAGE("Testing consistency of index and world coordinates.", dummy == point);
 
     CPPUNIT_ASSERT_MESSAGE("Testing width of rotated version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height of rotated version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness of rotated version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of rotated version: right ",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of rotated version: bottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of rotated version: normal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(), planegeometry->GetExtentInMM(0), testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(), planegeometry->GetExtentInMM(1), testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(), planegeometry->GetExtentInMM(2), testEps));
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
 
     width *= 2;
     height *= 3;
     planegeometry->SetSizeInUnits(width, height);
     CPPUNIT_ASSERT_MESSAGE("Testing SetSizeInUnits() of rotated version: ",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing SetSizeInUnits() of rotated version: ",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing SetSizeInUnits() of rotated version: ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of version with changed size in units: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of version with changed size in units: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of version with changed size in units: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of version with changed size in units: right ",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of version with changed size in units: bottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of version with changed size in units: normal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(), planegeometry->GetExtentInMM(0), testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(), planegeometry->GetExtentInMM(1), testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(), planegeometry->GetExtentInMM(2), testEps));
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   }
 
   void TestClone()
   {
     mitk::PlaneGeometry::Pointer clonedplanegeometry =
       dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
     // Cave: Statement below is negated!
     CPPUNIT_ASSERT_MESSAGE("Testing Clone(): ",
                            !((clonedplanegeometry.IsNull()) || (clonedplanegeometry->GetReferenceCount() != 1)));
     CPPUNIT_ASSERT_MESSAGE("Testing origin of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetOrigin(), origin, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing extent (in units) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of cloned version: right",
                            mitk::Equal(clonedplanegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of cloned version: bottom",
                            mitk::Equal(clonedplanegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of cloned version: normal",
                            mitk::Equal(clonedplanegeometry->GetAxisVector(2), normal, testEps));
 
     mappingTests2D(clonedplanegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   }
 
   void TestSagittalInitialization()
   {
     mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
     mitk::PlaneGeometry::Pointer clonedplanegeometry = planegeometry->Clone();
 
     // Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Sagittal, zPosition = 0, frontside=true):
     planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Sagittal);
 
     mitk::Vector3D newright, newbottom, newnormal;
     mitk::ScalarType newthicknessInMM;
 
     newright = bottom;
     newthicknessInMM = widthInMM / width * 1.0; // extent in normal direction is 1;
     newnormal = right;
     newnormal.Normalize();
     newnormal *= newthicknessInMM;
     newbottom = normal;
     newbottom.Normalize();
     newbottom *= thicknessInMM;
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of sagittally initialized version:",
                            mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0, testEps));
 
     // ok, corner was fine, so we can dare to believe the origin is ok.
     origin = planegeometry->GetOrigin();
 
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(0), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(1), 1, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), newnormal, testEps));
 
     mappingTests2D(planegeometry, height, 1, heightInMM, thicknessInMM, origin, newright, newbottom);
 
     // set origin back to the one of the axial slice:
     origin = clonedplanegeometry->GetOrigin();
     // Testing backside initialization: InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition
     // = 0, frontside=false, rotated=true):
     planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Axial, 0, false, true);
     mitk::Point3D backsideorigin;
     backsideorigin = origin + clonedplanegeometry->GetAxisVector(1); //+clonedplanegeometry->GetAxisVector(2);
 
     CPPUNIT_ASSERT_MESSAGE("Testing origin of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetOrigin(), backsideorigin, testEps));
 
     mitk::Point3D backsidecornerpoint0;
     backsidecornerpoint0 =
       cornerpoint0 + clonedplanegeometry->GetAxisVector(1); //+clonedplanegeometry->GetAxisVector(2);
     CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetCornerPoint(0), backsidecornerpoint0, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of backsidedly, axially initialized version "
                            "(should be same as in mm due to unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of backsidedly, axially initialized version "
                            "(should be same as in mm due to unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of backsidedly, axially initialized version "
                            "(should be same as in mm due to unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), -bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)); // T22254: Flipped sign
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, backsideorigin, right, -bottom);
   }
 
   void TestCoronalInitialization()
   {
     mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
 
     mitk::PlaneGeometry::Pointer clonedplanegeometry =
       dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
     //--------
 
     mitk::Vector3D newright, newbottom, newnormal;
     mitk::ScalarType newthicknessInMM;
 
     // Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Coronal, zPosition = 0, frontside=true)
     planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Coronal);
     newright = right;
     newbottom = normal;
     newbottom.Normalize();
     newbottom *= thicknessInMM;
     newthicknessInMM = heightInMM / height * 1.0 /*extent in normal direction is 1*/;
     newnormal = -bottom;
     newnormal.Normalize();
     newnormal *= newthicknessInMM;
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0, testEps));
 
     // ok, corner was fine, so we can dare to believe the origin is ok.
     origin = planegeometry->GetOrigin();
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(1), 1, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in units) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), -newnormal, testEps)); // T22254: Flipped sign
 
     mappingTests2D(planegeometry, width, 1, widthInMM, thicknessInMM, origin, newright, newbottom);
 
     // Changing plane to in-plane unit spacing using SetSizeInUnits:
     planegeometry->SetSizeInUnits(planegeometry->GetExtentInMM(0), planegeometry->GetExtentInMM(1));
 
     CPPUNIT_ASSERT_MESSAGE("Testing origin of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), -newnormal, testEps)); // T22254: Flipped sign
 
     mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
 
     // Changing plane to unit spacing also in normal direction using SetExtentInMM(2, 1.0):
     planegeometry->SetExtentInMM(2, 1.0);
     newnormal.Normalize();
 
     CPPUNIT_ASSERT_MESSAGE("Testing origin of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(2), 1.0, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), -newnormal, testEps)); // T22254: Flipped sign
     mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
   }
 
   void TestAxialInitialization()
   {
     mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
 
     // Clone, move, rotate and test for 'IsParallel' and 'IsOnPlane'
     mitk::PlaneGeometry::Pointer clonedplanegeometry =
       dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
 
     CPPUNIT_ASSERT_MESSAGE("Testing Clone(): ",
                            !((clonedplanegeometry.IsNull()) || (clonedplanegeometry->GetReferenceCount() != 1)));
 
     std::cout << "Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition = 0, "
                  "frontside=true): "
               << std::endl;
     planegeometry->InitializeStandardPlane(clonedplanegeometry);
 
     CPPUNIT_ASSERT_MESSAGE("Testing origin of axially initialized version: ",
                            mitk::Equal(planegeometry->GetOrigin(), origin));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of axially initialized version: ",
                            mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of axially initialized version (should be same as in mm due to "
                            "unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of axially initialized version (should be same as in mm due to "
                            "unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in units) of axially initialized version (should be same as in mm due "
                            "to unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height  (in mm) of axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   }
 
   void TestPlaneComparison()
   {
     // Clone, move, rotate and test for 'IsParallel' and 'IsOnPlane'
     mitk::PlaneGeometry::Pointer clonedplanegeometry2 =
       dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
 
     CPPUNIT_ASSERT_MESSAGE("Testing Clone(): ",
                            !((clonedplanegeometry2.IsNull()) || (clonedplanegeometry2->GetReferenceCount() != 1)));
     CPPUNIT_ASSERT_MESSAGE("Testing wheter original and clone are at the same position",
                            clonedplanegeometry2->IsOnPlane(planegeometry.GetPointer()));
     CPPUNIT_ASSERT_MESSAGE(" Asserting that origin is on the plane cloned plane:",
                            clonedplanegeometry2->IsOnPlane(origin));
 
     mitk::VnlVector newaxis(3);
     mitk::FillVector3D(newaxis, 1.0, 1.0, 1.0);
     newaxis.normalize();
     vnl_quaternion<mitk::ScalarType> rotation2(newaxis, 0.0);
 
     mitk::Vector3D clonednormal = clonedplanegeometry2->GetNormal();
     mitk::Point3D clonedorigin = clonedplanegeometry2->GetOrigin();
 
     auto planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), 180.0);
 
     clonedplanegeometry2->ExecuteOperation(planerot);
     CPPUNIT_ASSERT_MESSAGE(" Asserting that a flipped plane is still on the original plane: ",
                            clonedplanegeometry2->IsOnPlane(planegeometry.GetPointer()));
 
     clonedorigin += clonednormal;
     clonedplanegeometry2->SetOrigin(clonedorigin);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if the translated (cloned, flipped) plane is parallel to its origin plane: ",
                            clonedplanegeometry2->IsParallel(planegeometry));
     delete planerot;
 
     planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), 0.5);
     clonedplanegeometry2->ExecuteOperation(planerot);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if a non-paralell plane gets recognized as not paralell  [rotation +0.5 degree] : ",
                            !clonedplanegeometry2->IsParallel(planegeometry));
     delete planerot;
 
     planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), -1.0);
     clonedplanegeometry2->ExecuteOperation(planerot);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if a non-paralell plane gets recognized as not paralell  [rotation -0.5 degree] : ",
                            !clonedplanegeometry2->IsParallel(planegeometry));
     delete planerot;
 
     planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), 360.5);
     clonedplanegeometry2->ExecuteOperation(planerot);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if a non-paralell plane gets recognized as paralell  [rotation 360 degree] : ",
                            clonedplanegeometry2->IsParallel(planegeometry));
   }
 
 private:
   // helper Methods for the Tests
 
   mitk::PlaneGeometry::Pointer createPlaneGeometry()
   {
     mitk::Vector3D mySpacing;
     mySpacing[0] = 31;
     mySpacing[1] = 0.1;
     mySpacing[2] = 5.4;
     mitk::Point3D myOrigin;
     myOrigin[0] = 8;
     myOrigin[1] = 9;
     myOrigin[2] = 10;
     mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
     itk::Matrix<mitk::ScalarType, 3, 3> transMatrix;
     transMatrix.Fill(0);
     transMatrix[0][0] = 1;
     transMatrix[1][1] = 2;
     transMatrix[2][2] = 4;
 
     myTransform->SetMatrix(transMatrix);
 
     mitk::PlaneGeometry::Pointer geometry2D = mitk::PlaneGeometry::New();
     geometry2D->SetIndexToWorldTransform(myTransform);
     geometry2D->SetSpacing(mySpacing);
     geometry2D->SetOrigin(myOrigin);
     return geometry2D;
   }
 
   bool compareMatrix(itk::Matrix<mitk::ScalarType, 3, 3> left, itk::Matrix<mitk::ScalarType, 3, 3> right)
   {
     bool equal = true;
     for (int i = 0; i < 3; ++i)
       for (int j = 0; j < 3; ++j)
         equal &= mitk::Equal(left[i][j], right[i][j]);
     return equal;
   }
 
   /**
    * This function tests for correct mapping and is called several times from other tests
    **/
   void mappingTests2D(const mitk::PlaneGeometry *planegeometry,
                       const mitk::ScalarType &width,
                       const mitk::ScalarType &height,
                       const mitk::ScalarType &widthInMM,
                       const mitk::ScalarType &heightInMM,
                       const mitk::Point3D &origin,
                       const mitk::Vector3D &right,
                       const mitk::Vector3D &bottom)
   {
     std::cout << "Testing mapping Map(pt2d_mm(x=widthInMM/2.3,y=heightInMM/2.5), pt3d_mm) and compare with expected: ";
     mitk::Point2D pt2d_mm;
     mitk::Point3D pt3d_mm, expected_pt3d_mm;
     pt2d_mm[0] = widthInMM / 2.3;
     pt2d_mm[1] = heightInMM / 2.5;
     expected_pt3d_mm = origin + right * (pt2d_mm[0] / right.GetNorm()) + bottom * (pt2d_mm[1] / bottom.GetNorm());
     planegeometry->Map(pt2d_mm, pt3d_mm);
     CPPUNIT_ASSERT_MESSAGE(
       "Testing mapping Map(pt2d_mm(x=widthInMM/2.3,y=heightInMM/2.5), pt3d_mm) and compare with expected",
       mitk::Equal(pt3d_mm, expected_pt3d_mm, testEps));
 
     std::cout << "Testing mapping Map(pt3d_mm, pt2d_mm) and compare with expected: ";
     mitk::Point2D testpt2d_mm;
     planegeometry->Map(pt3d_mm, testpt2d_mm);
     std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
     std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
     std::cout << std::setprecision(12) << "10*mitk::eps " << 10 * mitk::eps << std::endl;
     // This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
     CPPUNIT_ASSERT_MESSAGE("Testing mapping Map(pt3d_mm, pt2d_mm) and compare with expected",
                            mitk::Equal(pt2d_mm, testpt2d_mm, 10 * mitk::eps));
 
     std::cout << "Testing IndexToWorld(pt2d_units, pt2d_mm) and compare with expected: ";
     mitk::Point2D pt2d_units;
     pt2d_units[0] = width / 2.0;
     pt2d_units[1] = height / 2.0;
     pt2d_mm[0] = widthInMM / 2.0;
     pt2d_mm[1] = heightInMM / 2.0;
     planegeometry->IndexToWorld(pt2d_units, testpt2d_mm);
     std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
     std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
     std::cout << std::setprecision(12) << "10*mitk::eps " << 10 * mitk::eps << std::endl;
     // This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
     CPPUNIT_ASSERT_MESSAGE("Testing IndexToWorld(pt2d_units, pt2d_mm) and compare with expected: ",
                            mitk::Equal(pt2d_mm, testpt2d_mm, 10 * mitk::eps));
 
     std::cout << "Testing WorldToIndex(pt2d_mm, pt2d_units) and compare with expected: ";
     mitk::Point2D testpt2d_units;
     planegeometry->WorldToIndex(pt2d_mm, testpt2d_units);
 
     std::cout << std::setprecision(12) << "Expected pt2d_units " << pt2d_units << std::endl;
     std::cout << std::setprecision(12) << "Result testpt2d_units " << testpt2d_units << std::endl;
     std::cout << std::setprecision(12) << "10*mitk::eps " << 10 * mitk::eps << std::endl;
     // This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
     CPPUNIT_ASSERT_MESSAGE("Testing WorldToIndex(pt2d_mm, pt2d_units) and compare with expected:",
                            mitk::Equal(pt2d_units, testpt2d_units, 10 * mitk::eps));
   }
 };
 MITK_TEST_SUITE_REGISTRATION(mitkPlaneGeometry)
diff --git a/Modules/CppMicroServices/CMakeLists.txt b/Modules/CppMicroServices/CMakeLists.txt
index 3faee251b5..4a7d9ca897 100644
--- a/Modules/CppMicroServices/CMakeLists.txt
+++ b/Modules/CppMicroServices/CMakeLists.txt
@@ -1,443 +1,440 @@
 project(CppMicroServices)
 
 set(${PROJECT_NAME}_MAJOR_VERSION 2)
 set(${PROJECT_NAME}_MINOR_VERSION 99)
 set(${PROJECT_NAME}_PATCH_VERSION 0)
 set(${PROJECT_NAME}_VERSION ${${PROJECT_NAME}_MAJOR_VERSION}.${${PROJECT_NAME}_MINOR_VERSION}.${${PROJECT_NAME}_PATCH_VERSION})
 
 cmake_minimum_required(VERSION 2.8.12)
 cmake_policy(VERSION 2.8.12)
 cmake_policy(SET CMP0017 NEW)
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #------------------------------------------------------------------------------
 
 set(US_CMAKE_DIR ${PROJECT_SOURCE_DIR}/cmake)
 
 set(CMAKE_MODULE_PATH
   ${US_CMAKE_DIR}
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(CMakeParseArguments)
 include(CMakePackageConfigHelpers)
 include(CheckCXXSourceCompiles)
 include(usFunctionAddResources)
 include(usFunctionEmbedResources)
 include(usFunctionGetResourceSource)
 include(usFunctionCheckResourceLinking)
 include(usFunctionCheckCompilerFlags)
 include(usFunctionGetGccVersion)
 include(usFunctionGenerateModuleInit)
 include(usMacroCreateModule)
 
 if(US_BUILD_TESTING)
   include(usFunctionCompileSnippets)
 endif()
 
 #-----------------------------------------------------------------------------
 # Init output directories
 #-----------------------------------------------------------------------------
 
 set(US_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
 set(US_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
 set(US_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
 
 foreach(_type ARCHIVE LIBRARY RUNTIME)
   if(NOT CMAKE_${_type}_OUTPUT_DIRECTORY)
     set(CMAKE_${_type}_OUTPUT_DIRECTORY ${US_${_type}_OUTPUT_DIRECTORY})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # 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 'Debug' as none was specified.")
   set(CMAKE_BUILD_TYPE Debug 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()
 
 #-----------------------------------------------------------------------------
 # CMake options
 #-----------------------------------------------------------------------------
 
 function(us_cache_var _var_name _var_default _var_type _var_help)
   set(_advanced 0)
   set(_force)
   foreach(_argn ${ARGN})
     if(_argn STREQUAL ADVANCED)
       set(_advanced 1)
     elseif(_argn STREQUAL FORCE)
       set(_force FORCE)
     endif()
   endforeach()
 
   if(US_IS_EMBEDDED)
     if(NOT DEFINED ${_var_name} OR _force)
       set(${_var_name} ${_var_default} PARENT_SCOPE)
     endif()
   else()
     set(${_var_name} ${_var_default} CACHE ${_var_type} "${_var_help}" ${_force})
     if(_advanced)
       mark_as_advanced(${_var_name})
     endif()
   endif()
 endfunction()
 
 # Determine if we are being build inside a larger project
 if(NOT DEFINED US_IS_EMBEDDED)
   if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
     set(US_IS_EMBEDDED 0)
   else()
     set(US_IS_EMBEDDED 1)
   endif()
 endif()
 
 # Determine the name of the install component for "SDK" artifacts.
 # The default is "sdk"
 if(NOT DEFINED US_SDK_INSTALL_COMPONENT)
   set(US_SDK_INSTALL_COMPONENT COMPONENT sdk)
 elseif(US_SDK_INSTALL_COMPONENT)
   set(US_SDK_INSTALL_COMPONENT COMPONENT ${US_SDK_INSTALL_COMPONENT})
 endif()
 
 us_cache_var(US_ENABLE_AUTOLOADING_SUPPORT OFF BOOL "Enable module auto-loading support")
 us_cache_var(US_ENABLE_THREADING_SUPPORT OFF BOOL "Enable threading support")
 us_cache_var(US_ENABLE_DEBUG_OUTPUT OFF BOOL "Enable debug messages" ADVANCED)
 us_cache_var(US_BUILD_SHARED_LIBS ON BOOL "Build shared libraries")
 us_cache_var(US_BUILD_TESTING OFF BOOL "Build tests")
 us_cache_var(US_BUILD_EXAMPLES OFF BOOL "Build example projects")
 
 if(US_BUILD_TESTING)
   enable_testing()
 endif()
 
 if(WIN32 AND NOT CYGWIN)
   set(default_runtime_install_dir bin/)
   set(default_library_install_dir bin/)
   set(default_archive_install_dir lib/)
   set(default_header_install_dir include/)
   set(default_auxiliary_install_dir share/)
 else()
   set(default_runtime_install_dir bin/)
   set(default_library_install_dir lib/${PROJECT_NAME})
   set(default_archive_install_dir lib/${PROJECT_NAME})
   set(default_header_install_dir include/${PROJECT_NAME})
   set(default_auxiliary_install_dir share/${PROJECT_NAME})
 endif()
 
 us_cache_var(RUNTIME_INSTALL_DIR ${default_runtime_install_dir} STRING "Relative install location for binaries" ADVANCED)
 us_cache_var(LIBRARY_INSTALL_DIR ${default_library_install_dir} STRING "Relative install location for libraries" ADVANCED)
 us_cache_var(ARCHIVE_INSTALL_DIR ${default_archive_install_dir} STRING "Relative install location for archives" ADVANCED)
 us_cache_var(HEADER_INSTALL_DIR ${default_header_install_dir} STRING "Relative install location for headers" ADVANCED)
 us_cache_var(AUXILIARY_INSTALL_DIR ${default_auxiliary_install_dir} STRING "Relative install location for auxiliary files" ADVANCED)
 set(AUXILIARY_CMAKE_INSTALL_DIR ${AUXILIARY_INSTALL_DIR}/cmake)
 
 us_cache_var(US_NAMESPACE "us" STRING "The namespace for the C++ Micro Services symbols")
 
 set(BUILD_SHARED_LIBS ${US_BUILD_SHARED_LIBS})
 
 set(US_MODULE_INIT_TEMPLATE "${US_CMAKE_DIR}/usModuleInit.cpp" CACHE INTERNAL "The module initialization template code")
 set(US_RESOURCE_RC_TEMPLATE "${US_CMAKE_DIR}/us_resources.rc.in" CACHE INTERNAL "The Windows RC resource template")
 set(US_CMAKE_RESOURCE_DEPENDENCIES_CPP "${US_CMAKE_DIR}/usCMakeResourceDependencies.cpp" CACHE INTERNAL "The dummy resource dependencies code")
 
 #-----------------------------------------------------------------------------
 # US C/CXX Flags
 #-----------------------------------------------------------------------------
 
 if(US_IS_EMBEDDED)
   set(CMAKE_C_FLAGS)
   set(CMAKE_C_FLAGS_RELEASE)
   set(CMAKE_C_FLAGS_DEBUG)
   set(CMAKE_CXX_FLAGS)
   set(CMAKE_CXX_FLAGS_RELEASE)
   set(CMAKE_CXX_FLAGS_DEBUG)
   set(CMAKE_LINK_FLAGS)
   set(CMAKE_LINK_FLAGS_RELEASE)
   set(CMAKE_LINK_FLAGS_DEBUG)
 endif()
 
 # Set C++ compiler flags
 if(NOT MSVC)
   foreach(_cxxflag -Werror -Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -Woverloaded-virtual -Wnon-virtual-dtor
                    -Wstrict-null-sentinel -Wsign-promo -fdiagnostics-show-option -Wno-error=deprecated-copy
                    -Wno-error=implicit-int-float-conversion)
     usFunctionCheckCompilerFlags(${_cxxflag} US_CXX_FLAGS)
   endforeach()
 endif()
 
 set(US_HAVE_VISIBILITY_ATTRIBUTE 0)
 usFunctionCheckCompilerFlags("-fvisibility=hidden -fvisibility-inlines-hidden" _have_visibility)
 if(_have_visibility)
   set(US_HAVE_VISIBILITY_ATTRIBUTE 1)
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
 
   usFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
   if(${GCC_VERSION} VERSION_LESS "4.0.0")
     message(FATAL_ERROR "gcc version ${GCC_VERSION} not supported. Please use gcc >= 4.")
   endif()
 
   # With older versions of gcc the flag -fstack-protector-all requires an extra dependency to libssp.so.
   # If the gcc version is lower than 4.4.0 and the build type is Release let's not include the flag.
   if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
     usFunctionCheckCompilerFlags("-fstack-protector-all" US_CXX_FLAGS)
   endif()
 
   # Enable visibility support (only for gcc >= 4.5)
   # We only support hidden visibility with gcc for now.
   #
   # Clang has troubles with correctly marking template declarations and explicit template
   # instantiations as exported across shared library boundaries. Specifically, comparing
   # type_info objects from STL types does not work (used in us::Any::Type() == typeid(std::string))
   # which could be related to the default visibility of STL types declared in libstdc++ and/or libc++
   # but also to using RTLD_LOCAL or RTLD_GLOBAL when loading shared libraries via dlopen().
   #
-  # See http://comments.gmane.org/gmane.comp.compilers.clang.scm/50028
-  # and http://llvm.org/bugs/show_bug.cgi?id=10113
-  #
   if(_have_visibility AND NOT ${GCC_VERSION} VERSION_LESS "4.5")
     set(US_CXX_FLAGS "${US_CXX_FLAGS} ${_have_visibility}")
   else()
     set(US_GCC_RTTI_WORKAROUND_NEEDED 1)
   endif()
 
   usFunctionCheckCompilerFlags("-O1 -D_FORTIFY_SOURCE=2" _fortify_source_flag)
   if(_fortify_source_flag)
     set(US_CXX_FLAGS_RELEASE "${US_CXX_FLAGS_RELEASE} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2")
   endif()
 endif()
 
 if(MSVC)
   set(US_CXX_FLAGS "/MP /WX /wd4180 /wd4996 /wd4251 /wd4503 ${US_CXX_FLAGS}")
 endif()
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${US_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${US_CXX_FLAGS_RELEASE}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${US_C_FLAGS}")
 set(CMAKE_C_FLAGS_REALEASE "${CMAKE_C_FLAGS_RELEASE} ${US_C_FLAGS_RELEASE}")
 
 #-----------------------------------------------------------------------------
 # US Link Flags
 #-----------------------------------------------------------------------------
 
 set(US_LINK_FLAGS )
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)
   foreach(_linkflag -Wl,--no-undefined)
     set(_add_flag)
     usFunctionCheckCompilerFlags("${_linkflag}" _add_flag)
     if(_add_flag)
       set(US_LINK_FLAGS "${US_LINK_FLAGS} ${_linkflag}")
     endif()
   endforeach()
 endif()
 
 usFunctionCheckResourceLinking()
 
 #-----------------------------------------------------------------------------
 # US Header Checks
 #-----------------------------------------------------------------------------
 
 include(CheckIncludeFileCXX)
 include(CheckCXXSourceCompiles)
 
 CHECK_INCLUDE_FILE_CXX(cxxabi.h US_HAVE_CXXABI_H)
 CHECK_INCLUDE_FILE_CXX(stdint.h US_HAVE_STDINT_H)
 CHECK_INCLUDE_FILE_CXX(tr1/unordered_map US_HAVE_TR1_UNORDERED_MAP_H)
 CHECK_INCLUDE_FILE_CXX(tr1/unordered_set US_HAVE_TR1_UNORDERED_SET_H)
 CHECK_INCLUDE_FILE_CXX(tr1/functional US_HAVE_TR1_FUNCTIONAL_H)
 CHECK_INCLUDE_FILE_CXX(unordered_map US_HAVE_UNORDERED_MAP_H)
 CHECK_INCLUDE_FILE_CXX(unordered_set US_HAVE_UNORDERED_SET_H)
 CHECK_INCLUDE_FILE_CXX(functional US_HAVE_FUNCTIONAL_H)
 
 if(US_HAVE_UNORDERED_MAP_H)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::tr1::unordered_map<int,int> m; return 0; }"
                             US_HAVE_TR1_UNORDERED_MAP)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::unordered_map<int,int> m; return 0; }"
                             US_HAVE_STD_UNORDERED_MAP)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::tr1::hash<int>(); return 0; }"
                             US_HAVE_TR1_HASH)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::hash<int>(); return 0; }"
                             US_HAVE_STD_HASH)
   if(US_HAVE_STD_HASH)
     CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend struct std::hash<int>; }; int main() { return 0; }"
                               US_HAVE_STD_HASH_STRUCT)
     CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend class std::hash<int>; }; int main() { return 0; }"
                               US_HAVE_STD_HASH_CLASS)
   elseif(US_HAVE_TR1_HASH)
     CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend struct std::tr1::hash<int>; }; int main() { return 0; }"
                               US_HAVE_TR1_HASH_STRUCT)
     CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend class std::tr1::hash<int>; }; int main() { return 0; }"
                               US_HAVE_TR1_HASH_CLASS)
   endif()
 elseif(US_HAVE_TR1_UNORDERED_MAP_H)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::tr1::unordered_map<int,int> m; return 0; }"
                             US_HAVE_TR1_UNORDERED_MAP)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::unordered_map<int,int> m; return 0; }"
                             US_HAVE_STD_UNORDERED_MAP)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::tr1::hash<int>(); return 0; }"
                             US_HAVE_TR1_HASH)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::hash<int>(); return 0; }"
                             US_HAVE_STD_HASH)
   if(US_HAVE_STD_HASH)
     CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend struct std::hash<int>; }; int main() { return 0; }"
                               US_HAVE_STD_HASH_STRUCT)
     CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend class std::hash<int>; }; int main() { return 0; }"
                               US_HAVE_STD_HASH_CLASS)
   elseif(US_HAVE_TR1_HASH)
     CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend struct std::tr1::hash<int>; }; int main() { return 0; }"
                               US_HAVE_TR1_HASH_STRUCT)
     CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend class std::tr1::hash<int>; }; int main() { return 0; }"
                               US_HAVE_TR1_HASH_CLASS)
   endif()
 else()
   message(SEND_ERROR "The header file \"unordered_map\" is not available.")
 endif()
 if(NOT (US_HAVE_TR1_UNORDERED_MAP OR US_HAVE_STD_UNORDERED_MAP))
   message(SEND_ERROR "The \"unordered_map\" type is not available.")
 endif()
 
 if(US_HAVE_UNORDERED_SET_H)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_set>\nint main() { std::tr1::unordered_set<int> s; return 0; }"
                             US_HAVE_TR1_UNORDERED_SET)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_set>\nint main() { std::unordered_set<int> s; return 0; }"
                             US_HAVE_STD_UNORDERED_SET)
 elseif(US_HAVE_TR1_UNORDERED_SET_H)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_set>\nint main() { std::tr1::unordered_set<int> s; return 0; }"
                             US_HAVE_TR1_UNORDERED_SET)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_set>\nint main() { std::unordered_set<int> s; return 0; }"
                             US_HAVE_STD_UNORDERED_SET)
 else()
   message(SEND_ERROR "The header file \"unordered_set\" is not available.")
 endif()
 if(NOT (US_HAVE_TR1_UNORDERED_SET OR US_HAVE_STD_UNORDERED_SET))
   message(SEND_ERROR "The \"unordered_set\" type is not available.")
 endif()
 
 if(NOT (US_HAVE_FUNCTIONAL_H OR US_HAVE_TR1_FUNCTIONAL_H))
   message(SEND_ERROR "The header file \"functional\" is not available.")
 endif()
 
 if(US_HAVE_FUNCTIONAL_H)
   CHECK_CXX_SOURCE_COMPILES("#include <functional>\nint main() { std::tr1::function<int(void)> f(main); return 0; }"
                             US_HAVE_TR1_FUNCTION)
   CHECK_CXX_SOURCE_COMPILES("#include <functional>\nint main() { std::function<int(void)> f(main); return 0; }"
                             US_HAVE_STD_FUNCTION)
 endif()
 if((NOT (US_HAVE_STD_FUNCTION OR US_HAVE_TR1_FUNCTION)) AND US_HAVE_TR1_FUNCTIONAL_H)
   unset(US_HAVE_TR1_FUNCTION CACHE)
   unset(US_HAVE_STD_FUNCTION CACHE)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/functional>\nint main() { std::tr1::function<int(void)> f(main); return 0; }"
                             US_HAVE_TR1_FUNCTION)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/functional>\nint main() { std::function<int(void)> f(main); return 0; }"
                             US_HAVE_STD_FUNCTION)
 endif()
 
 if(NOT (US_HAVE_STD_FUNCTION OR US_HAVE_TR1_FUNCTION))
   message(SEND_ERROR "The \"function\" type is not available.")
 endif()
 
 #-----------------------------------------------------------------------------
 # Source directory
 #-----------------------------------------------------------------------------
 
 set(US_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/third_party ${PROJECT_BINARY_DIR}/include)
 
 # Configure CppMicroServicesConfig.cmake for the build tree.
 # The file is used in sub-directories.
 
 set(PACKAGE_CONFIG_INCLUDE_DIR ${US_INCLUDE_DIRS})
 set(PACKAGE_CONFIG_RUNTIME_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 set(PACKAGE_CONFIG_CMAKE_DIR ${US_CMAKE_DIR})
 
 set(US_RCC_EXECUTABLE_NAME usResourceCompiler CACHE INTERNAL "The target name of the usResourceCompiler executable.")
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake.in
   ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
   @ONLY
   )
 
 set(us_global_config_h_file "${PROJECT_BINARY_DIR}/include/usGlobalConfig.h")
 configure_file(${US_CMAKE_DIR}/usGlobalConfig.h.in ${us_global_config_h_file})
 
 include_directories(${US_INCLUDE_DIRS})
 
 add_subdirectory(tools)
 
 add_subdirectory(core)
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 add_subdirectory(doc)
 
 #-----------------------------------------------------------------------------
 # Last configuration and install steps
 #-----------------------------------------------------------------------------
 
 # Version information
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}ConfigVersion.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
   @ONLY
   )
 
 export(TARGETS ${US_RCC_EXECUTABLE_NAME}
        FILE ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake)
 
 if(NOT US_NO_INSTALL)
 
   install(EXPORT ${PROJECT_NAME}Targets
           FILE ${PROJECT_NAME}Targets.cmake
           DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
 
   set(_install_cmake_scripts
     ${US_MODULE_INIT_TEMPLATE}
     ${US_CMAKE_RESOURCE_DEPENDENCIES_CPP}
     ${US_CMAKE_DIR}/usFunctionGenerateModuleInit.cmake
     ${US_CMAKE_DIR}/usFunctionAddResources.cmake
     ${US_CMAKE_DIR}/usFunctionEmbedResources.cmake
     ${US_CMAKE_DIR}/usFunctionGetResourceSource.cmake
     ${US_CMAKE_DIR}/usFunctionCheckResourceLinking.cmake
     ${US_CMAKE_DIR}/usFunctionCheckCompilerFlags.cmake
     )
 
   install(FILES ${_install_cmake_scripts}
           DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
 
   install(FILES ${us_global_config_h_file}
           DESTINATION ${HEADER_INSTALL_DIR})
 
   # Configure CppMicroServicesConfig.cmake for the install tree
   set(CONFIG_INCLUDE_DIR ${HEADER_INSTALL_DIR})
   set(CONFIG_RUNTIME_DIR ${RUNTIME_INSTALL_DIR})
   set(CONFIG_CMAKE_DIR ${AUXILIARY_CMAKE_INSTALL_DIR})
   configure_package_config_file(
     ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake.in
     ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${PROJECT_NAME}Config.cmake
     INSTALL_DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
     PATH_VARS CONFIG_INCLUDE_DIR CONFIG_RUNTIME_DIR CONFIG_CMAKE_DIR
     NO_SET_AND_CHECK_MACRO
     NO_CHECK_REQUIRED_COMPONENTS_MACRO
     )
 
   install(FILES ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${PROJECT_NAME}Config.cmake
                 ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
           DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
           ${US_SDK_INSTALL_COMPONENT}
     )
 
 endif()
diff --git a/Modules/CppMicroServices/LICENSE b/Modules/CppMicroServices/LICENSE
index d645695673..62589edd12 100644
--- a/Modules/CppMicroServices/LICENSE
+++ b/Modules/CppMicroServices/LICENSE
@@ -1,202 +1,202 @@
 
                                  Apache License
                            Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+                        https://www.apache.org/licenses/
 
    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
    1. Definitions.
 
       "License" shall mean the terms and conditions for use, reproduction,
       and distribution as defined by Sections 1 through 9 of this document.
 
       "Licensor" shall mean the copyright owner or entity authorized by
       the copyright owner that is granting the License.
 
       "Legal Entity" shall mean the union of the acting entity and all
       other entities that control, are controlled by, or are under common
       control with that entity. For the purposes of this definition,
       "control" means (i) the power, direct or indirect, to cause the
       direction or management of such entity, whether by contract or
       otherwise, or (ii) ownership of fifty percent (50%) or more of the
       outstanding shares, or (iii) beneficial ownership of such entity.
 
       "You" (or "Your") shall mean an individual or Legal Entity
       exercising permissions granted by this License.
 
       "Source" form shall mean the preferred form for making modifications,
       including but not limited to software source code, documentation
       source, and configuration files.
 
       "Object" form shall mean any form resulting from mechanical
       transformation or translation of a Source form, including but
       not limited to compiled object code, generated documentation,
       and conversions to other media types.
 
       "Work" shall mean the work of authorship, whether in Source or
       Object form, made available under the License, as indicated by a
       copyright notice that is included in or attached to the work
       (an example is provided in the Appendix below).
 
       "Derivative Works" shall mean any work, whether in Source or Object
       form, that is based on (or derived from) the Work and for which the
       editorial revisions, annotations, elaborations, or other modifications
       represent, as a whole, an original work of authorship. For the purposes
       of this License, Derivative Works shall not include works that remain
       separable from, or merely link (or bind by name) to the interfaces of,
       the Work and Derivative Works thereof.
 
       "Contribution" shall mean any work of authorship, including
       the original version of the Work and any modifications or additions
       to that Work or Derivative Works thereof, that is intentionally
       submitted to Licensor for inclusion in the Work by the copyright owner
       or by an individual or Legal Entity authorized to submit on behalf of
       the copyright owner. For the purposes of this definition, "submitted"
       means any form of electronic, verbal, or written communication sent
       to the Licensor or its representatives, including but not limited to
       communication on electronic mailing lists, source code control systems,
       and issue tracking systems that are managed by, or on behalf of, the
       Licensor for the purpose of discussing and improving the Work, but
       excluding communication that is conspicuously marked or otherwise
       designated in writing by the copyright owner as "Not a Contribution."
 
       "Contributor" shall mean Licensor and any individual or Legal Entity
       on behalf of whom a Contribution has been received by Licensor and
       subsequently incorporated within the Work.
 
    2. Grant of Copyright License. Subject to the terms and conditions of
       this License, each Contributor hereby grants to You a perpetual,
       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
       copyright license to reproduce, prepare Derivative Works of,
       publicly display, publicly perform, sublicense, and distribute the
       Work and such Derivative Works in Source or Object form.
 
    3. Grant of Patent License. Subject to the terms and conditions of
       this License, each Contributor hereby grants to You a perpetual,
       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
       (except as stated in this section) patent license to make, have made,
       use, offer to sell, sell, import, and otherwise transfer the Work,
       where such license applies only to those patent claims licensable
       by such Contributor that are necessarily infringed by their
       Contribution(s) alone or by combination of their Contribution(s)
       with the Work to which such Contribution(s) was submitted. If You
       institute patent litigation against any entity (including a
       cross-claim or counterclaim in a lawsuit) alleging that the Work
       or a Contribution incorporated within the Work constitutes direct
       or contributory patent infringement, then any patent licenses
       granted to You under this License for that Work shall terminate
       as of the date such litigation is filed.
 
    4. Redistribution. You may reproduce and distribute copies of the
       Work or Derivative Works thereof in any medium, with or without
       modifications, and in Source or Object form, provided that You
       meet the following conditions:
 
       (a) You must give any other recipients of the Work or
           Derivative Works a copy of this License; and
 
       (b) You must cause any modified files to carry prominent notices
           stating that You changed the files; and
 
       (c) You must retain, in the Source form of any Derivative Works
           that You distribute, all copyright, patent, trademark, and
           attribution notices from the Source form of the Work,
           excluding those notices that do not pertain to any part of
           the Derivative Works; and
 
       (d) If the Work includes a "NOTICE" text file as part of its
           distribution, then any Derivative Works that You distribute must
           include a readable copy of the attribution notices contained
           within such NOTICE file, excluding those notices that do not
           pertain to any part of the Derivative Works, in at least one
           of the following places: within a NOTICE text file distributed
           as part of the Derivative Works; within the Source form or
           documentation, if provided along with the Derivative Works; or,
           within a display generated by the Derivative Works, if and
           wherever such third-party notices normally appear. The contents
           of the NOTICE file are for informational purposes only and
           do not modify the License. You may add Your own attribution
           notices within Derivative Works that You distribute, alongside
           or as an addendum to the NOTICE text from the Work, provided
           that such additional attribution notices cannot be construed
           as modifying the License.
 
       You may add Your own copyright statement to Your modifications and
       may provide additional or different license terms and conditions
       for use, reproduction, or distribution of Your modifications, or
       for any such Derivative Works as a whole, provided Your use,
       reproduction, and distribution of the Work otherwise complies with
       the conditions stated in this License.
 
    5. Submission of Contributions. Unless You explicitly state otherwise,
       any Contribution intentionally submitted for inclusion in the Work
       by You to the Licensor shall be under the terms and conditions of
       this License, without any additional terms or conditions.
       Notwithstanding the above, nothing herein shall supersede or modify
       the terms of any separate license agreement you may have executed
       with Licensor regarding such Contributions.
 
    6. Trademarks. This License does not grant permission to use the trade
       names, trademarks, service marks, or product names of the Licensor,
       except as required for reasonable and customary use in describing the
       origin of the Work and reproducing the content of the NOTICE file.
 
    7. Disclaimer of Warranty. Unless required by applicable law or
       agreed to in writing, Licensor provides the Work (and each
       Contributor provides its Contributions) on an "AS IS" BASIS,
       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
       implied, including, without limitation, any warranties or conditions
       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
       PARTICULAR PURPOSE. You are solely responsible for determining the
       appropriateness of using or redistributing the Work and assume any
       risks associated with Your exercise of permissions under this License.
 
    8. Limitation of Liability. In no event and under no legal theory,
       whether in tort (including negligence), contract, or otherwise,
       unless required by applicable law (such as deliberate and grossly
       negligent acts) or agreed to in writing, shall any Contributor be
       liable to You for damages, including any direct, indirect, special,
       incidental, or consequential damages of any character arising as a
       result of this License or out of the use or inability to use the
       Work (including but not limited to damages for loss of goodwill,
       work stoppage, computer failure or malfunction, or any and all
       other commercial damages or losses), even if such Contributor
       has been advised of the possibility of such damages.
 
    9. Accepting Warranty or Additional Liability. While redistributing
       the Work or Derivative Works thereof, You may choose to offer,
       and charge a fee for, acceptance of support, warranty, indemnity,
       or other liability obligations and/or rights consistent with this
       License. However, in accepting such obligations, You may act only
       on Your own behalf and on Your sole responsibility, not on behalf
       of any other Contributor, and only if You agree to indemnify,
       defend, and hold each Contributor harmless for any liability
       incurred by, or claims asserted against, such Contributor by reason
       of your accepting any such warranty or additional liability.
 
    END OF TERMS AND CONDITIONS
 
    APPENDIX: How to apply the Apache License to your work.
 
       To apply the Apache License to your work, attach the following
       boilerplate notice, with the fields enclosed by brackets "[]"
       replaced with your own identifying information. (Don't include
       the brackets!)  The text should be enclosed in the appropriate
       comment syntax for the file format. We also recommend that a
       file or class name and description of purpose be included on the
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
    Copyright [yyyy] [name of copyright owner]
 
    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
+       https://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.
diff --git a/Modules/CppMicroServices/README.md b/Modules/CppMicroServices/README.md
index fcac6bd1d5..aeef8c7e66 100644
--- a/Modules/CppMicroServices/README.md
+++ b/Modules/CppMicroServices/README.md
@@ -1,100 +1,98 @@
-[![Build Status](https://secure.travis-ci.org/saschazelzer/CppMicroServices.png)](http://travis-ci.org/saschazelzer/CppMicroServices)
-
 [![Coverity Scan Build Status](https://scan.coverity.com/projects/1329/badge.svg)](https://scan.coverity.com/projects/1329)
 
 C++ Micro Services
 ==================
 
 Introduction
 ------------
 
 The C++ Micro Services library provides a dynamic service registry and module system,
 partially based the OSGi Core Release 5 specifications. It enables developers to create
 a service oriented and dynamic software stack.
 
 Proper usage of the C++ Micro Services library leads to
 
   - Re-use of software components
   - Loose coupling
   - Separation of concerns
   - Clean APIs based on service interfaces
   - Extensible systems
 
 and more.
 
 Requirements
 ------------
 
 This is a pure C++ implementation of the OSGi service model and does not have any third-party
 library dependencies.
 
 Supported Platforms
 -------------------
 
 The library should compile on many different platforms. Below is a list of tested compiler/OS combinations:
 
   - GCC 4.6 (Ubuntu 12.04)
   - GCC 4.8 (Ubuntu 13.10)
   - Clang 3.2 (Ubuntu 13.10)
   - Clang (MacOS X 10.8 and 10.9)
   - Visual Studio 2008 SP1, 2010, 2012, 2013 (Windows 7)
 
 Legal
 -----
 
 Copyright (c) German Cancer Research Center (DKFZ). Licensed under the [Apache License v2.0][apache_license].
 
 Quick Start
 -----------
 
 Essentially, the C++ Micro Services library provides you with a powerful dynamic service registry.
 Each shared or static library has an associated `ModuleContext` object, through which the service
 registry is accessed.
 
 To query the registry for a service object implementing one or more specific interfaces, the code
 would look like this:
 
 ```cpp
 #include <usModuleContext.h>
 #include <someInterface.h>
 
 using namespace us;
 
 void UseService(ModuleContext* context)
 {
   ServiceReference serviceRef = context->GetServiceReference<SomeInterface>();
   if (serviceRef)
   {
     SomeInterface* service = context->GetService<SomeInterface>(serviceRef);
     if (service) { /* do something */ }
   }
 }
 ```
 
 Registering a service object against a certain interface looks like this:
 
 ```cpp
 #include <usModuleContext.h>
 #include <someInterface.h>
 
 using namespace us;
 
 void RegisterSomeService(ModuleContext* context, SomeInterface* service)
 {
   context->RegisterService<SomeInterface>(service);
 }
 ```
 
 The OSGi service model additionally allows to annotate services with properties and using these
 properties during service look-ups. It also allows to track the life-cycle of service objects.
-Please see the [Documentation](http://cppmicroservices.org/doc_latest/index.html) for more
+Please see the [Documentation](https://cppmicroservices.org/doc_latest/index.html) for more
 examples and tutorials and the API reference. There is also a blog post about
-[OSGi Lite for C++](http://blog.cppmicroservices.org/2012/04/15/osgi-lite-for-c++).
+[OSGi Lite for C++](https://blog.cppmicroservices.org/2012/04/15/osgi-lite-for-c++).
 
 Build Instructions
 ------------------
 
 Please visit the [Build Instructions][bi_master] page online.
 
-[bi_master]: http://cppmicroservices.org/doc_latest/BuildInstructions.html
-[apache_license]: http://www.apache.org/licenses/LICENSE-2.0
+[bi_master]: https://cppmicroservices.org/doc_latest/BuildInstructions.html
+[apache_license]: https://www.apache.org/licenses/LICENSE-2.0
diff --git a/Modules/CppMicroServices/cmake/usCMakeResourceDependencies.cpp b/Modules/CppMicroServices/cmake/usCMakeResourceDependencies.cpp
index 03703b6bb6..79e22db6c1 100644
--- a/Modules/CppMicroServices/cmake/usCMakeResourceDependencies.cpp
+++ b/Modules/CppMicroServices/cmake/usCMakeResourceDependencies.cpp
@@ -1,33 +1,33 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 namespace {
 
 // This is dummy code to silence some linkers warning about
 // empty object files.
 struct CMakeResourceDependencies
 {
   CMakeResourceDependencies()
   {
   }
 };
 
 }
diff --git a/Modules/CppMicroServices/cmake/usModuleInit.cpp b/Modules/CppMicroServices/cmake/usModuleInit.cpp
index d8c7483773..93fbfcc180 100644
--- a/Modules/CppMicroServices/cmake/usModuleInit.cpp
+++ b/Modules/CppMicroServices/cmake/usModuleInit.cpp
@@ -1,24 +1,24 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModuleInitialization.h>
 
 US_INITIALIZE_MODULE
diff --git a/Modules/CppMicroServices/core/README.md b/Modules/CppMicroServices/core/README.md
index fcac6bd1d5..aeef8c7e66 100644
--- a/Modules/CppMicroServices/core/README.md
+++ b/Modules/CppMicroServices/core/README.md
@@ -1,100 +1,98 @@
-[![Build Status](https://secure.travis-ci.org/saschazelzer/CppMicroServices.png)](http://travis-ci.org/saschazelzer/CppMicroServices)
-
 [![Coverity Scan Build Status](https://scan.coverity.com/projects/1329/badge.svg)](https://scan.coverity.com/projects/1329)
 
 C++ Micro Services
 ==================
 
 Introduction
 ------------
 
 The C++ Micro Services library provides a dynamic service registry and module system,
 partially based the OSGi Core Release 5 specifications. It enables developers to create
 a service oriented and dynamic software stack.
 
 Proper usage of the C++ Micro Services library leads to
 
   - Re-use of software components
   - Loose coupling
   - Separation of concerns
   - Clean APIs based on service interfaces
   - Extensible systems
 
 and more.
 
 Requirements
 ------------
 
 This is a pure C++ implementation of the OSGi service model and does not have any third-party
 library dependencies.
 
 Supported Platforms
 -------------------
 
 The library should compile on many different platforms. Below is a list of tested compiler/OS combinations:
 
   - GCC 4.6 (Ubuntu 12.04)
   - GCC 4.8 (Ubuntu 13.10)
   - Clang 3.2 (Ubuntu 13.10)
   - Clang (MacOS X 10.8 and 10.9)
   - Visual Studio 2008 SP1, 2010, 2012, 2013 (Windows 7)
 
 Legal
 -----
 
 Copyright (c) German Cancer Research Center (DKFZ). Licensed under the [Apache License v2.0][apache_license].
 
 Quick Start
 -----------
 
 Essentially, the C++ Micro Services library provides you with a powerful dynamic service registry.
 Each shared or static library has an associated `ModuleContext` object, through which the service
 registry is accessed.
 
 To query the registry for a service object implementing one or more specific interfaces, the code
 would look like this:
 
 ```cpp
 #include <usModuleContext.h>
 #include <someInterface.h>
 
 using namespace us;
 
 void UseService(ModuleContext* context)
 {
   ServiceReference serviceRef = context->GetServiceReference<SomeInterface>();
   if (serviceRef)
   {
     SomeInterface* service = context->GetService<SomeInterface>(serviceRef);
     if (service) { /* do something */ }
   }
 }
 ```
 
 Registering a service object against a certain interface looks like this:
 
 ```cpp
 #include <usModuleContext.h>
 #include <someInterface.h>
 
 using namespace us;
 
 void RegisterSomeService(ModuleContext* context, SomeInterface* service)
 {
   context->RegisterService<SomeInterface>(service);
 }
 ```
 
 The OSGi service model additionally allows to annotate services with properties and using these
 properties during service look-ups. It also allows to track the life-cycle of service objects.
-Please see the [Documentation](http://cppmicroservices.org/doc_latest/index.html) for more
+Please see the [Documentation](https://cppmicroservices.org/doc_latest/index.html) for more
 examples and tutorials and the API reference. There is also a blog post about
-[OSGi Lite for C++](http://blog.cppmicroservices.org/2012/04/15/osgi-lite-for-c++).
+[OSGi Lite for C++](https://blog.cppmicroservices.org/2012/04/15/osgi-lite-for-c++).
 
 Build Instructions
 ------------------
 
 Please visit the [Build Instructions][bi_master] page online.
 
-[bi_master]: http://cppmicroservices.org/doc_latest/BuildInstructions.html
-[apache_license]: http://www.apache.org/licenses/LICENSE-2.0
+[bi_master]: https://cppmicroservices.org/doc_latest/BuildInstructions.html
+[apache_license]: https://www.apache.org/licenses/LICENSE-2.0
diff --git a/Modules/CppMicroServices/core/doc/doxygen/standalone/BuildInstructions.md b/Modules/CppMicroServices/core/doc/doxygen/standalone/BuildInstructions.md
index 201410319c..9cf1dcb75f 100644
--- a/Modules/CppMicroServices/core/doc/doxygen/standalone/BuildInstructions.md
+++ b/Modules/CppMicroServices/core/doc/doxygen/standalone/BuildInstructions.md
@@ -1,55 +1,55 @@
 Build Instructions    {#BuildInstructions}
 ==================
 
 The C++ Micro Services library provides [CMake][cmake] build scripts which allow the generation of
 platform and IDE specific project files.
 
 The library should compile on many different platforms. Below is a list of tested compiler/OS combinations:
 
   - GCC 4.6 (Ubuntu 12.04)
   - GCC 4.8 (Ubuntu 13.10)
   - Clang 3.2 (Ubuntu 13.10)
   - Clang (MacOS X 10.8 and 10.9)
   - Visual Studio 2008 SP1, 2010, 2012, 2013 (Windows 7)
 
 
 Prerequisites
 -------------
 
 - [CMake][cmake] 2.8 (Visual Studio 2010 and 2012 users should use the latest CMake version available)
 
 
 Configuring the Build
 ---------------------
 
 When building the C++ Micro Services library, you have a few configuration options at hand.
 
 ### General build options
 
 - **CMAKE_INSTALL_PREFIX**
   The installation path.
 - **US_BUILD_SHARED_LIBS**
   Specify if the library should be build shared or static. See \ref MicroServices_StaticModules
   for detailed information about static CppMicroServices modules.
 - **US_BUILD_TESTING**
   Build unit tests and code snippets.
 - **US_ENABLE_AUTOLOADING_SUPPORT**
   Enable auto-loading of modules located in special sub-directories. See \ref MicroServices_AutoLoading
   for detailed information about this feature.
 - **US_ENABLE_THREADING_SUPPORT**
   Enable the use of synchronization primitives (atomics and pthread mutexes or Windows primitives)
   to make the API thread-safe. If your application is not multi-threaded, turn this option OFF
   to get maximum performance.
 
 ### Customizing naming conventions
 
 - **US_NAMESPACE**
   The default namespace is `us` but you may override this at will.
 - **US_HEADER_PREFIX**
   By default, all public headers have a "us" prefix. You may specify an arbitrary prefix to match your
   naming conventions.
 
 The above options are mainly useful when embedding the C++ Micro Services source code in your own library and
 you want to make it look like native source code.
 
-[cmake]: http://www.cmake.org
+[cmake]: https://www.cmake.org
diff --git a/Modules/CppMicroServices/core/doc/snippets/uServices-staticmodules/MyStaticModule.cpp b/Modules/CppMicroServices/core/doc/snippets/uServices-staticmodules/MyStaticModule.cpp
index ca70b39ecb..330f2a6073 100644
--- a/Modules/CppMicroServices/core/doc/snippets/uServices-staticmodules/MyStaticModule.cpp
+++ b/Modules/CppMicroServices/core/doc/snippets/uServices-staticmodules/MyStaticModule.cpp
@@ -1,39 +1,39 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModuleActivator.h>
 #include <usModuleInitialization.h>
 
 US_USE_NAMESPACE
 
 struct MyStaticModuleActivator : public ModuleActivator
 {
   void Load(ModuleContext* /*context*/) override
   {
     std::cout << "Hello from a static module." << std::endl;
   }
 
   void Unload(ModuleContext* /*context*/) override {}
 };
 
 US_EXPORT_MODULE_ACTIVATOR(MyStaticModuleActivator)
 
 US_INITIALIZE_MODULE
diff --git a/Modules/CppMicroServices/core/examples/dictionaryclient/Activator.cpp b/Modules/CppMicroServices/core/examples/dictionaryclient/Activator.cpp
index 45f9782701..b906378932 100644
--- a/Modules/CppMicroServices/core/examples/dictionaryclient/Activator.cpp
+++ b/Modules/CppMicroServices/core/examples/dictionaryclient/Activator.cpp
@@ -1,121 +1,121 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 //! [Activator]
 #include "IDictionaryService.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 
 US_USE_NAMESPACE
 
 namespace {
 
 /**
  * This class implements a module activator that uses a dictionary service to check for
  * the proper spelling of a word by check for its existence in the dictionary.
  * This modules uses the first service that it finds and does not monitor the
  * dynamic availability of the service (i.e., it does not listen for the arrival
  * or departure of dictionary services). When loading this module, the thread
  * calling the Load() method is used to read words from standard input. You can
  * stop checking words by entering an empty line, but to start checking words
  * again you must unload and then load the module again.
  */
 class US_ABI_LOCAL Activator : public ModuleActivator
 {
 
 public:
 
   /**
    * Implements ModuleActivator::Load(). Queries for all available dictionary
    * services. If none are found it simply prints a message and returns,
    * otherwise it reads words from standard input and checks for their
    * existence from the first dictionary that it finds.
    *
    * \note It is very bad practice to use the calling thread to perform a lengthy
    *       process like this; this is only done for the purpose of the tutorial.
    *
    * @param context the module context for this module.
    */
   void Load(ModuleContext *context)
   {
     // Query for all service references matching any language.
     std::vector<ServiceReference<IDictionaryService> > refs =
         context->GetServiceReferences<IDictionaryService>("(Language=*)");
 
     if (!refs.empty())
     {
       std::cout << "Enter a blank line to exit." << std::endl;
 
       // Loop endlessly until the user enters a blank line
       while (std::cin)
       {
         // Ask the user to enter a word.
         std::cout << "Enter word: ";
 
         std::string word;
         std::getline(std::cin, word);
 
         // If the user entered a blank line, then
         // exit the loop.
         if (word.empty())
         {
           break;
         }
 
         // First, get a dictionary service and then check
         // if the word is correct.
         IDictionaryService* dictionary = context->GetService<IDictionaryService>(refs.front());
         if ( dictionary->CheckWord( word ) )
         {
           std::cout << "Correct." << std::endl;
         }
         else
         {
           std::cout << "Incorrect." << std::endl;
         }
 
         // Unget the dictionary service.
         context->UngetService(refs.front());
       }
     }
     else
     {
       std::cout << "Couldn't find any dictionary service..." << std::endl;
     }
   }
 
   /**
    * Implements ModuleActivator::Unload(). Does nothing since
    * the C++ Micro Services library will automatically unget any used services.
    * @param context the context for the module.
    */
   void Unload(ModuleContext* /*context*/)
   {
     // NOTE: The service is automatically released.
   }
 
 };
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(Activator)
 //![Activator]
diff --git a/Modules/CppMicroServices/core/examples/dictionaryclient2/Activator.cpp b/Modules/CppMicroServices/core/examples/dictionaryclient2/Activator.cpp
index bd3b2d5da6..0f64b229eb 100644
--- a/Modules/CppMicroServices/core/examples/dictionaryclient2/Activator.cpp
+++ b/Modules/CppMicroServices/core/examples/dictionaryclient2/Activator.cpp
@@ -1,218 +1,218 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 //! [Activator]
 #include "IDictionaryService.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 
 US_USE_NAMESPACE
 
 namespace {
 
 /**
  * This class implements a module activator that uses a dictionary service to check for
  * the proper spelling of a word by checking for its existence in the
  * dictionary. This module is more complex than the module in Example 3 because
  * it monitors the dynamic availability of the dictionary services. In other
  * words, if the service it is using departs, then it stops using it gracefully,
  * or if it needs a service and one arrives, then it starts using it
  * automatically. As before, the module uses the first service that it finds and
  * uses the calling thread of the Load() method to read words from standard
  * input. You can stop checking words by entering an empty line, but to start
  * checking words again you must unload and then load the module again.
  */
 class US_ABI_LOCAL Activator : public ModuleActivator
 {
 
 public:
 
   Activator()
    : m_context(nullptr)
    , m_dictionary(nullptr)
   {}
 
   /**
    * Implements ModuleActivator::Load(). Adds itself as a listener for service
    * events, then queries for available dictionary services. If any
    * dictionaries are found it gets a reference to the first one available and
    * then starts its "word checking loop". If no dictionaries are found, then
    * it just goes directly into its "word checking loop", but it will not be
    * able to check any words until a dictionary service arrives; any arriving
    * dictionary service will be automatically used by the client if a
    * dictionary is not already in use. Once it has dictionary, it reads words
    * from standard input and checks for their existence in the dictionary that
    * it is using.
    *
    * \note It is very bad practice to use the calling thread to perform a
    *       lengthy process like this; this is only done for the purpose of
    *       the tutorial.
    *
    * @param context the module context for this module.
    */
   void Load(ModuleContext *context)
   {
     m_context = context;
 
     {
       // Use your favorite thread library to synchronize member
       // variable access within this scope while registering
       // the service listener and performing our initial
       // dictionary service lookup since we
       // don't want to receive service events when looking up the
       // dictionary service, if one exists.
       // MutexLocker lock(&m_mutex);
 
       // Listen for events pertaining to dictionary services.
       m_context->AddServiceListener(this, &Activator::ServiceChanged,
                                     std::string("(&(") + ServiceConstants::OBJECTCLASS() + "=" +
                                     us_service_interface_iid<IDictionaryService>() + ")" + "(Language=*))");
 
       // Query for any service references matching any language.
       std::vector<ServiceReference<IDictionaryService> > refs =
           context->GetServiceReferences<IDictionaryService>("(Language=*)");
 
       // If we found any dictionary services, then just get
       // a reference to the first one so we can use it.
       if (!refs.empty())
       {
         m_ref = refs.front();
         m_dictionary = m_context->GetService(m_ref);
       }
     }
 
     std::cout << "Enter a blank line to exit." << std::endl;
 
     // Loop endlessly until the user enters a blank line
     while (std::cin)
     {
       // Ask the user to enter a word.
       std::cout << "Enter word: ";
 
       std::string word;
       std::getline(std::cin, word);
 
       // If the user entered a blank line, then
       // exit the loop.
       if (word.empty())
       {
         break;
       }
       // If there is no dictionary, then say so.
       else if (m_dictionary == nullptr)
       {
         std::cout << "No dictionary available." << std::endl;
       }
       // Otherwise print whether the word is correct or not.
       else if (m_dictionary->CheckWord( word ))
       {
         std::cout << "Correct." << std::endl;
       }
       else
       {
         std::cout << "Incorrect." << std::endl;
       }
     }
   }
 
   /**
    * Implements ModuleActivator::Unload(). Does nothing since
    * the C++ Micro Services library will automatically unget any used services.
    * @param context the context for the module.
    */
   void Unload(ModuleContext* /*context*/)
   {
     // NOTE: The service is automatically released.
   }
 
   /**
    * Implements ServiceListener.serviceChanged(). Checks to see if the service
    * we are using is leaving or tries to get a service if we need one.
    *
    * @param event the fired service event.
    */
   void ServiceChanged(const ServiceEvent event)
   {
     // Use your favorite thread library to synchronize this
     // method with the Load() method.
     // MutexLocker lock(&m_mutex);
 
     // If a dictionary service was registered, see if we
     // need one. If so, get a reference to it.
     if (event.GetType() == ServiceEvent::REGISTERED)
     {
       if (!m_ref)
       {
         // Get a reference to the service object.
         m_ref = event.GetServiceReference();
         m_dictionary = m_context->GetService(m_ref);
       }
     }
     // If a dictionary service was unregistered, see if it
     // was the one we were using. If so, unget the service
     // and try to query to get another one.
     else if (event.GetType() == ServiceEvent::UNREGISTERING)
     {
       if (event.GetServiceReference() == m_ref)
       {
         // Unget service object and null references.
         m_context->UngetService(m_ref);
         m_ref = 0;
         m_dictionary = nullptr;
 
         // Query to see if we can get another service.
         std::vector<ServiceReference<IDictionaryService> > refs;
         try
         {
           refs = m_context->GetServiceReferences<IDictionaryService>("(Language=*)");
         }
         catch (const std::invalid_argument& e)
         {
           std::cout << e.what() << std::endl;
         }
 
         if (!refs.empty())
         {
           // Get a reference to the first service object.
           m_ref = refs.front();
           m_dictionary = m_context->GetService(m_ref);
         }
       }
     }
   }
 
 private:
 
   // Module context
   ModuleContext* m_context;
 
   // The service reference being used
   ServiceReference<IDictionaryService> m_ref;
 
   // The service object being used
   IDictionaryService* m_dictionary;
 };
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(Activator)
 //![Activator]
diff --git a/Modules/CppMicroServices/core/examples/dictionaryclient3/Activator.cpp b/Modules/CppMicroServices/core/examples/dictionaryclient3/Activator.cpp
index f3c8616993..f61bd74382 100644
--- a/Modules/CppMicroServices/core/examples/dictionaryclient3/Activator.cpp
+++ b/Modules/CppMicroServices/core/examples/dictionaryclient3/Activator.cpp
@@ -1,146 +1,146 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 //! [Activator]
 #include "IDictionaryService.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usServiceTracker.h>
 
 US_USE_NAMESPACE
 
 namespace {
 
 /**
  * This class implements a module activator that uses a dictionary
  * service to check for the proper spelling of a word by
  * checking for its existence in the dictionary. This module
  * uses a service tracker to dynamically monitor the availability
  * of a dictionary service, instead of providing a custom service
  * listener as in Example 4. The module uses the service returned
  * by the service tracker, which is selected based on a ranking
  * algorithm defined by the C++ Micro Services library.
  * Again, the calling thread of the Load() method is used to read
  * words from standard input, checking its existence in the dictionary.
  * You can stop checking words by entering an empty line, but
  * to start checking words again you must unload and then load
  * the module again.
  */
 class US_ABI_LOCAL Activator : public ModuleActivator
 {
 
 public:
 
   Activator()
    : m_context(nullptr)
    , m_tracker(nullptr)
   {}
 
   /**
    * Implements ModuleActivator::Load(). Creates a service
    * tracker to monitor dictionary services and starts its "word
    * checking loop". It will not be able to check any words until
    * the service tracker finds a dictionary service; any discovered
    * dictionary service will be automatically used by the client.
    * It reads words from standard input and checks for their
    * existence in the discovered dictionary.
    *
    * \note It is very bad practice to use the calling thread to perform a
    *       lengthy process like this; this is only done for the purpose of
    *       the tutorial.
    *
    * @param context the module context for this module.
    */
   void Load(ModuleContext *context)
   {
     m_context = context;
 
     // Create a service tracker to monitor dictionary services.
     m_tracker = new ServiceTracker<IDictionaryService>(
                   m_context, LDAPFilter(std::string("(&(") + ServiceConstants::OBJECTCLASS() + "=" +
                                         us_service_interface_iid<IDictionaryService>() + ")" +
                                         "(Language=*))")
                   );
     m_tracker->Open();
 
     std::cout << "Enter a blank line to exit." << std::endl;
 
     // Loop endlessly until the user enters a blank line
     while (std::cin)
     {
       // Ask the user to enter a word.
       std::cout << "Enter word: ";
 
       std::string word;
       std::getline(std::cin, word);
 
       // Get the selected dictionary, if available.
       IDictionaryService* dictionary = m_tracker->GetService();
 
       // If the user entered a blank line, then
       // exit the loop.
       if (word.empty())
       {
         break;
       }
       // If there is no dictionary, then say so.
       else if (dictionary == nullptr)
       {
         std::cout << "No dictionary available." << std::endl;
       }
       // Otherwise print whether the word is correct or not.
       else if (dictionary->CheckWord(word))
       {
         std::cout << "Correct." << std::endl;
       }
       else
       {
         std::cout << "Incorrect." << std::endl;
       }
     }
 
     // This automatically closes the tracker
     delete m_tracker;
   }
 
   /**
    * Implements ModuleActivator::Unload(). Does nothing since
    * the C++ Micro Services library will automatically unget any used services.
    * @param context the context for the module.
    */
   void Unload(ModuleContext* /*context*/)
   {
   }
 
 private:
 
   // Module context
   ModuleContext* m_context;
 
   // The service tracker
   ServiceTracker<IDictionaryService>* m_tracker;
 };
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(Activator)
 //![Activator]
diff --git a/Modules/CppMicroServices/core/examples/dictionaryservice/Activator.cpp b/Modules/CppMicroServices/core/examples/dictionaryservice/Activator.cpp
index 3a00e7fde5..a5d3a9065c 100644
--- a/Modules/CppMicroServices/core/examples/dictionaryservice/Activator.cpp
+++ b/Modules/CppMicroServices/core/examples/dictionaryservice/Activator.cpp
@@ -1,120 +1,120 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 //! [Activator]
 #include "IDictionaryService.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usServiceProperties.h>
 
 #include <set>
 #include <memory>
 
 US_USE_NAMESPACE
 
 namespace {
 
 /**
  * This class implements a module activator that uses the module
  * context to register an English language dictionary service
  * with the C++ Micro Services registry during static initialization
  * of the module. The dictionary service interface is
  * defined in a separate file and is implemented by a nested class.
  */
 class US_ABI_LOCAL Activator : public ModuleActivator
 {
 
 private:
 
   /**
    * A private inner class that implements a dictionary service;
    * see IDictionaryService for details of the service.
    */
   class DictionaryImpl : public IDictionaryService
   {
     // The set of words contained in the dictionary.
     std::set<std::string> m_dictionary;
 
   public:
 
     DictionaryImpl()
     {
       m_dictionary.insert("welcome");
       m_dictionary.insert("to");
       m_dictionary.insert("the");
       m_dictionary.insert("micro");
       m_dictionary.insert("services");
       m_dictionary.insert("tutorial");
     }
 
     /**
      * Implements IDictionaryService::CheckWord(). Determines
      * if the passed in word is contained in the dictionary.
      * @param word the word to be checked.
      * @return true if the word is in the dictionary,
      *         false otherwise.
      **/
     bool CheckWord(const std::string& word)
     {
       std::string lword(word);
       std::transform(lword.begin(), lword.end(), lword.begin(), ::tolower);
 
       return m_dictionary.find(lword) != m_dictionary.end();
     }
   };
 
   std::unique_ptr<DictionaryImpl> m_dictionaryService;
 
 
 public:
 
   /**
    * Implements ModuleActivator::Load(). Registers an
    * instance of a dictionary service using the module context;
    * attaches properties to the service that can be queried
    * when performing a service look-up.
    * @param context the context for the module.
    */
   void Load(ModuleContext* context)
   {
     m_dictionaryService.reset(new DictionaryImpl);
     ServiceProperties props;
     props["Language"] = std::string("English");
     context->RegisterService<IDictionaryService>(m_dictionaryService.get(), props);
   }
 
   /**
    * Implements ModuleActivator::Unload(). Does nothing since
    * the C++ Micro Services library will automatically unregister any registered services.
    * @param context the context for the module.
    */
   void Unload(ModuleContext* /*context*/)
   {
     // NOTE: The service is automatically unregistered
   }
 
 };
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(Activator)
 //![Activator]
diff --git a/Modules/CppMicroServices/core/examples/dictionaryservice/IDictionaryService.cpp b/Modules/CppMicroServices/core/examples/dictionaryservice/IDictionaryService.cpp
index c375ff0cc5..b3dc99f9bb 100644
--- a/Modules/CppMicroServices/core/examples/dictionaryservice/IDictionaryService.cpp
+++ b/Modules/CppMicroServices/core/examples/dictionaryservice/IDictionaryService.cpp
@@ -1,25 +1,25 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "IDictionaryService.h"
 
 IDictionaryService::~IDictionaryService()
 {}
diff --git a/Modules/CppMicroServices/core/examples/dictionaryservice/IDictionaryService.h b/Modules/CppMicroServices/core/examples/dictionaryservice/IDictionaryService.h
index 58d288748c..f80aae1cbc 100644
--- a/Modules/CppMicroServices/core/examples/dictionaryservice/IDictionaryService.h
+++ b/Modules/CppMicroServices/core/examples/dictionaryservice/IDictionaryService.h
@@ -1,60 +1,60 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef IDICTIONARYSERVICE_H
 #define IDICTIONARYSERVICE_H
 
 //! [service]
 #include <usServiceInterface.h>
 
 #include <string>
 
 #ifdef US_BUILD_SHARED_LIBS
 #ifdef Example_dictionaryservice_EXPORTS
   #define DICTIONARYSERVICE_EXPORT US_ABI_EXPORT
 #else
   #define DICTIONARYSERVICE_EXPORT US_ABI_IMPORT
 #endif
 #else
 #define DICTIONARYSERVICE_EXPORT US_ABI_EXPORT
 #endif
 
 /**
  * A simple service interface that defines a dictionary service.
  * A dictionary service simply verifies the existence of a word.
  **/
 struct DICTIONARYSERVICE_EXPORT IDictionaryService
 {
   // Out-of-line virtual desctructor for proper dynamic cast
   // support with older versions of gcc.
   virtual ~IDictionaryService();
 
   /**
    * Check for the existence of a word.
    * @param word the word to be checked.
    * @return true if the word is in the dictionary,
    *         false otherwise.
    **/
   virtual bool CheckWord(const std::string& word) = 0;
 };
 //! [service]
 
 #endif // DICTIONARYSERVICE_H
diff --git a/Modules/CppMicroServices/core/examples/driver/main.cpp b/Modules/CppMicroServices/core/examples/driver/main.cpp
index 5949a084a0..ee7ffbdb42 100644
--- a/Modules/CppMicroServices/core/examples/driver/main.cpp
+++ b/Modules/CppMicroServices/core/examples/driver/main.cpp
@@ -1,309 +1,309 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModule.h>
 #include <usModuleRegistry.h>
 #include <usSharedLibrary.h>
 #include <usModuleImport.h>
 
 #include "usCoreExamplesDriverConfig.h"
 
 #if defined(US_PLATFORM_POSIX)
   #include <dlfcn.h>
 #elif defined(US_PLATFORM_WINDOWS)
   #ifndef WIN32_LEAN_AND_MEAN
     #define WIN32_LEAN_AND_MEAN
   #endif
   #include <windows.h>
   #include <strsafe.h>
 #else
   #error Unsupported platform
 #endif
 
 #include <iostream>
 #include <iomanip>
 #include <map>
 #include <set>
 #include <sstream>
 #include <stdexcept>
 #include <algorithm>
 
 US_USE_NAMESPACE
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
 std::vector<std::string> GetExampleModules()
 {
   std::vector<std::string> names;
 #ifdef US_BUILD_SHARED_LIBS
   names.push_back("eventlistener");
   names.push_back("dictionaryservice");
   names.push_back("frenchdictionary");
   names.push_back("dictionaryclient");
   names.push_back("dictionaryclient2");
   names.push_back("dictionaryclient3");
   names.push_back("spellcheckservice");
   names.push_back("spellcheckclient");
 #endif
   return names;
 }
 
 int main(int /*argc*/, char** /*argv*/)
 {
   char cmd[256];
 
   std::vector<std::string> availableModules = GetExampleModules();
 
   /* module path -> lib handle */
   std::map<std::string, SharedLibrary> libraryHandles;
 
   SharedLibrary sharedLib(LIB_PATH, "");
 
   std::cout << "> ";
   while(std::cin.getline(cmd, sizeof(cmd)))
   {
     std::string strCmd(cmd);
     if (strCmd == "q")
     {
       break;
     }
     else if (strCmd == "h")
     {
       std::cout << std::left << std::setw(15) << "h" << " This help text\n"
                 << std::setw(15) << "l <id | name>" << " Load the module with id <id> or name <name>\n"
                 << std::setw(15) << "u <id>" << " Unload the module with id <id>\n"
                 << std::setw(15) << "s" << " Print status information\n"
                 << std::setw(15) << "q" << " Quit\n" << std::flush;
     }
     else if (strCmd.find("l ") != std::string::npos)
     {
       std::string idOrName;
       idOrName.assign(strCmd.begin()+2, strCmd.end());
       std::stringstream ss(idOrName);
 
       long int id = -1;
       ss >> id;
       if (id > 0)
       {
         Module* module = ModuleRegistry::GetModule(id);
         if (!module)
         {
           std::cout << "Error: unknown id" << std::endl;
         }
         else if (module->IsLoaded())
         {
           std::cout << "Info: module already loaded" << std::endl;
         }
         else
         {
           try
           {
             std::map<std::string, SharedLibrary>::iterator libIter =
                 libraryHandles.find(module->GetLocation());
             if (libIter != libraryHandles.end())
             {
               libIter->second.Load();
             }
             else
             {
               // The module has been loaded previously due to a
               // linker dependency
               SharedLibrary libHandle(module->GetLocation());
               libHandle.Load();
               libraryHandles.insert(std::make_pair(libHandle.GetFilePath(), libHandle));
             }
           }
           catch (const std::exception& e)
           {
             std::cout << e.what() << std::endl;
           }
         }
       }
       else
       {
         Module* module = ModuleRegistry::GetModule(idOrName);
         if (!module)
         {
           try
           {
             std::map<std::string, SharedLibrary>::iterator libIter =
                 libraryHandles.find(sharedLib.GetFilePath(idOrName));
             if (libIter != libraryHandles.end())
             {
               libIter->second.Load();
             }
             else
             {
               bool libFound = false;
               for (std::vector<std::string>::const_iterator availableModuleIter = availableModules.begin();
                    availableModuleIter != availableModules.end(); ++availableModuleIter)
               {
                 if (*availableModuleIter == idOrName)
                 {
                   libFound = true;
                 }
               }
               if (!libFound)
               {
                 std::cout << "Error: unknown example module" << std::endl;
               }
               else
               {
                 SharedLibrary libHandle(LIB_PATH, idOrName);
                 libHandle.Load();
                 libraryHandles.insert(std::make_pair(libHandle.GetFilePath(), libHandle));
               }
             }
 
             std::vector<Module*> modules = ModuleRegistry::GetModules();
             for (std::vector<Module*>::const_iterator moduleIter = modules.begin();
                  moduleIter != modules.end(); ++moduleIter)
             {
               availableModules.erase(std::remove(availableModules.begin(), availableModules.end(), (*moduleIter)->GetName()),
                                      availableModules.end());
             }
 
           }
           catch (const std::exception& e)
           {
             std::cout << e.what() << std::endl;
           }
         }
         else if (!module->IsLoaded())
         {
           try
           {
             const std::string modulePath = module->GetLocation();
             std::map<std::string, SharedLibrary>::iterator libIter =
                 libraryHandles.find(modulePath);
             if (libIter != libraryHandles.end())
             {
               libIter->second.Load();
             }
             else
             {
               SharedLibrary libHandle(LIB_PATH, idOrName);
               libHandle.Load();
               libraryHandles.insert(std::make_pair(libHandle.GetFilePath(), libHandle));
             }
           }
           catch (const std::exception& e)
           {
             std::cout << e.what() << std::endl;
           }
         }
         else if (module)
         {
           std::cout << "Info: module already loaded" << std::endl;
         }
       }
     }
     else if (strCmd.find("u ") != std::string::npos)
     {
       std::stringstream ss(strCmd);
       ss.ignore(2);
 
       long int id = -1;
       ss >> id;
 
       if (id == 1)
       {
         std::cout << "Info: Unloading not possible" << std::endl;
       }
       else
       {
         Module* const module = ModuleRegistry::GetModule(id);
         if (module)
         {
           std::map<std::string, SharedLibrary>::iterator libIter =
               libraryHandles.find(module->GetLocation());
           if (libIter == libraryHandles.end())
           {
             std::cout << "Info: Unloading not possible. The module was loaded by a dependent module." << std::endl;
           }
           else
           {
             try
             {
               libIter->second.Unload();
 
               // Check if it has really been unloaded
               if (module->IsLoaded())
               {
                 std::cout << "Info: The module is still referenced by another loaded module. It will be unloaded when all dependent modules are unloaded." << std::endl;
               }
             }
             catch (const std::exception& e)
             {
               std::cout << e.what() << std::endl;
             }
           }
         }
         else
         {
           std::cout << "Error: unknown id" << std::endl;
         }
       }
     }
     else if (strCmd == "s")
     {
       std::vector<Module*> modules = ModuleRegistry::GetModules();
 
       std::cout << std::left;
 
       std::cout << "Id | " << std::setw(20) << "Name" << " | " << std::setw(9) << "Status" << std::endl;
       std::cout << "-----------------------------------\n";
 
       for (std::vector<std::string>::const_iterator nameIter = availableModules.begin();
            nameIter != availableModules.end(); ++nameIter)
       {
         std::cout << " - | " << std::setw(20) << *nameIter << " | " << std::setw(9) << "-" << std::endl;
       }
 
       for (std::vector<Module*>::const_iterator moduleIter = modules.begin();
            moduleIter != modules.end(); ++moduleIter)
       {
         std::cout << std::right << std::setw(2) << (*moduleIter)->GetModuleId() << std::left << " | ";
         std::cout << std::setw(20) << (*moduleIter)->GetName() << " | ";
         std::cout << std::setw(9) << ((*moduleIter)->IsLoaded() ? "LOADED" : "UNLOADED");
         std::cout << std::endl;
       }
     }
     else
     {
       std::cout << "Unknown command: " << strCmd << " (type 'h' for help)" << std::endl;
     }
     std::cout << "> ";
   }
 
   return 0;
 }
 
 #ifndef US_BUILD_SHARED_LIBS
 US_IMPORT_MODULE(CppMicroServices)
 US_IMPORT_MODULE(eventlistener)
 US_IMPORT_MODULE(dictionaryservice)
 US_IMPORT_MODULE(dictionaryclient)
 #endif
diff --git a/Modules/CppMicroServices/core/examples/driver/usCoreExamplesDriverConfig.h.in b/Modules/CppMicroServices/core/examples/driver/usCoreExamplesDriverConfig.h.in
index 95af0c8cc3..1fa983d856 100644
--- a/Modules/CppMicroServices/core/examples/driver/usCoreExamplesDriverConfig.h.in
+++ b/Modules/CppMicroServices/core/examples/driver/usCoreExamplesDriverConfig.h.in
@@ -1,41 +1,41 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USEXAMPLEDRIVERCONFIG_H
 #define USEXAMPLEDRIVERCONFIG_H
 
 #include "usGlobalConfig.h"
 
 #ifdef US_PLATFORM_POSIX
 #define PATH_SEPARATOR "/"
 #else
 #define PATH_SEPARATOR "\\"
 #endif
 
 #ifdef CMAKE_INTDIR
 #define US_LIBRARY_OUTPUT_DIRECTORY "@CMAKE_LIBRARY_OUTPUT_DIRECTORY_NATIVE@" PATH_SEPARATOR CMAKE_INTDIR
 #define US_RUNTIME_OUTPUT_DIRECTORY "@CMAKE_RUNTIME_OUTPUT_DIRECTORY_NATIVE@" PATH_SEPARATOR CMAKE_INTDIR
 #else
 #define US_LIBRARY_OUTPUT_DIRECTORY "@CMAKE_LIBRARY_OUTPUT_DIRECTORY_NATIVE@"
 #define US_RUNTIME_OUTPUT_DIRECTORY "@CMAKE_RUNTIME_OUTPUT_DIRECTORY_NATIVE@"
 #endif
 
 #endif // USEXAMPLEDRIVERCONFIG_H
diff --git a/Modules/CppMicroServices/core/examples/eventlistener/Activator.cpp b/Modules/CppMicroServices/core/examples/eventlistener/Activator.cpp
index a4462a7339..e749f64dc4 100644
--- a/Modules/CppMicroServices/core/examples/eventlistener/Activator.cpp
+++ b/Modules/CppMicroServices/core/examples/eventlistener/Activator.cpp
@@ -1,94 +1,94 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 //! [Activator]
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 
 US_USE_NAMESPACE
 
 namespace {
 
 /**
  * This class implements a simple module that utilizes the CppMicroServices's
  * event mechanism to listen for service events. Upon receiving a service event,
  * it prints out the event's details.
  */
 class Activator : public ModuleActivator
 {
 
 private:
 
   /**
    * Implements ModuleActivator::Load(). Prints a message and adds a member
    * function to the module context as a service listener.
    *
    * @param context the framework context for the module.
    */
   void Load(ModuleContext* context)
   {
     std::cout << "Starting to listen for service events." << std::endl;
     context->AddServiceListener(this, &Activator::ServiceChanged);
   }
 
   /**
    * Implements ModuleActivator::Unload(). Prints a message and removes the
    * member function from the module context as a service listener.
    *
    * @param context the framework context for the module.
    */
   void Unload(ModuleContext* context)
   {
     context->RemoveServiceListener(this, &Activator::ServiceChanged);
     std::cout << "Stopped listening for service events." << std::endl;
 
     // Note: It is not required that we remove the listener here,
     // since the framework will do it automatically anyway.
   }
 
   /**
    * Prints the details of any service event from the framework.
    *
    * @param event the fired service event.
    */
   void ServiceChanged(const ServiceEvent event)
   {
     std::string objectClass = ref_any_cast<std::vector<std::string> >(event.GetServiceReference().GetProperty(ServiceConstants::OBJECTCLASS())).front();
 
     if (event.GetType() == ServiceEvent::REGISTERED)
     {
       std::cout << "Ex1: Service of type " << objectClass << " registered." << std::endl;
     }
     else if (event.GetType() == ServiceEvent::UNREGISTERING)
     {
       std::cout << "Ex1: Service of type " << objectClass << " unregistered." << std::endl;
     }
     else if (event.GetType() == ServiceEvent::MODIFIED)
     {
       std::cout << "Ex1: Service of type " << objectClass << " modified." << std::endl;
     }
   }
 };
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(Activator)
 //! [Activator]
diff --git a/Modules/CppMicroServices/core/examples/frenchdictionary/Activator.cpp b/Modules/CppMicroServices/core/examples/frenchdictionary/Activator.cpp
index 009b45f2f3..f89f114e19 100644
--- a/Modules/CppMicroServices/core/examples/frenchdictionary/Activator.cpp
+++ b/Modules/CppMicroServices/core/examples/frenchdictionary/Activator.cpp
@@ -1,122 +1,122 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 //! [Activator]
 #include "IDictionaryService.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usServiceProperties.h>
 
 #include <set>
 #include <algorithm>
 #include <memory>
 
 US_USE_NAMESPACE
 
 namespace {
 
 /**
  * This class implements a module activator that uses the module
  * context to register a French language dictionary service
  * with the C++ Micro Services registry during static initialization
  * of the module. The dictionary service interface is
  * defined in Example 2 (dictionaryservice) and is implemented by a
  * nested class. This class is identical to the class in Example 2,
  * except that the dictionary contains French words.
  */
 class US_ABI_LOCAL Activator : public ModuleActivator
 {
 
 private:
 
   /**
    * A private inner class that implements a dictionary service;
    * see DictionaryService for details of the service.
    */
   class DictionaryImpl : public IDictionaryService
   {
     // The set of words contained in the dictionary.
     std::set<std::string> m_dictionary;
 
   public:
 
     DictionaryImpl()
     {
       m_dictionary.insert("bienvenue");
       m_dictionary.insert("au");
       m_dictionary.insert("tutoriel");
       m_dictionary.insert("micro");
       m_dictionary.insert("services");
     }
 
     /**
      * Implements DictionaryService.checkWord(). Determines
      * if the passed in word is contained in the dictionary.
      * @param word the word to be checked.
      * @return true if the word is in the dictionary,
      *         false otherwise.
      **/
     bool CheckWord(const std::string& word)
     {
       std::string lword(word);
       std::transform(lword.begin(), lword.end(), lword.begin(), ::tolower);
 
       return m_dictionary.find(lword) != m_dictionary.end();
     }
   };
 
   std::unique_ptr<DictionaryImpl> m_dictionaryService;
 
 
 public:
 
   /**
    * Implements ModuleActivator::Load(). Registers an
    * instance of a dictionary service using the module context;
    * attaches properties to the service that can be queried
    * when performing a service look-up.
    * @param context the context for the module.
    */
   void Load(ModuleContext* context)
   {
     m_dictionaryService.reset(new DictionaryImpl);
     ServiceProperties props;
     props["Language"] = std::string("French");
     context->RegisterService<IDictionaryService>(m_dictionaryService.get(), props);
   }
 
   /**
    * Implements ModuleActivator::Unload(). Does nothing since
    * the C++ Micro Services library will automatically unregister any registered services.
    * @param context the context for the module.
    */
   void Unload(ModuleContext* /*context*/)
   {
     // NOTE: The service is automatically unregistered
   }
 
 };
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(Activator)
 //![Activator]
diff --git a/Modules/CppMicroServices/core/examples/spellcheckclient/Activator.cpp b/Modules/CppMicroServices/core/examples/spellcheckclient/Activator.cpp
index 11cabc3748..0b9c174dc9 100644
--- a/Modules/CppMicroServices/core/examples/spellcheckclient/Activator.cpp
+++ b/Modules/CppMicroServices/core/examples/spellcheckclient/Activator.cpp
@@ -1,147 +1,147 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 //! [Activator]
 #include "ISpellCheckService.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usServiceTracker.h>
 
 #include <iostream>
 #include <cstring>
 
 US_USE_NAMESPACE
 
 namespace {
 
 /**
  * This class implements a module that uses a spell checker
  * service to check the spelling of a passage. This module
  * is essentially identical to Example 5, in that it uses the
  * Service Tracker to monitor the dynamic availability of the
  * spell checker service. When loading this module, the thread
  * calling the Load() method is used to read passages from
  * standard input. You can stop spell checking passages by
  * entering an empty line, but to start spell checking again
  * you must un-load and then load the module again.
 **/
 class US_ABI_LOCAL Activator : public ModuleActivator
 {
 
 public:
 
   Activator()
    : m_context(nullptr)
    , m_tracker(nullptr)
   {}
 
   /**
    * Implements ModuleActivator::Load(). Creates a service
    * tracker object to monitor spell checker services. Enters
    * a spell check loop where it reads passages from standard
    * input and checks their spelling using the spell checker service.
    *
    * \note It is very bad practice to use the calling thread to perform a
    *       lengthy process like this; this is only done for the purpose of
    *       the tutorial.
    *
    * @param context the module context for this module.
    */
   void Load(ModuleContext *context)
   {
     m_context = context;
 
     // Create a service tracker to monitor spell check services.
     m_tracker = new ServiceTracker<ISpellCheckService>(m_context);
     m_tracker->Open();
 
     std::cout << "Enter a blank line to exit." << std::endl;
 
     // Loop endlessly until the user enters a blank line
     while (std::cin)
     {
       // Ask the user to enter a passage.
       std::cout << "Enter passage: ";
 
       std::string passage;
       std::getline(std::cin, passage);
 
       // Get the selected spell check service, if available.
       ISpellCheckService* checker = m_tracker->GetService();
 
       // If the user entered a blank line, then
       // exit the loop.
       if (passage.empty())
       {
         break;
       }
       // If there is no spell checker, then say so.
       else if (checker == nullptr)
       {
         std::cout << "No spell checker available." << std::endl;
       }
       // Otherwise check passage and print misspelled words.
       else
       {
         std::vector<std::string> errors = checker->Check(passage);
 
         if (errors.empty())
         {
           std::cout << "Passage is correct." << std::endl;
         }
         else
         {
           std::cout << "Incorrect word(s):" << std::endl;
           for (std::size_t i = 0; i < errors.size(); ++i)
           {
             std::cout << "    " << errors[i] << std::endl;
           }
         }
       }
     }
 
     // This automatically closes the tracker
     delete m_tracker;
   }
 
   /**
    * Implements ModuleActivator::Unload(). Does nothing since
    * the C++ Micro Services library will automatically unget any used services.
    * @param context the context for the module.
    */
   void Unload(ModuleContext* /*context*/)
   {
   }
 
 private:
 
   // Module context
   ModuleContext* m_context;
 
   // The service tracker
   ServiceTracker<ISpellCheckService>* m_tracker;
 };
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(Activator)
 //![Activator]
diff --git a/Modules/CppMicroServices/core/examples/spellcheckservice/Activator.cpp b/Modules/CppMicroServices/core/examples/spellcheckservice/Activator.cpp
index 3aba6c53d6..4b5baada5f 100644
--- a/Modules/CppMicroServices/core/examples/spellcheckservice/Activator.cpp
+++ b/Modules/CppMicroServices/core/examples/spellcheckservice/Activator.cpp
@@ -1,229 +1,229 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 //! [Activator]
 #include "IDictionaryService.h"
 #include "ISpellCheckService.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usServiceProperties.h>
 #include <usServiceTracker.h>
 #include <usServiceTrackerCustomizer.h>
 
 #include <map>
 #include <cstring>
 #include <memory>
 
 US_USE_NAMESPACE
 
 namespace {
 
 /**
  * This class implements a module that implements a spell
  * checker service. The spell checker service uses all available
  * dictionary services to check for the existence of words in
  * a given sentence. This module uses a ServiceTracker to
  * monitors the dynamic availability of dictionary services,
  * and to aggregate all available dictionary services as they
  * arrive and depart. The spell checker service is only registered
  * if there are dictionary services available, thus the spell
  * checker service will appear and disappear as dictionary
  * services appear and disappear, respectively.
 **/
 class US_ABI_LOCAL Activator : public ModuleActivator, public ServiceTrackerCustomizer<IDictionaryService>
 {
 
 private:
 
   /**
    * A private inner class that implements a spell check service; see
    * ISpellCheckService for details of the service.
    */
   class SpellCheckImpl : public ISpellCheckService
   {
 
   private:
 
     typedef std::map<ServiceReference<IDictionaryService>, IDictionaryService*> RefToServiceType;
     RefToServiceType m_refToSvcMap;
 
   public:
 
     /**
      * Implements ISpellCheckService::Check(). Checks the given passage for
      * misspelled words.
      *
      * @param passage the passage to spell check.
      * @return A list of misspelled words.
      */
     std::vector<std::string> Check(const std::string& passage)
     {
       std::vector<std::string> errorList;
 
       // No misspelled words for an empty string.
       if (passage.empty())
       {
         return errorList;
       }
 
       // Tokenize the passage using spaces and punctuation.
       const char* delimiters = " ,.!?;:";
       char* passageCopy = new char[passage.size()+1];
       std::memcpy(passageCopy, passage.c_str(), passage.size()+1);
       char* pch = std::strtok(passageCopy, delimiters);
 
       {
         // Lock the m_refToSvcMap member using your favorite thread library here...
         // MutexLocker lock(&m_refToSvcMapMutex)
 
         // Loop through each word in the passage.
         while (pch)
         {
           std::string word(pch);
 
           bool correct = false;
 
           // Check each available dictionary for the current word.
           for (RefToServiceType::const_iterator i = m_refToSvcMap.begin();
                (!correct) && (i != m_refToSvcMap.end()); ++i)
           {
             IDictionaryService* dictionary = i->second;
 
             if (dictionary->CheckWord(word))
             {
               correct = true;
             }
           }
 
           // If the word is not correct, then add it
           // to the incorrect word list.
           if (!correct)
           {
             errorList.push_back(word);
           }
 
           pch = std::strtok(nullptr, delimiters);
         }
       }
 
       delete[] passageCopy;
 
       return errorList;
     }
 
     std::size_t AddDictionary(const ServiceReference<IDictionaryService>& ref, IDictionaryService* dictionary)
     {
       // Lock the m_refToSvcMap member using your favorite thread library here...
       // MutexLocker lock(&m_refToSvcMapMutex)
 
       m_refToSvcMap.insert(std::make_pair(ref, dictionary));
 
       return m_refToSvcMap.size();
     }
 
     std::size_t RemoveDictionary(const ServiceReference<IDictionaryService>& ref)
     {
       // Lock the m_refToSvcMap member using your favorite thread library here...
       // MutexLocker lock(&m_refToSvcMapMutex)
 
       m_refToSvcMap.erase(ref);
 
       return m_refToSvcMap.size();
     }
   };
 
   virtual IDictionaryService* AddingService(const ServiceReference<IDictionaryService>& reference)
   {
     IDictionaryService* dictionary = m_context->GetService(reference);
     std::size_t count = m_spellCheckService->AddDictionary(reference, dictionary);
     if (!m_spellCheckReg && count > 1)
     {
       m_spellCheckReg = m_context->RegisterService<ISpellCheckService>(m_spellCheckService.get());
     }
     return dictionary;
   }
 
   virtual void ModifiedService(const ServiceReference<IDictionaryService>& /*reference*/,
                                IDictionaryService* /*service*/)
   {
     // do nothing
   }
 
   virtual void RemovedService(const ServiceReference<IDictionaryService>& reference,
                               IDictionaryService* /*service*/)
   {
     if (m_spellCheckService->RemoveDictionary(reference) < 2 && m_spellCheckReg)
     {
       m_spellCheckReg.Unregister();
       m_spellCheckReg = 0;
     }
   }
 
   std::unique_ptr<SpellCheckImpl> m_spellCheckService;
   ServiceRegistration<ISpellCheckService> m_spellCheckReg;
 
   ModuleContext* m_context;
   std::unique_ptr<ServiceTracker<IDictionaryService> > m_tracker;
 
 public:
 
   Activator()
     : m_context(nullptr)
   {}
 
   /**
    * Implements ModuleActivator::Load(). Registers an
    * instance of a dictionary service using the module context;
    * attaches properties to the service that can be queried
    * when performing a service look-up.
    *
    * @param context the context for the module.
    */
   void Load(ModuleContext* context)
   {
     m_context = context;
 
     m_spellCheckService.reset(new SpellCheckImpl);
     m_tracker.reset(new ServiceTracker<IDictionaryService>(context, this));
     m_tracker->Open();
   }
 
   /**
    * Implements ModuleActivator::Unload(). Does nothing since
    * the C++ Micro Services library will automatically unregister any registered services
    * and release any used services.
    *
    * @param context the context for the module.
    */
   void Unload(ModuleContext* /*context*/)
   {
     // NOTE: The service is automatically unregistered
 
     m_tracker->Close();
   }
 
 };
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(Activator)
 //![Activator]
diff --git a/Modules/CppMicroServices/core/examples/spellcheckservice/ISpellCheckService.cpp b/Modules/CppMicroServices/core/examples/spellcheckservice/ISpellCheckService.cpp
index 7041dd070b..5968877fda 100644
--- a/Modules/CppMicroServices/core/examples/spellcheckservice/ISpellCheckService.cpp
+++ b/Modules/CppMicroServices/core/examples/spellcheckservice/ISpellCheckService.cpp
@@ -1,25 +1,25 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "ISpellCheckService.h"
 
 ISpellCheckService::~ISpellCheckService()
 {}
diff --git a/Modules/CppMicroServices/core/examples/spellcheckservice/ISpellCheckService.h b/Modules/CppMicroServices/core/examples/spellcheckservice/ISpellCheckService.h
index 47e35399fe..d72b59fe8e 100644
--- a/Modules/CppMicroServices/core/examples/spellcheckservice/ISpellCheckService.h
+++ b/Modules/CppMicroServices/core/examples/spellcheckservice/ISpellCheckService.h
@@ -1,66 +1,66 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef ISPELLCHECKSERVICE_H
 #define ISPELLCHECKSERVICE_H
 
 //! [service]
 #include <usServiceInterface.h>
 
 #include <string>
 #include <vector>
 
 #ifdef US_BUILD_SHARED_LIBS
 #ifdef Example_spellcheckservice_EXPORTS
   #define SPELLCHECKSERVICE_EXPORT US_ABI_EXPORT
 #else
   #define SPELLCHECKSERVICE_EXPORT US_ABI_IMPORT
 #endif
 #else
   #define SPELLCHECKSERVICE_EXPORT US_ABI_EXPORT
 #endif
 
 /**
  * A simple service interface that defines a spell check service. A spell check
  * service checks the spelling of all words in a given passage. A passage is any
  * number of words separated by a space character and the following punctuation
  * marks: comma, period, exclamation mark, question mark, semi-colon, and colon.
  */
 struct SPELLCHECKSERVICE_EXPORT ISpellCheckService
 {
   // Out-of-line virtual desctructor for proper dynamic cast
   // support with older versions of gcc.
   virtual ~ISpellCheckService();
 
   /**
    * Checks a given passage for spelling errors. A passage is any number of
    * words separated by a space and any of the following punctuation marks:
    * comma (,), period (.), exclamation mark (!), question mark (?),
    * semi-colon (;), and colon(:).
    *
    * @param passage the passage to spell check.
    * @return A list of misspelled words.
    */
   virtual std::vector<std::string> Check(const std::string& passage) = 0;
 };
 //! [service]
 //!
 #endif // ISPELLCHECKSERVICE_H
diff --git a/Modules/CppMicroServices/core/include/usGetModuleContext.h b/Modules/CppMicroServices/core/include/usGetModuleContext.h
index 77b70cc7ba..e1d964c609 100644
--- a/Modules/CppMicroServices/core/include/usGetModuleContext.h
+++ b/Modules/CppMicroServices/core/include/usGetModuleContext.h
@@ -1,65 +1,65 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USGETMODULECONTEXT_H
 #define USGETMODULECONTEXT_H
 
 #ifndef US_MODULE_NAME
 #error Missing preprocessor define US_MODULE_NAME
 #endif
 
 #include <usGlobalConfig.h>
 #include <usModuleRegistry.h>
 #include <usModule.h>
 #include <usLog_p.h>
 #include <usModuleUtils_p.h>
 
 US_BEGIN_NAMESPACE
 
 class ModuleContext;
 
 /**
  * \ingroup MicroServices
  *
  * \brief Returns the module context of the calling module.
  *
  * This function allows easy access to the ModuleContext instance from
  * inside a C++ Micro Services module.
  *
  * \return The ModuleContext of the calling module.
  */
 static inline ModuleContext* GetModuleContext()
 {
   Module* module = ModuleRegistry::GetModule(US_STR(US_MODULE_NAME));
   if (module)
   {
     return module->GetModuleContext();
   }
   US_WARN << "Module '" << US_STR(US_MODULE_NAME) << "' unknown. "
              "The calling module probably misses a US_MODULE_NAME compile definition "
              "and/or a call to US_INITIALIZE_MODULE in one of its source files.";
   return nullptr;
 }
 
 US_END_NAMESPACE
 
 #endif // USGETMODULECONTEXT_H
diff --git a/Modules/CppMicroServices/core/include/usLDAPFilter.h b/Modules/CppMicroServices/core/include/usLDAPFilter.h
index e9ee922366..3340e04340 100644
--- a/Modules/CppMicroServices/core/include/usLDAPFilter.h
+++ b/Modules/CppMicroServices/core/include/usLDAPFilter.h
@@ -1,171 +1,171 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USLDAPFILTER_H
 #define USLDAPFILTER_H
 
 #include "usServiceProperties.h"
 
 #include "usSharedData.h"
 
 US_BEGIN_NAMESPACE
 
 class LDAPFilterData;
 class ServiceReferenceBase;
 
 /**
  * \ingroup MicroServices
  *
- * An <a href="http://www.ietf.org/rfc/rfc1960.txt">RFC 1960</a>-based Filter.
+ * An <a href="https://www.ietf.org/rfc/rfc1960.txt">RFC 1960</a>-based Filter.
  *
  * <p>
  * A <code>LDAPFilter</code> can be used numerous times to determine if the match
  * argument matches the filter string that was used to create the <code>LDAPFilter</code>.
  * <p>
  * Some examples of LDAP filters are:
  *
  *   - "(cn=Babs Jensen)"
  *   - "(!(cn=Tim Howes))"
  *   - "(&(" + ServiceConstants::OBJECTCLASS() + "=Person)(|(sn=Jensen)(cn=Babs J*)))"
  *   - "(o=univ*of*mich*)"
  *
  * \remarks This class is thread safe.
  *
  * \sa LDAPProp for a fluent API generating LDAP filter strings
  */
 class US_Core_EXPORT LDAPFilter {
 
 private:
 
   typedef SharedDataPointer<LDAPFilterData> LDAPFilter::*bool_type;
 
 public:
 
   /**
    * Creates in invalid <code>LDAPFilter</code> object.
    * Test the validity by using the boolean conversion operator.
    *
    * <p>
    * Calling methods on an invalid <code>LDAPFilter</code>
    * will result in undefined behavior.
    */
   LDAPFilter();
 
   /**
    * Creates a <code>LDAPFilter</code> object. This <code>LDAPFilter</code>
    * object may be used to match a <code>ServiceReference</code> object or a
    * <code>ServiceProperties</code> object.
    *
    * <p>
    * If the filter cannot be parsed, an std::invalid_argument will be
    * thrown with a human readable message where the filter became unparsable.
    *
    * @param filter The filter string.
    * @return A <code>LDAPFilter</code> object encapsulating the filter string.
    * @throws std::invalid_argument If <code>filter</code> contains an invalid
    *         filter string that cannot be parsed.
    * @see "Framework specification for a description of the filter string syntax." TODO!
    */
   LDAPFilter(const std::string& filter);
 
   LDAPFilter(const LDAPFilter& other);
 
   ~LDAPFilter();
 
   operator bool_type() const;
 
   /**
    * Filter using a service's properties.
    * <p>
    * This <code>LDAPFilter</code> is executed using the keys and values of the
    * referenced service's properties. The keys are looked up in a case
    * insensitive manner.
    *
    * @param reference The reference to the service whose properties are used
    *        in the match.
    * @return <code>true</code> if the service's properties match this
    *         <code>LDAPFilter</code> <code>false</code> otherwise.
    */
   bool Match(const ServiceReferenceBase& reference) const;
 
   /**
    * Filter using a <code>ServiceProperties</code> object with case insensitive key lookup. This
    * <code>LDAPFilter</code> is executed using the specified <code>ServiceProperties</code>'s keys
    * and values. The keys are looked up in a case insensitive manner.
    *
    * @param dictionary The <code>ServiceProperties</code> whose key/value pairs are used
    *        in the match.
    * @return <code>true</code> if the <code>ServiceProperties</code>'s values match this
    *         filter; <code>false</code> otherwise.
    */
   bool Match(const ServiceProperties& dictionary) const;
 
   /**
    * Filter using a <code>ServiceProperties</code>. This <code>LDAPFilter</code> is executed using
    * the specified <code>ServiceProperties</code>'s keys and values. The keys are looked
    * up in a normal manner respecting case.
    *
    * @param dictionary The <code>ServiceProperties</code> whose key/value pairs are used
    *        in the match.
    * @return <code>true</code> if the <code>ServiceProperties</code>'s values match this
    *         filter; <code>false</code> otherwise.
    */
   bool MatchCase(const ServiceProperties& dictionary) const;
 
   /**
    * Returns this <code>LDAPFilter</code>'s filter string.
    * <p>
    * The filter string is normalized by removing whitespace which does not
    * affect the meaning of the filter.
    *
    * @return This <code>LDAPFilter</code>'s filter string.
    */
   std::string ToString() const;
 
   /**
    * Compares this <code>LDAPFilter</code> to another <code>LDAPFilter</code>.
    *
    * <p>
    * This implementation returns the result of calling
    * <code>this->ToString() == other.ToString()</code>.
    *
    * @param other The object to compare against this <code>LDAPFilter</code>.
    * @return Returns the result of calling
    *         <code>this->ToString() == other.ToString()</code>.
    */
   bool operator==(const LDAPFilter& other) const;
 
   LDAPFilter& operator=(const LDAPFilter& filter);
 
 protected:
 
   SharedDataPointer<LDAPFilterData> d;
 
 };
 
 US_END_NAMESPACE
 
 /**
  * \ingroup MicroServices
  */
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, const US_PREPEND_NAMESPACE(LDAPFilter)& filter);
 
 #endif // USLDAPFILTER_H
diff --git a/Modules/CppMicroServices/core/include/usLDAPProp.h b/Modules/CppMicroServices/core/include/usLDAPProp.h
index e0a03ababd..4376518b6d 100644
--- a/Modules/CppMicroServices/core/include/usLDAPProp.h
+++ b/Modules/CppMicroServices/core/include/usLDAPProp.h
@@ -1,226 +1,226 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USLDAPPROP_H
 #define USLDAPPROP_H
 
 #include <usCoreConfig.h>
 #include <usAny.h>
 
 US_BEGIN_NAMESPACE
 
 /// \cond
 class US_Core_EXPORT LDAPPropExpr
 {
 public:
 
   explicit LDAPPropExpr(const std::string& expr);
 
   LDAPPropExpr& operator!();
 
   operator std::string() const;
 
   bool IsNull() const;
 
 private:
 
   LDAPPropExpr& operator=(const LDAPPropExpr&);
 
   std::string m_ldapExpr;
 };
 /// \endcond
 
 /**
  * \ingroup MicroServicesUtils
  *
  * A fluent API for creating LDAP filter strings.
  *
  * Examples for creating LDAPFilter objects:
  * \code
  * // This creates the filter "(&(name=Ben)(!(count=1)))"
  * LDAPFilter filter(LDAPProp("name") == "Ben" && !(LDAPProp("count") == 1));
  *
  * // This creates the filter "(|(presence=*)(!(absence=*)))"
  * LDAPFilter filter(LDAPProp("presence") || !LDAPProp("absence"));
  *
  * // This creates the filter "(&(ge>=-3)(approx~=hi))"
  * LDAPFilter filter(LDAPProp("ge") >= -3 && LDAPProp("approx").Approx("hi"));
  * \endcode
  *
  * \sa LDAPFilter
  */
 class US_Core_EXPORT LDAPProp
 {
 public:
 
   /**
    * Create a LDAPProp instance for the named LDAP property.
    *
    * @param property The name of the LDAP property.
    */
   LDAPProp(const std::string& property);
 
   /**
    * LDAP equality '='
    *
    * @param s A type convertible to std::string.
    * @return A LDAP expression object.
    *
    * @{
    */
   LDAPPropExpr operator==(const std::string& s) const;
   LDAPPropExpr operator==(const us::Any& s) const;
   template<class T>
   LDAPPropExpr operator==(const T& s) const
   {
     std::stringstream ss;
     ss << s;
     return LDAPPropExpr("(" + m_property + "=" + ss.str() + ")");
   }
   /// @}
 
   operator LDAPPropExpr () const;
 
   /**
    * States the absence of the LDAP property.
    *
    * @return A LDAP expression object.
    */
   LDAPPropExpr operator!() const;
 
   /**
    * Convenience operator for LDAP inequality.
    *
    * Writing either
    * \code
    * LDAPProp("attr") != "val"
    * \endcode
    * or
    * \code
    * !(LDAPProp("attr") == "val")
    * \endcode
    * leads to the same string "(!(attr=val))".
    *
    * @param s A type convertible to std::string.
    * @return A LDAP expression object.
    *
    * @{
    */
   LDAPPropExpr operator!=(const std::string& s) const;
   LDAPPropExpr operator!=(const us::Any& s) const;
   template<class T>
   LDAPPropExpr operator!=(const T& s) const
   {
     std::stringstream ss;
     ss << s;
     return operator!=(ss.str());
   }
   /// @}
 
   /**
    * LDAP greater or equal '>='
    *
    * @param s A type convertible to std::string.
    * @return A LDAP expression object.
    *
    * @{
    */
   LDAPPropExpr operator>=(const std::string& s) const;
   LDAPPropExpr operator>=(const us::Any& s) const;
   template<class T>
   LDAPPropExpr operator>=(const T& s) const
   {
     std::stringstream ss;
     ss << s;
     return operator>=(ss.str());
   }
   /// @}
 
   /**
    * LDAP less or equal '<='
    *
    * @param s A type convertible to std::string.
    * @return A LDAP expression object.
    *
    * @{
    */
   LDAPPropExpr operator<=(const std::string& s) const;
   LDAPPropExpr operator<=(const us::Any& s) const;
   template<class T>
   LDAPPropExpr operator<=(const T& s) const
   {
     std::stringstream ss;
     ss << s;
     return operator<=(ss.str());
   }
   /// @}
 
   /**
    * LDAP approximation '~='
    *
    * @param s A type convertible to std::string.
    * @return A LDAP expression object.
    *
    * @{
    */
   LDAPPropExpr Approx(const std::string& s) const;
   LDAPPropExpr Approx(const us::Any& s) const;
   template<class T>
   LDAPPropExpr Approx(const T& s) const
   {
     std::stringstream ss;
     ss << s;
     return Approx(ss.str());
   }
   /// @}
 
 private:
 
   LDAPProp& operator=(const LDAPProp&);
 
   std::string m_property;
 };
 
 US_END_NAMESPACE
 
 /**
  * \ingroup MicroServicesUtils
  *
  * LDAP logical and '&'
  *
  * @param left A LDAP expression.
  * @param right A LDAP expression.
  * @return A LDAP expression
  */
 US_Core_EXPORT us::LDAPPropExpr operator&&(const us::LDAPPropExpr& left, const us::LDAPPropExpr& right);
 
 /**
  * \ingroup MicroServicesUtils
  *
  * LDAP logical or '|'
  *
  * @param left A LDAP expression.
  * @param right A LDAP expression.
  * @return A LDAP expression
  */
 US_Core_EXPORT us::LDAPPropExpr operator||(const us::LDAPPropExpr& left, const us::LDAPPropExpr& right);
 
 #endif // USLDAPPROP_H
diff --git a/Modules/CppMicroServices/core/include/usModule.h b/Modules/CppMicroServices/core/include/usModule.h
index 489f98eb24..163f574ccc 100644
--- a/Modules/CppMicroServices/core/include/usModule.h
+++ b/Modules/CppMicroServices/core/include/usModule.h
@@ -1,367 +1,367 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USMODULE_H
 #define USMODULE_H
 
 #include "usModuleVersion.h"
 
 #include <vector>
 
 US_BEGIN_NAMESPACE
 
 class Any;
 class CoreModuleContext;
 struct ModuleInfo;
 class ModuleContext;
 class ModuleResource;
 class ModulePrivate;
 
 template<class S>
 class ServiceReference;
 
 typedef ServiceReference<void> ServiceReferenceU;
 
 /**
  * \ingroup MicroServices
  *
  * Represents a CppMicroServices module.
  *
  * <p>
  * A <code>%Module</code> object is the access point to a CppMicroServices module.
  * Each CppMicroServices module has an associated <code>%Module</code> object.
  *
  * <p>
  * A module has unique identity, a <code>long</code>, chosen by the
  * framework. This identity does not change during the lifecycle of a module.
  *
  * <p>
  * A module can be in one of two states:
  * <ul>
  * <li>LOADED
  * <li>UNLOADED
  * </ul>
  * <p>
  * You can determine the current state by using IsLoaded().
  *
  * <p>
  * A module can only execute code when its state is <code>LOADED</code>.
  * An <code>UNLOADED</code> module is a
  * zombie and can only be reached because it was loaded before. However,
  * unloaded modules can be loaded again.
  *
  * <p>
  * The framework is the only entity that is allowed to create
  * <code>%Module</code> objects.
  *
  * @remarks This class is thread safe.
  */
 class US_Core_EXPORT Module
 {
 
 public:
 
   /**
    * Returns the property key for looking up this module's id.
    * The property value is of type \c long.
    *
    * @return The id property key.
    */
   static const std::string& PROP_ID();
 
   /**
    * Returns the property key for looking up this module's name.
    * The property value is of type \c std::string.
    *
    * @return The name property key.
    */
   static const std::string& PROP_NAME();
 
   /**
    * Returns the property key for looking up this module's
    * location in the file system.
    * The property value is of type \c std::string.
    *
    * @return The location property key.
    */
   static const std::string& PROP_LOCATION();
 
   /**
    * Returns the property key with a value of \c module.version for looking
    * up this module's version identifier.
    * The property value is of type \c std::string.
    *
    * @return The version property key.
    */
   static const std::string& PROP_VERSION();
 
   /**
    * Returns the property key with a value of \c module.vendor for looking
    * up this module's vendor information.
    * The property value is of type \c std::string.
    *
    * @return The vendor property key.
    */
   static const std::string& PROP_VENDOR();
 
   /**
    * Returns the property key with a value of \c module.description for looking
    * up this module's description.
    * The property value is of type \c std::string.
    *
    * @return The description property key.
    */
   static const std::string& PROP_DESCRIPTION();
 
   /**
    * Returns the property key with a value of \c module.autoload_dir for looking
    * up this module's auto-load directory.
    * The property value is of type \c std::string.
    *
    * @return The auto-load directory property key.
    */
   static const std::string& PROP_AUTOLOAD_DIR();
 
   /**
    * Returns the property key with a value of \c module.autoloaded_modules for
    * looking up this module's auto-load modules.
    * The property value is of type \c std::vector<std::string> and contains
    * the file system locations for the auto-loaded modules triggered by this
    * module.
    *
    * @return The auto-loaded modules property key.
    */
   static const std::string& PROP_AUTOLOADED_MODULES();
 
   ~Module();
 
   /**
    * Returns this module's current state.
    *
    * <p>
    * A module can be in only one state at any time.
    *
    * @return <code>true</code> if the module is <code>LOADED</code>
    *         <code>false</code> if it is <code>UNLOADED</code>
    */
   bool IsLoaded() const;
 
   /**
    * Returns this module's {@link ModuleContext}. The returned
    * <code>ModuleContext</code> can be used by the caller to act on behalf
    * of this module.
    *
    * <p>
    * If this module is not in the <code>LOADED</code> state, then this
    * module has no valid <code>ModuleContext</code>. This method will
    * return <code>0</code> if this module has no valid
    * <code>ModuleContext</code>.
    *
    * @return A <code>ModuleContext</code> for this module or
    *         <code>0</code> if this module has no valid
    *         <code>ModuleContext</code>.
    */
   ModuleContext* GetModuleContext() const;
 
   /**
    * Returns this module's unique identifier. This module is assigned a unique
    * identifier by the framework when it was loaded.
    *
    * <p>
    * A module's unique identifier has the following attributes:
    * <ul>
    * <li>Is unique.
    * <li>Is a <code>long</code>.
    * <li>Its value is not reused for another module, even after a module is
    * unloaded.
    * <li>Does not change while a module remains loaded.
    * <li>Does not change when a module is reloaded.
    * </ul>
    *
    * <p>
    * This method continues to return this module's unique identifier while
    * this module is in the <code>UNLOADED</code> state.
    *
    * @return The unique identifier of this module.
    */
   long GetModuleId() const;
 
   /**
    * Returns this module's location.
    *
    * <p>
    * The location is the full path to the module's shared library.
    * This method continues to return this module's location
    * while this module is in the <code>UNLOADED</code> state.
    *
    * @return The string representation of this module's location.
    */
   std::string GetLocation() const;
 
   /**
    * Returns the name of this module as specified by the
    * US_CREATE_MODULE CMake macro. The module
    * name together with a version must identify a unique module.
    *
    * <p>
    * This method continues to return this module's name while
    * this module is in the <code>UNLOADED</code> state.
    *
    * @return The name of this module.
    */
   std::string GetName() const;
 
   /**
    * Returns the version of this module as specified by the
    * US_INITIALIZE_MODULE CMake macro. If this module does not have a
    * specified version then {@link ModuleVersion::EmptyVersion} is returned.
    *
    * <p>
    * This method continues to return this module's version while
    * this module is in the <code>UNLOADED</code> state.
    *
    * @return The version of this module.
    */
   ModuleVersion GetVersion() const;
 
   /**
    * Returns the value of the specified property for this module. The
    * method returns an empty Any if the property is not found.
    *
    * @param key The name of the requested property.
    * @return The value of the requested property, or an empty string
    *         if the property is undefined.
    *
    * @sa GetPropertyKeys()
    * @sa \ref MicroServices_ModuleProperties
    */
   Any GetProperty(const std::string& key) const;
 
   /**
    * Returns a list of top-level property keys for this module.
    *
    * @return A list of available property keys.
    *
    * @sa \ref MicroServices_ModuleProperties
    */
   std::vector<std::string> GetPropertyKeys() const;
 
   /**
    * Returns this module's ServiceReference list for all services it
    * has registered or an empty list if this module has no registered
    * services.
    *
    * The list is valid at the time of the call to this method, however,
    * as the framework is a very dynamic environment, services can be
    * modified or unregistered at anytime.
    *
    * @return A list of ServiceReference objects for services this
    * module has registered.
    */
   std::vector<ServiceReferenceU> GetRegisteredServices() const;
 
   /**
    * Returns this module's ServiceReference list for all services it is
    * using or returns an empty list if this module is not using any
    * services. A module is considered to be using a service if its use
    * count for that service is greater than zero.
    *
    * The list is valid at the time of the call to this method, however,
    * as the framework is a very dynamic environment, services can be
    * modified or unregistered at anytime.
    *
    * @return A list of ServiceReference objects for all services this
    * module is using.
    */
   std::vector<ServiceReferenceU> GetServicesInUse() const;
 
   /**
    * Returns the resource at the specified \c path in this module.
    * The specified \c path is always relative to the root of this module and may
    * begin with '/'. A path value of "/" indicates the root of this module.
    *
    * @param path The path name of the resource.
    * @return A ModuleResource object for the given \c path. If the \c path cannot
    * be found in this module or the module's state is \c UNLOADED, an invalid
    * ModuleResource object is returned.
    */
   ModuleResource GetResource(const std::string& path) const;
 
   /**
    * Returns resources in this module.
    *
    * This method is intended to be used to obtain configuration, setup, localization
    * and other information from this module.
    *
    * This method can either return only resources in the specified \c path or recurse
    * into subdirectories returning resources in the directory tree beginning at the
    * specified path.
    *
    * Examples:
    * \snippet uServices-resources/main.cpp 0
    *
    * @param path The path name in which to look. The path is always relative to the root
    * of this module and may begin with '/'. A path value of "/" indicates the root of this module.
    * @param filePattern The resource name pattern for selecting entries in the specified path.
    * The pattern is only matched against the last element of the resource path. Substring
    * matching is supported using the wildcard charachter ('*'). If \c filePattern is empty,
    * this is equivalent to "*" and matches all resources.
    * @param recurse If \c true, recurse into subdirectories. Otherwise only return resources
    * from the specified path.
    * @return A vector of ModuleResource objects for each matching entry.
    */
   std::vector<ModuleResource> FindResources(const std::string& path, const std::string& filePattern, bool recurse) const;
 
 private:
 
   friend class CoreModuleActivator;
   friend class ModuleRegistry;
   friend class ServiceReferencePrivate;
 
   ModulePrivate* d;
 
   Module();
 
   void Init(CoreModuleContext* coreCtx, ModuleInfo* info);
   void Uninit();
 
   void Start();
   void Stop();
 
   // purposely not implemented
   Module(const Module &);
   Module& operator=(const Module&);
 
 };
 
 US_END_NAMESPACE
 
 /**
  * \ingroup MicroServices
  */
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, const US_PREPEND_NAMESPACE(Module)& module);
 /**
  * \ingroup MicroServices
  */
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, US_PREPEND_NAMESPACE(Module) const * module);
 
 #endif // USMODULE_H
diff --git a/Modules/CppMicroServices/core/include/usModuleActivator.h b/Modules/CppMicroServices/core/include/usModuleActivator.h
index 6231f065ff..9ed4ccc241 100644
--- a/Modules/CppMicroServices/core/include/usModuleActivator.h
+++ b/Modules/CppMicroServices/core/include/usModuleActivator.h
@@ -1,134 +1,134 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEACTIVATOR_H_
 #define USMODULEACTIVATOR_H_
 
 #ifndef US_MODULE_NAME
 #error Missing US_MODULE_NAME preprocessor define
 #endif
 
 #include <usGlobalConfig.h>
 #include <usModuleUtils_p.h>
 
 US_BEGIN_NAMESPACE
 
 class ModuleContext;
 
 /**
  * \ingroup MicroServices
  *
  * Customizes the starting and stopping of a CppMicroServices module.
  * <p>
  * <code>%ModuleActivator</code> is an interface that can be implemented by
  * CppMicroServices modules. The CppMicroServices library can create instances of a
  * module's <code>%ModuleActivator</code> as required. If an instance's
  * <code>ModuleActivator::Load</code> method executes successfully, it is
  * guaranteed that the same instance's <code>%ModuleActivator::Unload</code>
  * method will be called when the module is to be unloaded. The CppMicroServices
  * library does not concurrently call a <code>%ModuleActivator</code> object.
  *
  * <p>
  * <code>%ModuleActivator</code> is an abstract class interface whose implementations
  * must be exported via a special macro. Implementations are usually declared
  * and defined directly in .cpp files.
  *
  * <p>
  * \snippet uServices-activator/main.cpp 0
  *
  * <p>
  * The class implementing the <code>%ModuleActivator</code> interface must have a public
  * default constructor so that a <code>%ModuleActivator</code>
  * object can be created by the CppMicroServices library.
  *
  */
 struct ModuleActivator
 {
 
   virtual ~ModuleActivator() {}
 
   /**
    * Called when this module is loaded. This method
    * can be used to register services or to allocate any resources that this
    * module may need globally (during the whole module lifetime).
    *
    * <p>
    * This method must complete and return to its caller in a timely manner.
    *
    * @param context The execution context of the module being loaded.
    * @throws std::exception If this method throws an exception, this
    *         module is marked as stopped and the framework will remove this
    *         module's listeners, unregister all services registered by this
    *         module, and release all services used by this module.
    */
   virtual void Load(ModuleContext* context) = 0;
 
   /**
    * Called when this module is unloaded. In general, this
    * method should undo the work that the <code>ModuleActivator::Load</code>
    * method started. There should be no active threads that were started by
    * this module when this method returns.
    *
    * <p>
    * This method must complete and return to its caller in a timely manner.
    *
    * @param context The execution context of the module being unloaded.
    * @throws std::exception If this method throws an exception, the
    *         module is still marked as unloaded, and the framework will remove
    *         the module's listeners, unregister all services registered by the
    *         module, and release all services used by the module.
    */
   virtual void Unload(ModuleContext* context) = 0;
 
 };
 
 US_END_NAMESPACE
 
 
 /**
  * \ingroup MicroServices
  *
  * \brief Export a module activator class.
  *
  * \param _activator_type The fully-qualified type-name of the module activator class.
  *
  * Call this macro after the definition of your module activator to make it
  * accessible by the CppMicroServices library.
  *
  * Example:
  * \snippet uServices-activator/main.cpp 0
  */
 #define US_EXPORT_MODULE_ACTIVATOR(_activator_type)                                       \
   extern "C" US_ABI_EXPORT US_PREPEND_NAMESPACE(ModuleActivator)* US_CONCAT(_us_module_activator_instance_, US_MODULE_NAME) () \
   {                                                                                       \
     struct ScopedPointer                                                                  \
     {                                                                                     \
       ScopedPointer(US_PREPEND_NAMESPACE(ModuleActivator)* activator = 0) : m_Activator(activator) {} \
       ~ScopedPointer() { delete m_Activator; }                                            \
       US_PREPEND_NAMESPACE(ModuleActivator)* m_Activator;                                 \
     };                                                                                    \
                                                                                           \
     static ScopedPointer activatorPtr;                                                    \
     if (activatorPtr.m_Activator == 0) activatorPtr.m_Activator = new _activator_type;    \
     return activatorPtr.m_Activator;                                                      \
   }
 
 #endif /* USMODULEACTIVATOR_H_ */
diff --git a/Modules/CppMicroServices/core/include/usModuleContext.h b/Modules/CppMicroServices/core/include/usModuleContext.h
index 358cbe4d8b..bfee00510d 100644
--- a/Modules/CppMicroServices/core/include/usModuleContext.h
+++ b/Modules/CppMicroServices/core/include/usModuleContext.h
@@ -1,851 +1,851 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULECONTEXT_H_
 #define USMODULECONTEXT_H_
 
 // TODO: Replace includes with forward directives!
 
 #include "usListenerFunctors_p.h"
 #include "usServiceInterface.h"
 #include "usServiceEvent.h"
 #include "usServiceRegistration.h"
 #include "usServiceException.h"
 #include "usModuleEvent.h"
 
 US_BEGIN_NAMESPACE
 
 typedef US_SERVICE_LISTENER_FUNCTOR ServiceListener;
 typedef US_MODULE_LISTENER_FUNCTOR ModuleListener;
 
 class ModuleContextPrivate;
 class ServiceFactory;
 
 template<class S> class ServiceObjects;
 
 /**
  * \ingroup MicroServices
  *
  * A module's execution context within the framework. The context is used to
  * grant access to other methods so that this module can interact with the
  * Micro Services Framework.
  *
  * <p>
  * <code>ModuleContext</code> methods allow a module to:
  * <ul>
  * <li>Subscribe to events published by the framework.
  * <li>Register service objects with the framework service registry.
  * <li>Retrieve <code>ServiceReference</code>s from the framework service
  * registry.
  * <li>Get and release service objects for a referenced service.
  * <li>Get the list of modules loaded in the framework.
  * <li>Get the {@link Module} object for a module.
  * </ul>
  *
  * <p>
  * A <code>ModuleContext</code> object will be created and provided to the
  * module associated with this context when it is loaded using the
  * us::ModuleActivator::Load method. The same <code>ModuleContext</code>
  * object will be passed to the module associated with this context when it is
  * unloaded using the us::ModuleActivator::Unload method. A
  * <code>ModuleContext</code> object is generally for the private use of its
  * associated module and is not meant to be shared with other modules in the
  * module environment.
  *
  * <p>
  * The <code>Module</code> object associated with a <code>ModuleContext</code>
  * object is called the <em>context module</em>.
  *
  * <p>
  * The <code>ModuleContext</code> object is only valid during the execution of
  * its context module; that is, during the period when the context module
  * is loaded. If the <code>ModuleContext</code>
  * object is used subsequently, a <code>std::logic_error</code> is
  * thrown. The <code>ModuleContext</code> object is never reused after
  * its context module is unloaded.
  *
  * <p>
  * The framework is the only entity that can create <code>ModuleContext</code>
  * objects.
  *
  * @remarks This class is thread safe.
  */
 class US_Core_EXPORT ModuleContext
 {
 
 public:
 
   ~ModuleContext();
 
   /**
    * Returns the <code>Module</code> object associated with this
    * <code>ModuleContext</code>. This module is called the context module.
    *
    * @return The <code>Module</code> object associated with this
    *         <code>ModuleContext</code>.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    */
   Module* GetModule() const;
 
   /**
    * Returns the module with the specified identifier.
    *
    * @param id The identifier of the module to retrieve.
    * @return A <code>Module</code> object or <code>0</code> if the
    *         identifier does not match any previously loaded module.
    */
   Module* GetModule(long id) const;
 
   /**
    * Get the module that with the specified module name.
    *
    * @param name The name of the module to get.
    * @return The requested \c Module or \c nullptr.
    */
   Module* GetModule(const std::string& name);
 
   /**
    * Returns a list of all known modules.
    * <p>
    * This method returns a list of all modules loaded in the module
    * environment at the time of the call to this method. This list will
    * also contain modules which might already have been unloaded.
    *
    * @return A std::vector of <code>Module</code> objects which
    *         will hold one object per known module.
    */
   std::vector<Module*> GetModules() const;
 
   /**
    * Registers the specified service object with the specified properties
    * under the specified class names into the framework. A
    * <code>ServiceRegistration</code> object is returned. The
    * <code>ServiceRegistration</code> object is for the private use of the
    * module registering the service and should not be shared with other
    * modules. The registering module is defined to be the context module.
    * Other modules can locate the service by using either the
    * GetServiceReferences() or GetServiceReference() method.
    *
    * <p>
    * A module can register a service object that implements the
    * ServiceFactory or PrototypeServiceFactory interface to have more
    * flexibility in providing service objects to other modules.
    *
    * <p>
    * The following steps are taken when registering a service:
    * <ol>
    * <li>The framework adds the following service properties to the service
    * properties from the specified <code>ServiceProperties</code> (which may be
    * omitted): <br/>
    * A property named us::ServiceConstants::SERVICE_ID() identifying the
    * registration number of the service <br/>
    * A property named us::ServiceConstants::OBJECTCLASS() containing all the
    * specified classes. <br/>
    * A property named us::ServiceConstants::SERVICE_SCOPE() identifying the scope
    * of the service. <br/>
    * Properties with these names in the specified <code>ServiceProperties</code> will
    * be ignored.
    * <li>The service is added to the framework service registry and may now be
    * used by other modules.
    * <li>A service event of type ServiceEvent#REGISTERED is fired.
    * <li>A <code>ServiceRegistration</code> object for this registration is
    * returned.
    * </ol>
    *
    * @note This is a low-level method and should normally not be used directly.
    *       Use one of the templated RegisterService methods instead.
    *
    * @param service The service object, which is a map of interface identifiers
    *        to raw service pointers.
    * @param properties The properties for this service. The keys in the
    *        properties object must all be <code>std::string</code> objects. See
    *        us::ServiceConstants for a list of standard service property keys.
    *        Changes should not be made to this object after calling this
    *        method. To update the service's properties the
    *        us::ServiceRegistration::SetProperties method must be called.
    *        The set of properties may be omitted if the service has
    *        no properties.
    * @return A <code>ServiceRegistration</code> object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    *
    * @throws std::invalid_argument If one of the following is true:
    *         <ul>
    *         <li><code>service</code> is <code>0</code>.
    *         <li><code>properties</code> contains case variants of the same key name.
    *         </ul>
    * @throws std::logic_error If this ModuleContext is no longer valid.
    *
    * @see ServiceRegistration
    * @see ServiceFactory
    * @see PrototypeServiceFactory
    */
   ServiceRegistrationU RegisterService(const InterfaceMap& service,
                                        const ServiceProperties& properties = ServiceProperties());
 
   /**
    * Registers the specified service object with the specified properties
    * using the specified template argument with the framework.
    *
    * <p>
    * This method is provided as a convenience when <code>service</code> will only be registered under
    * a single class name whose type is available to the caller. It is otherwise identical to
    * RegisterService(const InterfaceMap&, const ServiceProperties&) but should be preferred
    * since it avoids errors in the string literal identifying the class name or interface identifier.
    *
    * Example usage:
    * \snippet uServices-registration/main.cpp 1-1
    * \snippet uServices-registration/main.cpp 1-2
    *
    * @tparam S The type under which the service can be located.
    * @param service The service object or a ServiceFactory object.
    * @param properties The properties for this service.
    * @return A ServiceRegistration object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException If the service type \c S is invalid or the
    *         \c service object is nullptr.
    *
    * @see RegisterService(const InterfaceMap&, const ServiceProperties&)
    */
   template<class S>
   ServiceRegistration<S> RegisterService(S* service, const ServiceProperties& properties = ServiceProperties())
   {
     InterfaceMap servicePointers = MakeInterfaceMap<S>(service);
     return RegisterService(servicePointers, properties);
   }
 
   /**
    * Registers the specified service object with the specified properties
    * using the specified template argument with the framework.
    *
    * <p>
    * This method is provided as a convenience when registering a service under
    * two interface classes whose type is available to the caller. It is otherwise identical to
    * RegisterService(const InterfaceMap&, const ServiceProperties&) but should be preferred
    * since it avoids errors in the string literal identifying the class name or interface identifier.
    *
    * Example usage:
    * \snippet uServices-registration/main.cpp 2-1
    * \snippet uServices-registration/main.cpp 2-2
    *
    * @tparam I1 The first interface type under which the service can be located.
    * @tparam I2 The second interface type under which the service can be located.
    * @param impl The service object or a ServiceFactory object.
    * @param properties The properties for this service.
    * @return A ServiceRegistration object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException If the service type \c S is invalid or the
    *         \c service object is nullptr.
    *
    * @see RegisterService(const InterfaceMap&, const ServiceProperties&)
    */
   template<class I1, class I2, class Impl>
   ServiceRegistration<I1,I2> RegisterService(Impl* impl, const ServiceProperties& properties = ServiceProperties())
   {
     InterfaceMap servicePointers = MakeInterfaceMap<I1, I2>(impl);
     return RegisterService(servicePointers, properties);
   }
 
   /**
    * Registers the specified service object with the specified properties
    * using the specified template argument with the framework.
    *
    * <p>
    * This method is identical to the RegisterService<I1,I2,Impl>(Impl*, const ServiceProperties&)
    * method except that it supports three service interface types.
    *
    * @tparam I1 The first interface type under which the service can be located.
    * @tparam I2 The second interface type under which the service can be located.
    * @tparam I3 The third interface type under which the service can be located.
    * @param impl The service object or a ServiceFactory object.
    * @param properties The properties for this service.
    * @return A ServiceRegistration object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException If the service type \c S is invalid or the
    *         \c service object is nullptr.
    *
    * @see RegisterService(const InterfaceMap&, const ServiceProperties&)
    */
   template<class I1, class I2, class I3, class Impl>
   ServiceRegistration<I1,I2,I3> RegisterService(Impl* impl, const ServiceProperties& properties = ServiceProperties())
   {
     InterfaceMap servicePointers = MakeInterfaceMap<I1, I2, I3>(impl);
     return RegisterService(servicePointers, properties);
   }
 
   /**
    * Registers the specified service factory as a service with the specified properties
    * using the specified template argument as service interface type with the framework.
    *
    * <p>
    * This method is provided as a convenience when <code>factory</code> will only be registered under
    * a single class name whose type is available to the caller. It is otherwise identical to
    * RegisterService(const InterfaceMap&, const ServiceProperties&) but should be preferred
    * since it avoids errors in the string literal identifying the class name or interface identifier.
    *
    * Example usage:
    * \snippet uServices-registration/main.cpp 1-1
    * \snippet uServices-registration/main.cpp f1
    *
    * @tparam S The type under which the service can be located.
    * @param factory The ServiceFactory or PrototypeServiceFactory object.
    * @param properties The properties for this service.
    * @return A ServiceRegistration object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException If the service type \c S is invalid or the
    *         \c service factory object is nullptr.
    *
    * @see RegisterService(const InterfaceMap&, const ServiceProperties&)
    */
   template<class S>
   ServiceRegistration<S> RegisterService(ServiceFactory* factory, const ServiceProperties& properties = ServiceProperties())
   {
     InterfaceMap servicePointers = MakeInterfaceMap<S>(factory);
     return RegisterService(servicePointers, properties);
   }
 
   /**
    * Registers the specified service factory as a service with the specified properties
    * using the specified template argument as service interface type with the framework.
    *
    * <p>
    * This method is identical to the RegisterService<S>(ServiceFactory*, const ServiceProperties&)
    * method except that it supports two service interface types.
    *
    * Example usage:
    * \snippet uServices-registration/main.cpp 2-1
    * \snippet uServices-registration/main.cpp f2
    *
    * @tparam I1 The first interface type under which the service can be located.
    * @tparam I2 The second interface type under which the service can be located.
    * @param factory The ServiceFactory or PrototypeServiceFactory object.
    * @param properties The properties for this service.
    * @return A ServiceRegistration object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException If the service type \c S is invalid or the
    *         \c service factory object is nullptr.
    *
    * @see RegisterService(const InterfaceMap&, const ServiceProperties&)
    */
   template<class I1, class I2>
   ServiceRegistration<I1,I2> RegisterService(ServiceFactory* factory, const ServiceProperties& properties = ServiceProperties())
   {
     InterfaceMap servicePointers = MakeInterfaceMap<I1,I2>(factory);
     return RegisterService(servicePointers, properties);
   }
 
   /**
    * Registers the specified service factory as a service with the specified properties
    * using the specified template argument as service interface type with the framework.
    *
    * <p>
    * This method is identical to the RegisterService<S>(ServiceFactory*, const ServiceProperties&)
    * method except that it supports three service interface types.
    *
    * @tparam I1 The first interface type under which the service can be located.
    * @tparam I2 The second interface type under which the service can be located.
    * @tparam I3 The third interface type under which the service can be located.
    * @param factory The ServiceFactory or PrototypeServiceFactory object.
    * @param properties The properties for this service.
    * @return A ServiceRegistration object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException If the service type \c S is invalid or the
    *         \c service factory object is nullptr.
    *
    * @see RegisterService(const InterfaceMap&, const ServiceProperties&)
    */
   template<class I1, class I2, class I3>
   ServiceRegistration<I1,I2,I3> RegisterService(ServiceFactory* factory, const ServiceProperties& properties = ServiceProperties())
   {
     InterfaceMap servicePointers = MakeInterfaceMap<I1,I2,I3>(factory);
     return RegisterService(servicePointers, properties);
   }
 
   /**
    * Returns a list of <code>ServiceReference</code> objects. The returned
    * list contains services that
    * were registered under the specified class and match the specified filter
    * expression.
    *
    * <p>
    * The list is valid at the time of the call to this method. However since
    * the Micro Services framework is a very dynamic environment, services can be modified or
    * unregistered at any time.
    *
    * <p>
    * The specified <code>filter</code> expression is used to select the
    * registered services whose service properties contain keys and values
    * which satisfy the filter expression. See LDAPFilter for a description
    * of the filter syntax. If the specified <code>filter</code> is
    * empty, all registered services are considered to match the
    * filter. If the specified <code>filter</code> expression cannot be parsed,
    * an <code>std::invalid_argument</code> will be thrown with a human readable
    * message where the filter became unparsable.
    *
    * <p>
    * The result is a list of <code>ServiceReference</code> objects for all
    * services that meet all of the following conditions:
    * <ul>
    * <li>If the specified class name, <code>clazz</code>, is not
    * empty, the service must have been registered with the
    * specified class name. The complete list of class names with which a
    * service was registered is available from the service's
    * us::ServiceConstants::OBJECTCLASS() property.
    * <li>If the specified <code>filter</code> is not empty, the
    * filter expression must match the service.
    * </ul>
    *
    * @param clazz The class name with which the service was registered or
    *        an empty string for all services.
    * @param filter The filter expression or empty for all
    *        services.
    * @return A list of <code>ServiceReference</code> objects or
    *         an empty list if no services are registered which satisfy the
    *         search.
    * @throws std::invalid_argument If the specified <code>filter</code>
    *         contains an invalid filter expression that cannot be parsed.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    */
   std::vector<ServiceReferenceU> GetServiceReferences(const std::string& clazz, const std::string& filter = std::string());
 
   /**
    * Returns a list of <code>ServiceReference</code> objects. The returned
    * list contains services that
    * were registered under the interface id of the template argument <code>S</code>
    * and match the specified filter expression.
    *
    * <p>
    * This method is identical to GetServiceReferences(const std::string&, const std::string&) except that
    * the class name for the service object is automatically deduced from the template argument.
    *
    * @tparam S The type under which the requested service objects must have been registered.
    * @param filter The filter expression or empty for all
    *        services.
    * @return A list of <code>ServiceReference</code> objects or
    *         an empty list if no services are registered which satisfy the
    *         search.
    * @throws std::invalid_argument If the specified <code>filter</code>
    *         contains an invalid filter expression that cannot be parsed.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException If the service type \c S is invalid.
    *
    * @see GetServiceReferences(const std::string&, const std::string&)
    */
   template<class S>
   std::vector<ServiceReference<S> > GetServiceReferences(const std::string& filter = std::string())
   {
     std::string clazz = us_service_interface_iid<S>();
     if (clazz.empty()) throw ServiceException("The service interface class has no US_DECLARE_SERVICE_INTERFACE macro");
     typedef std::vector<ServiceReferenceU> BaseVectorT;
     BaseVectorT serviceRefs = GetServiceReferences(clazz, filter);
     std::vector<ServiceReference<S> > result;
     for(BaseVectorT::const_iterator i = serviceRefs.begin(); i != serviceRefs.end(); ++i)
     {
       result.push_back(ServiceReference<S>(*i));
     }
     return result;
   }
 
   /**
    * Returns a <code>ServiceReference</code> object for a service that
    * implements and was registered under the specified class.
    *
    * <p>
    * The returned <code>ServiceReference</code> object is valid at the time of
    * the call to this method. However as the Micro Services framework is a very dynamic
    * environment, services can be modified or unregistered at any time.
    *
    * <p>
    * This method is the same as calling
    * {@link ModuleContext::GetServiceReferences(const std::string&, const std::string&)} with an
    * empty filter expression. It is provided as a convenience for
    * when the caller is interested in any service that implements the
    * specified class.
    * <p>
    * If multiple such services exist, the service with the highest ranking (as
    * specified in its us::ServiceConstants::SERVICE_RANKING() property) is returned.
    * <p>
    * If there is a tie in ranking, the service with the lowest service ID (as
    * specified in its us::ServiceConstants::SERVICE_ID() property); that is, the
    * service that was registered first is returned.
    *
    * @param clazz The class name with which the service was registered.
    * @return A <code>ServiceReference</code> object, or an invalid <code>ServiceReference</code> if
    *         no services are registered which implement the named class.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException If no service was registered under the given class name.
    *
    * @see #GetServiceReferences(const std::string&, const std::string&)
    */
   ServiceReferenceU GetServiceReference(const std::string& clazz);
 
   /**
    * Returns a <code>ServiceReference</code> object for a service that
    * implements and was registered under the specified template class argument.
    *
    * <p>
    * This method is identical to GetServiceReference(const std::string&) except that
    * the class name for the service object is automatically deduced from the template argument.
    *
    * @tparam S The type under which the requested service must have been registered.
    * @return A <code>ServiceReference</code> object, or an invalid <code>ServiceReference</code> if
    *         no services are registered which implement the type <code>S</code>.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException It no service was registered under the given class name.
    * @see #GetServiceReference(const std::string&)
    * @see #GetServiceReferences(const std::string&)
    */
   template<class S>
   ServiceReference<S> GetServiceReference()
   {
     std::string clazz = us_service_interface_iid<S>();
     if (clazz.empty()) throw ServiceException("The service interface class has no US_DECLARE_SERVICE_INTERFACE macro");
     return ServiceReference<S>(GetServiceReference(clazz));
   }
 
   /**
    * Returns the service object referenced by the specified
    * <code>ServiceReferenceBase</code> object.
    * <p>
    * A module's use of a service is tracked by the module's use count of that
    * service. Each time a service's service object is returned by
    * {@link #GetService(const ServiceReference<S>&)} the context module's use count for
    * that service is incremented by one. Each time the service is released by
    * {@link #UngetService(const ServiceReferenceBase&)} the context module's use count
    * for that service is decremented by one.
    * <p>
    * When a module's use count for a service drops to zero, the module should
    * no longer use that service.
    *
    * <p>
    * This method will always return <code>0</code> when the service
    * associated with this <code>reference</code> has been unregistered.
    *
    * <p>
    * The following steps are taken to get the service object:
    * <ol>
    * <li>If the service has been unregistered, <code>0</code> is returned.
    * <li>The context module's use count for this service is incremented by
    * one.
    * <li>If the context module's use count for the service is currently one
    * and the service was registered with an object implementing the
    * <code>ServiceFactory</code> interface, the
    * us::ServiceFactory::GetService() method is
    * called to create a service object for the context module. This service
    * object is cached by the framework. While the context module's use count
    * for the service is greater than zero, subsequent calls to get the
    * services's service object for the context module will return the cached
    * service object. <br>
    * If the <code>ServiceFactory</code> object throws an
    * exception, <code>0</code> is returned and a warning is logged.
    * <li>The service object for the service is returned.
    * </ol>
    *
    * @param reference A reference to the service.
    * @return A service object for the service associated with
    *         <code>reference</code> or <code>0</code> if the service is not
    *         registered or the <code>ServiceFactory</code> threw
    *         an exception.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @throws std::invalid_argument If the specified
    *         <code>ServiceReferenceBase</code> is invalid (default constructed).
    * @see #UngetService(const ServiceReferenceBase&)
    * @see ServiceFactory
    */
   void* GetService(const ServiceReferenceBase& reference);
 
   InterfaceMap GetService(const ServiceReferenceU& reference);
 
   /**
    * Returns the service object referenced by the specified
    * <code>ServiceReference</code> object.
    * <p>
    * This is a convenience method which is identical to void* GetService(const ServiceReferenceBase&)
    * except that it casts the service object to the supplied template argument type
    *
    * @tparam S The type the service object will be cast to.
    * @return A service object for the service associated with
    *         <code>reference</code> or <code>0</code> if the service is not
    *         registered, the <code>ServiceFactory</code> threw
    *         an exception or the service could not be casted to the desired type.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @throws std::invalid_argument If the specified
    *         <code>ServiceReference</code> is invalid (default constructed).
    * @see #GetService(const ServiceReferenceBase&)
    * @see #UngetService(const ServiceReferenceBase&)
    * @see ServiceFactory
    */
   template<class S>
   S* GetService(const ServiceReference<S>& reference)
   {
     const ServiceReferenceBase& baseRef = reference;
     return reinterpret_cast<S*>(GetService(baseRef));
   }
 
   /**
    * Returns the ServiceObjects object for the service referenced by the specified
    * ServiceReference object. The ServiceObjects object can be used to obtain
    * multiple service objects for services with prototype scope. For services with
    * singleton or module scope, the ServiceObjects::GetService() method behaves
    * the same as the GetService(const ServiceReference<S>&) method and the
    * ServiceObjects::UngetService(const ServiceReferenceBase&) method behaves the
    * same as the UngetService(const ServiceReferenceBase&) method. That is, only one,
    * use-counted service object is available from the ServiceObjects object.
    *
    * @tparam S Type of Service.
    * @param reference A reference to the service.
    * @return A ServiceObjects object for the service associated with the specified
    * reference or an invalid instance if the service is not registered.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws std::invalid_argument If the specified ServiceReference is invalid
    * (default constructed or the service has been unregistered)
    *
    * @see PrototypeServiceFactory
    */
   template<class S>
   ServiceObjects<S> GetServiceObjects(const ServiceReference<S>& reference)
   {
     return ServiceObjects<S>(this, reference);
   }
 
   /**
    * Releases the service object referenced by the specified
    * <code>ServiceReference</code> object. If the context module's use count
    * for the service is zero, this method returns <code>false</code>.
    * Otherwise, the context modules's use count for the service is decremented
    * by one.
    *
    * <p>
    * The service's service object should no longer be used and all references
    * to it should be destroyed when a module's use count for the service drops
    * to zero.
    *
    * <p>
    * The following steps are taken to unget the service object:
    * <ol>
    * <li>If the context module's use count for the service is zero or the
    * service has been unregistered, <code>false</code> is returned.
    * <li>The context module's use count for this service is decremented by
    * one.
    * <li>If the context module's use count for the service is currently zero
    * and the service was registered with a <code>ServiceFactory</code> object,
    * the ServiceFactory#UngetService
    * method is called to release the service object for the context module.
    * <li><code>true</code> is returned.
    * </ol>
    *
    * @param reference A reference to the service to be released.
    * @return <code>false</code> if the context module's use count for the
    *         service is zero or if the service has been unregistered;
    *         <code>true</code> otherwise.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see #GetService
    * @see ServiceFactory
    */
   bool UngetService(const ServiceReferenceBase& reference);
 
   void AddServiceListener(const ServiceListener& delegate,
                           const std::string& filter = std::string());
   void RemoveServiceListener(const ServiceListener& delegate);
 
   void AddModuleListener(const ModuleListener& delegate);
   void RemoveModuleListener(const ModuleListener& delegate);
 
   /**
    * Adds the specified <code>callback</code> with the
    * specified <code>filter</code> to the context modules's list of listeners.
    * See LDAPFilter for a description of the filter syntax. Listeners
    * are notified when a service has a lifecycle state change.
    *
    * <p>
    * You must take care to remove registered listeners befor the <code>receiver</code>
    * object is destroyed. However, the Micro Services framework takes care
    * of removing all listeners registered by this context module's classes
    * after the module is unloaded.
    *
    * <p>
    * If the context module's list of listeners already contains a pair <code>(r,c)</code>
    * of <code>receiver</code> and <code>callback</code> such that
    * <code>(r == receiver && c == callback)</code>, then this
    * method replaces that callback's filter (which may be empty)
    * with the specified one (which may be empty).
    *
    * <p>
    * The callback is called if the filter criteria is met. To filter based
    * upon the class of the service, the filter should reference the
    * us::ServiceConstants::OBJECTCLASS() property. If <code>filter</code> is
    * empty, all services are considered to match the filter.
    *
    * <p>
    * When using a <code>filter</code>, it is possible that the
    * <code>ServiceEvent</code>s for the complete lifecycle of a service
    * will not be delivered to the callback. For example, if the
    * <code>filter</code> only matches when the property <code>x</code> has
    * the value <code>1</code>, the callback will not be called if the
    * service is registered with the property <code>x</code> not set to the
    * value <code>1</code>. Subsequently, when the service is modified
    * setting property <code>x</code> to the value <code>1</code>, the
    * filter will match and the callback will be called with a
    * <code>ServiceEvent</code> of type <code>MODIFIED</code>. Thus, the
    * callback will not be called with a <code>ServiceEvent</code> of type
    * <code>REGISTERED</code>.
    *
    * @tparam R The type of the receiver (containing the member function to be called)
    * @param receiver The object to connect to.
    * @param callback The member function pointer to call.
    * @param filter The filter criteria.
    * @throws std::invalid_argument If <code>filter</code> contains an
    *         invalid filter string that cannot be parsed.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see ServiceEvent
    * @see RemoveServiceListener()
    */
   template<class R>
   void AddServiceListener(R* receiver, void(R::*callback)(const ServiceEvent),
                           const std::string& filter = std::string())
   {
     AddServiceListener(ServiceListenerMemberFunctor(receiver, callback),
                        static_cast<void*>(receiver), filter);
   }
 
   /**
    * Removes the specified <code>callback</code> from the context module's
    * list of listeners.
    *
    * <p>
    * If the <code>(receiver,callback)</code> pair is not contained in this
    * context module's list of listeners, this method does nothing.
    *
    * @tparam R The type of the receiver (containing the member function to be removed)
    * @param receiver The object from which to disconnect.
    * @param callback The member function pointer to remove.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see AddServiceListener()
    */
   template<class R>
   void RemoveServiceListener(R* receiver, void(R::*callback)(const ServiceEvent))
   {
     RemoveServiceListener(ServiceListenerMemberFunctor(receiver, callback),
                           static_cast<void*>(receiver));
   }
 
   /**
    * Adds the specified <code>callback</code> to the context modules's list
    * of listeners. Listeners are notified when a module has a lifecycle
    * state change.
    *
    * <p>
    * If the context module's list of listeners already contains a pair <code>(r,c)</code>
    * of <code>receiver</code> and <code>callback</code> such that
    * <code>(r == receiver && c == callback)</code>, then this method does nothing.
    *
    * @tparam R The type of the receiver (containing the member function to be called)
    * @param receiver The object to connect to.
    * @param callback The member function pointer to call.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see ModuleEvent
    */
   template<class R>
   void AddModuleListener(R* receiver, void(R::*callback)(const ModuleEvent))
   {
     AddModuleListener(ModuleListenerMemberFunctor(receiver, callback),
                       static_cast<void*>(receiver));
   }
 
   /**
    * Removes the specified <code>callback</code> from the context module's
    * list of listeners.
    *
    * <p>
    * If the <code>(receiver,callback)</code> pair is not contained in this
    * context module's list of listeners, this method does nothing.
    *
    * @tparam R The type of the receiver (containing the member function to be removed)
    * @param receiver The object from which to disconnect.
    * @param callback The member function pointer to remove.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see AddModuleListener()
    */
   template<class R>
   void RemoveModuleListener(R* receiver, void(R::*callback)(const ModuleEvent))
   {
     RemoveModuleListener(ModuleListenerMemberFunctor(receiver, callback),
                          static_cast<void*>(receiver));
   }
 
   /**
    * Get the absolute path for a file or directory in the persistent
    * storage area provided for the module. The returned path
    * might be empty if no storage path has been set previously.
    * If the path is non-empty, it is safe to assume that the path is writable.
    *
    * @see ModuleSettings::SetStoragePath(const std::string&)
    *
    * @param filename A relative name to the file or directory to be accessed.
    * @return The absolute path to the persistent storage area for the given file name.
    */
   std::string GetDataFile(const std::string& filename) const;
 
 
 private:
 
   friend class Module;
   friend class ModulePrivate;
 
   ModuleContext(ModulePrivate* module);
 
   // purposely not implemented
   ModuleContext(const ModuleContext&);
   ModuleContext& operator=(const ModuleContext&);
 
   void AddServiceListener(const ServiceListener& delegate, void* data,
                           const std::string& filter);
   void RemoveServiceListener(const ServiceListener& delegate, void* data);
 
   void AddModuleListener(const ModuleListener& delegate, void* data);
   void RemoveModuleListener(const ModuleListener& delegate, void* data);
 
   ModuleContextPrivate * const d;
 };
 
 US_END_NAMESPACE
 
 #endif /* USMODULECONTEXT_H_ */
diff --git a/Modules/CppMicroServices/core/include/usModuleEvent.h b/Modules/CppMicroServices/core/include/usModuleEvent.h
index 03d7007d30..8a745018f3 100644
--- a/Modules/CppMicroServices/core/include/usModuleEvent.h
+++ b/Modules/CppMicroServices/core/include/usModuleEvent.h
@@ -1,153 +1,153 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEEVENT_H
 #define USMODULEEVENT_H
 
 #include <iostream>
 
 #include "usSharedData.h"
 
 US_BEGIN_NAMESPACE
 
 class Module;
 class ModuleEventData;
 
 /**
  * \ingroup MicroServices
  *
  * An event from the Micro Services framework describing a module lifecycle change.
  * <p>
  * <code>ModuleEvent</code> objects are delivered to listeners connected
  * via ModuleContext::AddModuleListener() when a change
  * occurs in a modules's lifecycle. A type code is used to identify
  * the event type for future extendability.
  *
  * @see ModuleContext#AddModuleListener
  */
 class US_Core_EXPORT ModuleEvent
 {
 
   SharedDataPointer<ModuleEventData> d;
 
 public:
 
   enum Type {
 
     /**
      * The module has been loaded.
      * <p>
      * The module's
      * \link ModuleActivator::Load(ModuleContext*) ModuleActivator Load\endlink method
      * has been executed.
      */
     LOADED,
 
     /**
      * The module has been unloaded.
      * <p>
      * The module's
      * \link ModuleActivator::Unload(ModuleContext*) ModuleActivator Unload\endlink method
      * has been executed.
      */
     UNLOADED,
 
     /**
      * The module is about to be loaded.
      * <p>
      * The module's
      * \link ModuleActivator::Load(ModuleContext*) ModuleActivator Load\endlink method
      * is about to be called.
      */
     LOADING,
 
     /**
      * The module is about to be unloaded.
      * <p>
      * The module's
      * \link ModuleActivator::Unload(ModuleContext*) ModuleActivator Unload\endlink method
      * is about to be called.
      */
     UNLOADING
 
   };
 
   /**
    * Creates an invalid instance.
    */
   ModuleEvent();
 
   ~ModuleEvent();
 
   /**
    * Can be used to check if this ModuleEvent instance is valid,
    * or if it has been constructed using the default constructor.
    *
    * @return <code>true</code> if this event object is valid,
    *         <code>false</code> otherwise.
    */
   bool IsNull() const;
 
   /**
    * Creates a module event of the specified type.
    *
    * @param type The event type.
    * @param module The module which had a lifecycle change.
    */
   ModuleEvent(Type type, Module* module);
 
   ModuleEvent(const ModuleEvent& other);
 
   ModuleEvent& operator=(const ModuleEvent& other);
 
   /**
    * Returns the module which had a lifecycle change.
    *
    * @return The module that had a change occur in its lifecycle.
    */
   Module* GetModule() const;
 
   /**
    * Returns the type of lifecyle event. The type values are:
    * <ul>
    * <li>{@link #LOADING}
    * <li>{@link #LOADED}
    * <li>{@link #UNLOADING}
    * <li>{@link #UNLOADED}
    * </ul>
    *
    * @return The type of lifecycle event.
    */
   Type GetType() const;
 
 };
 
 /**
  * \ingroup MicroServices
  * @{
  */
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, ModuleEvent::Type eventType);
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, const ModuleEvent& event);
 /** @}*/
 
 US_END_NAMESPACE
 
 #endif // USMODULEEVENT_H
diff --git a/Modules/CppMicroServices/core/include/usModuleEventHook.h b/Modules/CppMicroServices/core/include/usModuleEventHook.h
index 6ccebe0c46..94d72814f2 100644
--- a/Modules/CppMicroServices/core/include/usModuleEventHook.h
+++ b/Modules/CppMicroServices/core/include/usModuleEventHook.h
@@ -1,70 +1,70 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEEVENTHOOK_H
 #define USMODULEEVENTHOOK_H
 
 #include "usServiceInterface.h"
 #include "usShrinkableVector.h"
 
 US_BEGIN_NAMESPACE
 
 class ModuleContext;
 class ModuleEvent;
 
 /**
  * @ingroup MicroServices
  *
  * %Module Event Hook Service.
  *
  * <p>
  * Modules registering this service will be called during module lifecycle
  * (loading, loaded, unloading, and unloaded) operations.
  *
  * @remarks Implementations of this interface are required to be thread-safe.
  */
 struct US_Core_EXPORT ModuleEventHook
 {
 
   virtual ~ModuleEventHook();
 
   /**
    * Module event hook method. This method is called prior to module event
    * delivery when a module is loading, loaded, unloading, or unloaded.
    * This method can filter the modules which receive the event.
    * <p>
    * This method is called one and only one time for
    * each module event generated, this includes module events which are
    * generated when there are no module listeners registered.
    *
    * @param event The module event to be delivered.
    * @param contexts A list of Module Contexts for modules which have
    *        listeners to which the specified event will be delivered. The
    *        implementation of this method may remove module contexts from the
    *        list to prevent the event from being delivered to the
    *        associated modules.
    */
   virtual void Event(const ModuleEvent& event, ShrinkableVector<ModuleContext*>& contexts) = 0;
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULEEVENTHOOK_H
diff --git a/Modules/CppMicroServices/core/include/usModuleFindHook.h b/Modules/CppMicroServices/core/include/usModuleFindHook.h
index c5a5324ec5..5e5b21591e 100644
--- a/Modules/CppMicroServices/core/include/usModuleFindHook.h
+++ b/Modules/CppMicroServices/core/include/usModuleFindHook.h
@@ -1,71 +1,71 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEFINDHOOK_H
 #define USMODULEFINDHOOK_H
 
 #include "usServiceInterface.h"
 #include "usShrinkableVector.h"
 
 US_BEGIN_NAMESPACE
 
 class Module;
 class ModuleContext;
 
 /**
  * @ingroup MicroServices
  *
  * %Module Context Hook Service.
  *
  * <p>
  * Modules registering this service will be called during module find
  * (get modules) operations.
  *
  * @remarks Implementations of this interface are required to be thread-safe.
  */
 struct US_Core_EXPORT ModuleFindHook
 {
 
   virtual ~ModuleFindHook();
 
   /**
    * Find hook method. This method is called for module find operations
    * using ModuleContext::GetBundle(long)
    * and ModuleContext::GetModules() methods. The find method can
    * filter the result of the find operation.
    *
    * \note A find operation using the ModuleContext::GetModule(const std::string&)
    *       method does not cause the find method to be called, neither does any
    *       call to the static methods of the ModuleRegistry class.
    *
    * @param context The module context of the module performing the find
    *        operation.
    * @param modules A list of Modules to be returned as a result of the
    *        find operation. The implementation of this method may remove
    *        modules from the list to prevent the modules from being
    *        returned to the module performing the find operation.
    */
   virtual void Find(const ModuleContext* context, ShrinkableVector<Module*>& modules) = 0;
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULEFINDHOOK_H
diff --git a/Modules/CppMicroServices/core/include/usModuleImport.h b/Modules/CppMicroServices/core/include/usModuleImport.h
index f503118e41..36f67faeb8 100644
--- a/Modules/CppMicroServices/core/include/usModuleImport.h
+++ b/Modules/CppMicroServices/core/include/usModuleImport.h
@@ -1,93 +1,93 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEIMPORT_H
 #define USMODULEIMPORT_H
 
 #include <usGlobalConfig.h>
 
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 struct ModuleActivator;
 
 US_END_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * \brief Initialize a static module.
  *
  * \param _module_name The name of the module to initialize.
  *
  * This macro initializes the static module named \c _module_name.
  *
  * It the module provides an activator, use the #US_IMPORT_MODULE macro instead,
  * to ensure that the activator is called. Do not forget to actually link
  * the static module to the importing executable or shared library.
  *
  * \sa US_IMPORT_MODULE
  * \sa US_IMPORT_MODULE_RESOURCES
  * \sa \ref MicroServices_StaticModules
  */
 #define US_INITIALIZE_STATIC_MODULE(_module_name)                          \
   extern "C" void _us_import_module_initializer_ ## _module_name();        \
   struct StaticModuleInitializer_ ## _module_name                          \
   {                                                                        \
     StaticModuleInitializer_ ## _module_name()                             \
     {                                                                      \
       _us_import_module_initializer_ ## _module_name();                    \
     }                                                                      \
   };                                                                       \
   static StaticModuleInitializer_ ## _module_name _InitializeModule_ ## _module_name;
 
 /**
  * \ingroup MicroServices
  *
  * \brief Import a static module.
  *
  * \param _module_name The name of the module to import.
  *
  * This macro imports the static module named \c _module_name.
  *
  * Inserting this macro into your application's source code will allow you to make use of
  * a static module. It will initialize the static module and calls its
  * ModuleActivator. It the module does not provide an activator, use the
  * #US_INITIALIZE_STATIC_MODULE macro instead. Do not forget to actually link
  * the static module to the importing executable or shared library.
  *
  * Example:
  * \snippet uServices-staticmodules/main.cpp ImportStaticModuleIntoMain
  *
  * \sa US_INITIALIZE_STATIC_MODULE
  * \sa US_IMPORT_MODULE_RESOURCES
  * \sa \ref MicroServices_StaticModules
  */
 #define US_IMPORT_MODULE(_module_name)                                     \
   US_INITIALIZE_STATIC_MODULE(_module_name)                                \
   extern "C" US_PREPEND_NAMESPACE(ModuleActivator)* _us_module_activator_instance_ ## _module_name (); \
   void _dummy_reference_to_ ## _module_name ## _activator()                \
   {                                                                        \
     _us_module_activator_instance_ ## _module_name();                      \
   }
 
 #endif // USMODULEREGISTRY_H
diff --git a/Modules/CppMicroServices/core/include/usModuleInfo.h b/Modules/CppMicroServices/core/include/usModuleInfo.h
index 175b41d8c7..c2a5264936 100644
--- a/Modules/CppMicroServices/core/include/usModuleInfo.h
+++ b/Modules/CppMicroServices/core/include/usModuleInfo.h
@@ -1,50 +1,50 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USMODULEINFO_H
 #define USMODULEINFO_H
 
 #include <usCoreConfig.h>
 
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 struct ModuleActivator;
 
 /**
  * This class is not intended to be used directly. It is exported to support
  * the CppMicroServices module system.
  */
 struct US_Core_EXPORT ModuleInfo
 {
   ModuleInfo(const std::string& name);
 
   std::string name;
   std::string location;
   std::string autoLoadDir;
   long id;
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULEINFO_H
diff --git a/Modules/CppMicroServices/core/include/usModuleInitialization.h b/Modules/CppMicroServices/core/include/usModuleInitialization.h
index c8691e0233..f0ea791b8d 100644
--- a/Modules/CppMicroServices/core/include/usModuleInitialization.h
+++ b/Modules/CppMicroServices/core/include/usModuleInitialization.h
@@ -1,120 +1,120 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef US_MODULE_NAME
 #error Missing US_MODULE_NAME preprocessor define
 #endif
 
 #ifndef USMODULEINITIALIZATION_H
 #define USMODULEINITIALIZATION_H
 
 #include <usStaticInit_p.h>
 
 #include <usModuleRegistry.h>
 #include <usModuleInfo.h>
 #include <usModuleUtils_p.h>
 
 #include <cstring>
 
 
 /**
  * \ingroup MicroServices
  *
  * \brief Creates initialization code for a module.
  *
  * Each module which wants to register itself with the CppMicroServices library
  * has to put a call to this macro in one of its source files. Further, the modules
  * source files must be compiled with the \c US_MODULE_NAME pre-processor definition
  * set to a module-unique identifier.
  *
  * Calling the \c US_INITIALIZE_MODULE macro will initialize the module for use with
  * the CppMicroServices library, using a default auto-load directory named after the
  * \c US_MODULE_NAME definition.
  *
  * \sa MicroServices_AutoLoading
  *
  * \remarks If you are using CMake, consider using the provided CMake macro
  * <code>usFunctionGenerateModuleInit()</code>.
  */
 #define US_INITIALIZE_MODULE                                                                 \
 US_BEGIN_NAMESPACE                                                                           \
 namespace {                                                                                  \
                                                                                              \
 /* Declare a file scoped ModuleInfo object */                                                \
 US_GLOBAL_STATIC_WITH_ARGS(ModuleInfo, moduleInfo, (US_STR(US_MODULE_NAME)))                 \
                                                                                              \
 /* This class is used to statically initialize the library within the C++ Micro services     \
    library. It looks up a library specific C-style function returning an instance            \
    of the ModuleActivator interface. */                                                      \
 class US_ABI_LOCAL US_CONCAT(ModuleInitializer_, US_MODULE_NAME) {                           \
                                                                                              \
 public:                                                                                      \
                                                                                              \
   US_CONCAT(ModuleInitializer_, US_MODULE_NAME)()                                            \
   {                                                                                          \
     ModuleInfo*(*moduleInfoPtr)() = moduleInfo;                                              \
     void* moduleInfoSym = nullptr;                                                              \
     std::memcpy(&moduleInfoSym, &moduleInfoPtr, sizeof(void*));                              \
     std::string location = ModuleUtils::GetLibraryPath(moduleInfoSym);                       \
     moduleInfoPtr()->location = location;                                                    \
                                                                                              \
     Register();                                                                              \
   }                                                                                          \
                                                                                              \
   static void Register()                                                                     \
   {                                                                                          \
     ModuleRegistry::Register(moduleInfo());                                                  \
   }                                                                                          \
                                                                                              \
   ~US_CONCAT(ModuleInitializer_, US_MODULE_NAME)()                                           \
   {                                                                                          \
     ModuleRegistry::UnRegister(moduleInfo());                                                \
   }                                                                                          \
                                                                                              \
 };                                                                                           \
                                                                                              \
                                                                                              \
 US_DEFINE_MODULE_INITIALIZER                                                                 \
 }                                                                                            \
                                                                                              \
 US_END_NAMESPACE                                                                             \
                                                                                              \
 /* A helper function which is called by the US_IMPORT_MODULE macro to initialize             \
    static modules */                                                                         \
 extern "C" void US_ABI_LOCAL US_CONCAT(_us_import_module_initializer_, US_MODULE_NAME)()     \
 {                                                                                            \
   static US_PREPEND_NAMESPACE(US_CONCAT(ModuleInitializer_, US_MODULE_NAME)) US_CONCAT(_InitializeModule_, US_MODULE_NAME); \
 }
 
 // Create a file-scoped static object for registering the module
 // during static initialization of the shared library
 #define US_DEFINE_MODULE_INITIALIZER \
 static US_CONCAT(ModuleInitializer_, US_MODULE_NAME) US_CONCAT(_InitializeModule_, US_MODULE_NAME);
 
 // Static modules don't create a file-scoped static object for initialization
 // (it would be discarded during static linking anyway). The initialization code
 // is triggered by the US_IMPORT_MODULE macro instead.
 #if defined(US_STATIC_MODULE)
 #undef US_DEFINE_MODULE_INITIALIZER
 #define US_DEFINE_MODULE_INITIALIZER
 #endif
 
 #endif // USMODULEINITIALIZATION_H
diff --git a/Modules/CppMicroServices/core/include/usModuleRegistry.h b/Modules/CppMicroServices/core/include/usModuleRegistry.h
index 587a2a8e06..ce91c98be9 100644
--- a/Modules/CppMicroServices/core/include/usModuleRegistry.h
+++ b/Modules/CppMicroServices/core/include/usModuleRegistry.h
@@ -1,90 +1,90 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEREGISTRY_H
 #define USMODULEREGISTRY_H
 
 #include <vector>
 #include <string>
 
 #include <usCoreConfig.h>
 
 US_BEGIN_NAMESPACE
 
 class Module;
 struct ModuleInfo;
 struct ModuleActivator;
 
 /**
  * \ingroup MicroServices
  *
  * Here we handle all the modules that are loaded in the framework.
  */
 class US_Core_EXPORT ModuleRegistry {
 
 public:
 
   /**
    * Get the module that has the specified module identifier.
    *
    * @param id The identifier of the module to get.
    * @return Module or null
    *         if the module was not found.
    */
   static Module* GetModule(long id);
 
   /**
    * Get the module that has specified module name.
    *
    * @param name The name of the module to get.
    * @return Module or null.
    */
   static Module* GetModule(const std::string& name);
 
   /**
    * Get all known modules.
    *
    * @return A list which is filled with all known modules.
    */
   static std::vector<Module*> GetModules();
 
   /**
    * Get all modules currently in module state <code>LOADED</code>.
    *
    * @return A list which is filled with all modules in
    *         state <code>LOADED</code>
    */
   static std::vector<Module*> GetLoadedModules();
 
   static void Register(ModuleInfo* info);
 
   static void UnRegister(const ModuleInfo* info);
 
 private:
 
   // disabled
   ModuleRegistry();
 
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULEREGISTRY_H
diff --git a/Modules/CppMicroServices/core/include/usModuleResource.h b/Modules/CppMicroServices/core/include/usModuleResource.h
index ffbe66c728..fa06df61e1 100644
--- a/Modules/CppMicroServices/core/include/usModuleResource.h
+++ b/Modules/CppMicroServices/core/include/usModuleResource.h
@@ -1,312 +1,312 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USMODULERESOURCE_H
 #define USMODULERESOURCE_H
 
 #include <usCoreExport.h>
 
 #include <ostream>
 #include <vector>
 
 US_MSVC_PUSH_DISABLE_WARNING(4396)
 
 US_BEGIN_NAMESPACE
 
 class ModuleResourcePrivate;
 class ModuleResourceContainer;
 
 /**
  * \ingroup MicroServices
  *
  * Represents a resource (text file, image, etc.) embedded in a CppMicroServices module.
  *
  * A \c %ModuleResource object provides information about a resource (external file) which
  * was embedded into this module's shared library. \c %ModuleResource objects can be obtained
  * be calling Module#GetResource or Module#FindResources.
  *
  * Example code for retreiving a resource object and reading its contents:
  * \snippet uServices-resources/main.cpp 1
  *
  * %ModuleResource objects have value semantics and copies are very inexpensive.
  *
  * \see ModuleResourceStream
  * \see \ref MicroServices_Resources
  */
 class US_Core_EXPORT ModuleResource
 {
 
 private:
 
   typedef ModuleResourcePrivate* ModuleResource::*bool_type;
 
 public:
 
   /**
    * Creates in invalid %ModuleResource object.
    */
   ModuleResource();
   /**
    * Copy constructor.
    * @param resource The object to be copied.
    */
   ModuleResource(const ModuleResource& resource);
 
   ~ModuleResource();
 
   /**
    * Assignment operator.
    *
    * @param resource The %ModuleResource object which is assigned to this instance.
    * @return A reference to this %ModuleResource instance.
    */
   ModuleResource& operator=(const ModuleResource& resource);
 
   /**
    * A less then operator using the full resource path as returned by
    * GetResourcePath() to define the ordering.
    *
    * @param resource The object to which this %ModuleResource object is compared to.
    * @return \c true if this %ModuleResource object is less then \c resource,
    * \c false otherwise.
    */
   bool operator<(const ModuleResource& resource) const;
 
   /**
    * Equality operator for %ModuleResource objects.
    *
    * @param resource The object for testing equality.
    * @return \c true if this %ModuleResource object is equal to \c resource, i.e.
    * they are coming from the same module (shared or static) and have an equal
    * resource path, \c false otherwise.
    */
   bool operator==(const ModuleResource& resource) const;
 
   /**
    * Inequality operator for %ModuleResource objects.
    *
    * @param resource The object for testing inequality.
    * @return The result of <code>!(*this == resource)</code>.
    */
   bool operator!=(const ModuleResource& resource) const;
 
   /**
    * Tests this %ModuleResource object for validity.
    *
    * Invalid %ModuleResource objects are created by the default constructor or
    * can be returned by the Module class if the resource path is not found.
    *
    * @return \c true if this %ModuleReource object is valid and can safely be used,
    * \c false otherwise.
    */
   bool IsValid() const;
 
   /**
    * Boolean conversion operator using IsValid().
    */
   operator bool_type() const;
 
   /**
    * Returns the name of the resource, excluding the path.
    *
    * Example:
    * \code
    * ModuleResource resource = module->GetResource("/data/archive.tar.gz");
    * std::string name = resource.GetName(); // name = "archive.tar.gz"
    * \endcode
    *
    * @return The resource name.
    * @see GetPath(), GetResourcePath()
    */
   std::string GetName() const;
 
   /**
    * Returns the resource's path, without the file name.
    *
    * Example:
    * \code
    * ModuleResource resource = module->GetResource("/data/archive.tar.gz");
    * std::string path = resource.GetPath(); // path = "/data/"
    * \endcode
    *
    * The path with always begin and end with a forward slash.
    *
    * @return The resource path without the name.
    * @see GetResourcePath(), GetName() and IsDir()
    */
   std::string GetPath() const;
 
   /**
    * Returns the resource path including the file name.
    *
    * @return The resource path including the file name.
    * @see GetPath(), GetName() and IsDir()
    */
   std::string GetResourcePath() const;
 
   /**
    * Returns the base name of the resource without the path.
    *
    * Example:
    * \code
    * ModuleResource resource = module->GetResource("/data/archive.tar.gz");
    * std::string base = resource.GetBaseName(); // base = "archive"
    * \endcode
    *
    * @return The resource base name.
    * @see GetName(), GetSuffix(), GetCompleteSuffix() and GetCompleteBaseName()
    */
   std::string GetBaseName() const;
 
   /**
    * Returns the complete base name of the resource without the path.
    *
    * Example:
    * \code
    * ModuleResource resource = module->GetResource("/data/archive.tar.gz");
    * std::string base = resource.GetCompleteBaseName(); // base = "archive.tar"
    * \endcode
    *
    * @return The resource's complete base name.
    * @see GetName(), GetSuffix(), GetCompleteSuffix(), and GetBaseName()
    */
   std::string GetCompleteBaseName() const;
 
   /**
    * Returns the suffix of the resource.
    *
    * The suffix consists of all characters in the resource name after (but not
    * including) the last '.'.
    *
    * Example:
    * \code
    * ModuleResource resource = module->GetResource("/data/archive.tar.gz");
    * std::string suffix = resource.GetSuffix(); // suffix = "gz"
    * \endcode
    *
    * @return The resource name suffix.
    * @see GetName(), GetCompleteSuffix(), GetBaseName() and GetCompleteBaseName()
    */
   std::string GetSuffix() const;
 
   /**
    * Returns the complete suffix of the resource.
    *
    * The suffix consists of all characters in the resource name after (but not
    * including) the first '.'.
    *
    * Example:
    * \code
    * ModuleResource resource = module->GetResource("/data/archive.tar.gz");
    * std::string suffix = resource.GetCompleteSuffix(); // suffix = "tar.gz"
    * \endcode
    *
    * @return The resource name suffix.
    * @see GetName(), GetSuffix(), GetBaseName(), and GetCompleteBaseName()
    */
   std::string GetCompleteSuffix() const;
 
   /**
    * Returns \c true if this %ModuleResource object points to a directory and thus
    * may have child resources.
    *
    * @return \c true if this object points to a directory, \c false otherwise.
    */
   bool IsDir() const;
 
   /**
    * Returns \c true if this %ModuleResource object points to a file resource.
    *
    * @return \c true if this object points to an embedded file, \c false otherwise.
    */
   bool IsFile() const;
 
   /**
    * Returns a list of resource names which are children of this object.
    *
    * The returned names are relative to the path of this %ModuleResource object
    * and may contain file as well as directory entries.
    *
    * @return A list of child resource names.
    */
   std::vector<std::string> GetChildren() const;
 
   /**
    * Returns a list of resource objects which are children of this object.
    *
    * The return ModuleResource objects may contain files as well as
    * directory resources.
    *
    * @return A list of child resource objects.
    */
   std::vector<ModuleResource> GetChildResources() const;
 
   /**
    * Returns the size of the resource data for this %ModuleResource object.
    *
    * @return The resource data size.
    */
   int GetSize() const;
 
   /**
    * Returns the last modified time of this resource in seconds from the epoch.
    *
    * @return Last modified time of this resource.
    */
   time_t GetLastModified() const;
 
 private:
 
   ModuleResource(const std::string& file, const ModuleResourceContainer& resourceContainer);
   ModuleResource(int index, const ModuleResourceContainer& resourceContainer);
 
   friend class Module;
   friend class ModulePrivate;
   friend class ModuleResourceContainer;
   friend class ModuleResourceStream;
 
   US_HASH_FUNCTION_FRIEND(ModuleResource);
 
   std::size_t Hash() const;
 
   void* GetData() const;
 
   ModuleResourcePrivate* d;
 
 };
 
 US_END_NAMESPACE
 
 US_MSVC_POP_WARNING
 
 /**
  * \ingroup MicroServices
  */
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, const US_PREPEND_NAMESPACE(ModuleResource)& resource);
 
 US_HASH_FUNCTION_NAMESPACE_BEGIN
 US_HASH_FUNCTION_BEGIN(US_PREPEND_NAMESPACE(ModuleResource))
   return arg.Hash();
 US_HASH_FUNCTION_END
 US_HASH_FUNCTION_NAMESPACE_END
 
 #endif // USMODULERESOURCE_H
diff --git a/Modules/CppMicroServices/core/include/usModuleResourceStream.h b/Modules/CppMicroServices/core/include/usModuleResourceStream.h
index 1522423c35..f0fdb96371 100644
--- a/Modules/CppMicroServices/core/include/usModuleResourceStream.h
+++ b/Modules/CppMicroServices/core/include/usModuleResourceStream.h
@@ -1,70 +1,70 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULERESOURCESTREAM_H
 #define USMODULERESOURCESTREAM_H
 
 #include "usModuleResourceBuffer_p.h"
 
 #include <fstream>
 
 US_BEGIN_NAMESPACE
 
 class ModuleResource;
 
 /**
  * \ingroup MicroServices
  *
  * An input stream class for ModuleResource objects.
  *
  * This class provides access to the resource data embedded in a module's
  * shared library via a STL input stream interface.
  *
  * \see ModuleResource for an example how to use this class.
  */
 class US_Core_EXPORT ModuleResourceStream : private ModuleResourceBuffer, public std::istream
 {
 
 public:
 
   /**
    * Construct a %ModuleResourceStream object.
    *
    * @param resource The ModuleResource object for which an input stream
    * should be constructed.
    * @param mode The open mode of the stream. If \c std::ios_base::binary
    * is used, the resource data will be treated as binary data, otherwise
    * the data is interpreted as text data and the usual platform specific
    * end-of-line translations take place.
    */
   ModuleResourceStream(const ModuleResource& resource,
                        std::ios_base::openmode mode = std::ios_base::in);
 
 private:
 
   // purposely not implemented
   ModuleResourceStream(const ModuleResourceStream&);
   ModuleResourceStream& operator=(const ModuleResourceStream&);
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULERESOURCESTREAM_H
diff --git a/Modules/CppMicroServices/core/include/usModuleSettings.h b/Modules/CppMicroServices/core/include/usModuleSettings.h
index 71e5e5c216..7f1c17ee1a 100644
--- a/Modules/CppMicroServices/core/include/usModuleSettings.h
+++ b/Modules/CppMicroServices/core/include/usModuleSettings.h
@@ -1,171 +1,171 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USMODULESETTINGS_H
 #define USMODULESETTINGS_H
 
 #include "usCoreConfig.h"
 
 #include <vector>
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * Query and set certain properties of the CppMicroServices library.
  *
  * The following environment variables influence the runtime behavior
  * of the CppMicroServices library:
  *
  * - \e US_DISABLE_AUTOLOADING If set, auto-loading of modules is disabled.
  * - \e US_AUTOLOAD_PATHS A ':' (Unix) or ';' (Windows) separated list of paths
  *   from which modules should be auto-loaded.
  *
  * \remarks This class is thread safe.
  */
 class US_Core_EXPORT ModuleSettings
 {
 public:
 
   typedef std::vector<std::string> PathList;
 
   /**
    * Returns a special string which can be used as an argument for a
    * AddAutoLoadPath() call.
    *
    * When a module is loaded and this string has been added as a path
    * to the list of auto-load paths the CppMicroServices library will
    * auto-load all modules from the currently being loaded module's
    * auto-load directory.
    *
    * \return A string to be used in AddAutoLoadPath().
    *
    * \remarks The returned string is contained in the default set of
    * auto-load paths, unless a new set of paths is given by a call to
    * SetAutoLoadPaths().
    *
    * \sa MicroServices_AutoLoading
    * \sa US_INITIALIZE_MODULE
    */
   static std::string CURRENT_MODULE_PATH();
 
   /**
    * \return \c true if threading support has been configured into the
    * CppMicroServices library, \c false otherwise.
    */
   static bool IsThreadingSupportEnabled();
 
   /**
    * \return \c true if support for module auto-loading is enabled,
    * \c false otherwise.
    *
    * \remarks This method will always return \c false if support for auto-loading
    * has not been configured into the CppMicroServices library or if it has been
    * disabled by defining the US_DISABLE_AUTOLOADING environment variable.
    */
   static bool IsAutoLoadingEnabled();
 
   /**
    * Enable or disable auto-loading support.
    *
    * \param enable If \c true, enable auto-loading support, disable it otherwise.
    *
    * \remarks Calling this method will have no effect if support for
    * auto-loading has not been configured into the CppMicroServices library of it
    * it has been disabled by defining the US_DISABLE_AUTOLOADING envrionment variable.
    */
   static void SetAutoLoadingEnabled(bool enable);
 
   /**
    * \return A list of paths in the file-system from which modules will be
    * auto-loaded.
    */
   static PathList GetAutoLoadPaths();
 
   /**
    * Set a list of paths in the file-system from which modules should be
    * auto-loaded.
    * @param paths A list of absolute file-system paths.
    */
   static void SetAutoLoadPaths(const PathList& paths);
 
   /**
    * Add a path in the file-system to the list of paths from which modules
    * will be auto-loaded.
    *
    * @param path The additional absolute auto-load path in the file-system.
    */
   static void AddAutoLoadPath(const std::string& path);
 
   /**
    * Set a local storage path for persistend module data.
    *
    * This path is used as a base directory for providing modules
    * with a storage path for writing persistent data. The callee
    * must ensure that the provided path exists and is writable.
    *
    * @see ModuleContext::GetDataFile(const std::string&)
    *
    * @param path An absolute path for writing persistent data.
    */
   static void SetStoragePath(const std::string& path);
 
   /**
    * Get the absolute path for persistent data. The returned path
    * might be empty. If the path is non-empty, it is safe to assume
    * that the path exists and is writable.
    *
    * @return The absolute path to the persistent storage path.
    */
   static std::string GetStoragePath();
 
   /**
    * Set the logging level for log messages from CppMicroServices modules.
    *
    * Higher logging levels will discard messages with lower priority.
    * E.g. a logging level of WarningMsg will discard all messages of
    * type DebugMsg and InfoMsg.
    *
    * @param level The new logging level.
    */
   static void SetLogLevel(MsgType level);
 
   /**
    * Get the current logging level.
    *
    * @return The currently used logging level.
    */
   static MsgType GetLogLevel();
 
 private:
 
   // purposely not implemented
   ModuleSettings();
   ModuleSettings(const ModuleSettings&);
   ModuleSettings& operator=(const ModuleSettings&);
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULESETTINGS_H
diff --git a/Modules/CppMicroServices/core/include/usModuleVersion.h b/Modules/CppMicroServices/core/include/usModuleVersion.h
index 90eca373e9..88b8fcb48d 100644
--- a/Modules/CppMicroServices/core/include/usModuleVersion.h
+++ b/Modules/CppMicroServices/core/include/usModuleVersion.h
@@ -1,254 +1,254 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEVERSION_H
 #define USMODULEVERSION_H
 
 #include <usCoreExport.h>
 
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * Version identifier for CppMicroServices modules.
  *
  * <p>
  * Version identifiers have four components.
  * <ol>
  * <li>Major version. A non-negative integer.</li>
  * <li>Minor version. A non-negative integer.</li>
  * <li>Micro version. A non-negative integer.</li>
  * <li>Qualifier. A text string. See <code>ModuleVersion(const std::string&)</code> for the
  * format of the qualifier string.</li>
  * </ol>
  *
  * <p>
  * <code>ModuleVersion</code> objects are immutable.
  */
 class US_Core_EXPORT ModuleVersion {
 
 private:
 
   friend class ModulePrivate;
 
   unsigned int majorVersion;
   unsigned int minorVersion;
   unsigned int microVersion;
   std::string      qualifier;
 
   static const char SEPARATOR; //  = "."
 
   bool undefined;
 
 
   /**
    * Called by the ModuleVersion constructors to validate the version components.
    *
    * @return <code>true</code> if the validation was successfull, <code>false</code> otherwise.
    */
   void Validate();
 
   ModuleVersion& operator=(const ModuleVersion& v);
 
   explicit ModuleVersion(bool undefined = false);
 
 public:
 
   /**
    * The empty version "0.0.0".
    */
   static ModuleVersion EmptyVersion();
 
   /**
    * Creates an undefined version identifier, representing either
    * infinity or minus infinity.
    */
   static ModuleVersion UndefinedVersion();
 
   /**
    * Creates a version identifier from the specified numerical components.
    *
    * <p>
    * The qualifier is set to the empty string.
    *
    * @param majorVersion Major component of the version identifier.
    * @param minorVersion Minor component of the version identifier.
    * @param microVersion Micro component of the version identifier.
    *
    */
   ModuleVersion(unsigned int majorVersion, unsigned int minorVersion, unsigned int microVersion);
 
   /**
    * Creates a version identifier from the specified components.
    *
    * @param majorVersion Major component of the version identifier.
    * @param minorVersion Minor component of the version identifier.
    * @param microVersion Micro component of the version identifier.
    * @param qualifier Qualifier component of the version identifier.
    */
   ModuleVersion(unsigned int majorVersion, unsigned int minorVersion, unsigned int microVersion, const std::string& qualifier);
 
   /**
    * Created a version identifier from the specified string.
    *
    * <p>
    * Here is the grammar for version strings.
    *
    * <pre>
    * version ::= majorVersion('.'minorVersion('.'microVersion('.'qualifier)?)?)?
    * majorVersion ::= digit+
    * minorVersion ::= digit+
    * microVersion ::= digit+
    * qualifier ::= (alpha|digit|'_'|'-')+
    * digit ::= [0..9]
    * alpha ::= [a..zA..Z]
    * </pre>
    *
    * There must be no whitespace in version.
    *
    * @param version string representation of the version identifier.
    */
   ModuleVersion(const std::string& version);
 
   /**
    * Create a version identifier from another.
    *
    * @param version Another version identifier
    */
   ModuleVersion(const ModuleVersion& version);
 
 
   /**
    * Parses a version identifier from the specified string.
    *
    * <p>
    * See <code>ModuleVersion(const std::string&)</code> for the format of the version string.
    *
    * @param version string representation of the version identifier. Leading
    *        and trailing whitespace will be ignored.
    * @return A <code>ModuleVersion</code> object representing the version
    *         identifier. If <code>version</code> is the empty string
    *         then <code>EmptyVersion</code> will be
    *         returned.
    */
   static ModuleVersion ParseVersion(const std::string& version);
 
   /**
    * Returns the undefined state of this version identifier.
    *
    * @return <code>true</code> if this version identifier is undefined,
    *         <code>false</code> otherwise.
    */
   bool IsUndefined() const;
 
   /**
    * Returns the majorVersion component of this version identifier.
    *
    * @return The majorVersion component.
    */
   unsigned int GetMajor() const;
 
   /**
    * Returns the minorVersion component of this version identifier.
    *
    * @return The minorVersion component.
    */
   unsigned int GetMinor() const;
 
   /**
    * Returns the microVersion component of this version identifier.
    *
    * @return The microVersion component.
    */
   unsigned int GetMicro() const;
 
   /**
    * Returns the qualifier component of this version identifier.
    *
    * @return The qualifier component.
    */
   std::string GetQualifier() const;
 
   /**
    * Returns the string representation of this version identifier.
    *
    * <p>
    * The format of the version string will be <code>majorVersion.minorVersion.microVersion</code>
    * if qualifier is the empty string or
    * <code>majorVersion.minorVersion.microVersion.qualifier</code> otherwise.
    *
    * @return The string representation of this version identifier.
    */
   std::string ToString() const;
 
   /**
    * Compares this <code>ModuleVersion</code> object to another object.
    *
    * <p>
    * A version is considered to be <b>equal to </b> another version if the
    * majorVersion, minorVersion and microVersion components are equal and the qualifier component
    * is equal.
    *
    * @param object The <code>ModuleVersion</code> object to be compared.
    * @return <code>true</code> if <code>object</code> is a
    *         <code>ModuleVersion</code> and is equal to this object;
    *         <code>false</code> otherwise.
    */
   bool operator==(const ModuleVersion& object) const;
 
   /**
    * Compares this <code>ModuleVersion</code> object to another object.
    *
    * <p>
    * A version is considered to be <b>less than </b> another version if its
    * majorVersion component is less than the other version's majorVersion component, or the
    * majorVersion components are equal and its minorVersion component is less than the other
    * version's minorVersion component, or the majorVersion and minorVersion components are equal
    * and its microVersion component is less than the other version's microVersion component,
    * or the majorVersion, minorVersion and microVersion components are equal and it's qualifier
    * component is less than the other version's qualifier component (using
    * <code>std::string::operator<()</code>).
    *
    * <p>
    * A version is considered to be <b>equal to</b> another version if the
    * majorVersion, minorVersion and microVersion components are equal and the qualifier component
    * is equal.
    *
    * @param object The <code>ModuleVersion</code> object to be compared.
    * @return A negative integer, zero, or a positive integer if this object is
    *         less than, equal to, or greater than the specified
    *         <code>ModuleVersion</code> object.
    */
   int Compare(const ModuleVersion& object) const;
 
 };
 
 US_END_NAMESPACE
 
 /**
  * \ingroup MicroServices
  */
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, const US_PREPEND_NAMESPACE(ModuleVersion)& v);
 
 #endif // USMODULEVERSION_H
diff --git a/Modules/CppMicroServices/core/include/usPrototypeServiceFactory.h b/Modules/CppMicroServices/core/include/usPrototypeServiceFactory.h
index 2558f053c4..5992d4689f 100644
--- a/Modules/CppMicroServices/core/include/usPrototypeServiceFactory.h
+++ b/Modules/CppMicroServices/core/include/usPrototypeServiceFactory.h
@@ -1,102 +1,102 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USPROTOTYPESERVICEFACTORY_H
 #define USPROTOTYPESERVICEFACTORY_H
 
 #include <usServiceFactory.h>
 
 US_BEGIN_NAMESPACE
 
 /**
  * @ingroup MicroServices
  *
  * A factory for \link ServiceConstants::SCOPE_PROTOTYPE prototype scope\endlink services.
  * The factory can provide multiple, unique service objects.
  *
  * When registering a service, a PrototypeServiceFactory object can be used
  * instead of a service object, so that the module developer can create a
  * unique service object for each caller that is using the service.
  * When a caller uses a ServiceObjects to request a service instance, the
  * framework calls the GetService method to return a service object specifically
  * for the requesting caller. The caller can release the returned service object
  * and the framework will call the UngetService method with the service object.
  * When a module uses the ModuleContext::GetService(const ServiceReferenceBase&)
  * method to obtain a service object, the framework acts as if the service
  * has module scope. That is, the framework will call the GetService method to
  * obtain a module-scoped instance which will be cached and have a use count.
  * See ServiceFactory.
  *
  * A module can use both ServiceObjects and ModuleContext::GetService(const ServiceReferenceBase&)
  * to obtain a service object for a service. ServiceObjects::GetService() will always
  * return an instance provided by a call to GetService(Module*, const ServiceRegistrationBase&)
  * and ModuleContext::GetService(const ServiceReferenceBase&) will always
  * return the module-scoped instance.
  * PrototypeServiceFactory objects are only used by the framework and are not made
  * available to other modules. The framework may concurrently call a PrototypeServiceFactory.
  *
  * @see ModuleContext::GetServiceObjects()
  * @see ServiceObjects
  */
 struct PrototypeServiceFactory : public ServiceFactory
 {
 
   /**
    * Returns a service object for a caller.
    *
    * The framework invokes this method for each caller requesting a service object using
    * ServiceObjects::GetService(). The factory can then return a specific service object for the caller.
    * The framework checks that the returned service object is valid. If the returned service
    * object is empty or does not contain entries for all the interfaces named when the service
    * was registered, a warning is issued and nullptr is returned to the caller. If this
    * method throws an exception, a warning is issued and nullptr is returned to the caller.
    *
    * @param module The module requesting the service.
    * @param registration The ServiceRegistrationBase object for the requested service.
    * @return A service object that must contain entries for all the interfaces named when
    *         the service was registered.
    *
    * @see ServiceObjects#GetService()
    * @see InterfaceMap
    */
   InterfaceMap GetService(Module* module, const ServiceRegistrationBase& registration) override = 0;
 
   /**
    * Releases a service object created for a caller.
    *
    * The framework invokes this method when a service has been released by a modules such as
    * by calling ServiceObjects::UngetService(). The service object may then be destroyed.
    * If this method throws an exception, a warning is issued.
    *
    * @param module The module releasing the service.
    * @param registration The ServiceRegistrationBase object for the service being released.
    * @param service The service object returned by a previous call to the GetService method.
    *
    * @see ServiceObjects::UngetService()
    */
   void UngetService(Module* module, const ServiceRegistrationBase& registration,
                             const InterfaceMap& service) override = 0;
 
 };
 
 US_END_NAMESPACE
 
 #endif // USPROTOTYPESERVICEFACTORY_H
diff --git a/Modules/CppMicroServices/core/include/usServiceEvent.h b/Modules/CppMicroServices/core/include/usServiceEvent.h
index 4243c12275..399928e5d4 100644
--- a/Modules/CppMicroServices/core/include/usServiceEvent.h
+++ b/Modules/CppMicroServices/core/include/usServiceEvent.h
@@ -1,188 +1,188 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEEVENT_H
 #define USSERVICEEVENT_H
 
 #ifdef REGISTERED
 #ifdef _WIN32
 #error The REGISTERED preprocessor define clashes with the ServiceEvent::REGISTERED\
  enum type. Try to reorder your includes, compile with WIN32_LEAN_AND_MEAN, or undef\
  the REGISTERED macro befor including this header.
 #else
 #error The REGISTERED preprocessor define clashes with the ServiceEvent::REGISTERED\
  enum type. Try to reorder your includes or undef the REGISTERED macro befor including\
  this header.
 #endif
 #endif
 
 #include "usSharedData.h"
 
 #include "usServiceReference.h"
 
 US_BEGIN_NAMESPACE
 
 class ServiceEventData;
 
 /**
  * \ingroup MicroServices
  *
  * An event from the Micro Services framework describing a service lifecycle change.
  * <p>
  * <code>ServiceEvent</code> objects are delivered to
  * listeners connected via ModuleContext::AddServiceListener() when a
  * change occurs in this service's lifecycle. A type code is used to identify
  * the event type for future extendability.
  */
 class US_Core_EXPORT ServiceEvent
 {
 
   SharedDataPointer<ServiceEventData> d;
 
 public:
 
   enum Type {
 
     /**
      * This service has been registered.
      * <p>
      * This event is delivered <strong>after</strong> the service
      * has been registered with the framework.
      *
      * @see ModuleContext#RegisterService()
      */
     REGISTERED = 0x00000001,
 
     /**
      * The properties of a registered service have been modified.
      * <p>
      * This event is delivered <strong>after</strong> the service
      * properties have been modified.
      *
      * @see ServiceRegistration#SetProperties
      */
     MODIFIED = 0x00000002,
 
     /**
      * This service is in the process of being unregistered.
      * <p>
      * This event is delivered <strong>before</strong> the service
      * has completed unregistering.
      *
      * <p>
      * If a module is using a service that is <code>UNREGISTERING</code>, the
      * module should release its use of the service when it receives this event.
      * If the module does not release its use of the service when it receives
      * this event, the framework will automatically release the module's use of
      * the service while completing the service unregistration operation.
      *
      * @see ServiceRegistration#Unregister
      * @see ModuleContext#UngetService
      */
     UNREGISTERING = 0x00000004,
 
     /**
      * The properties of a registered service have been modified and the new
      * properties no longer match the listener's filter.
      * <p>
      * This event is delivered <strong>after</strong> the service
      * properties have been modified. This event is only delivered to listeners
      * which were added with a non-empty filter where the filter
      * matched the service properties prior to the modification but the filter
      * does not match the modified service properties.
      *
      * @see ServiceRegistration#SetProperties
      */
     MODIFIED_ENDMATCH = 0x00000008
 
   };
 
   /**
    * Creates an invalid instance.
    */
   ServiceEvent();
 
   ~ServiceEvent();
 
   /**
    * Can be used to check if this ServiceEvent instance is valid,
    * or if it has been constructed using the default constructor.
    *
    * @return <code>true</code> if this event object is valid,
    *         <code>false</code> otherwise.
    */
   bool IsNull() const;
 
   /**
    * Creates a new service event object.
    *
    * @param type The event type.
    * @param reference A <code>ServiceReference</code> object to the service
    *        that had a lifecycle change.
    */
   ServiceEvent(Type type, const ServiceReferenceBase& reference);
 
   ServiceEvent(const ServiceEvent& other);
 
   ServiceEvent& operator=(const ServiceEvent& other);
 
   /**
    * Returns a reference to the service that had a change occur in its
    * lifecycle.
    * <p>
    * This reference is the source of the event.
    *
    * @return Reference to the service that had a lifecycle change.
    */
   ServiceReferenceU GetServiceReference() const;
 
   template<class S>
   ServiceReference<S> GetServiceReference(InterfaceType<S>) const
   {
     return GetServiceReference();
   }
 
   /**
    * Returns the type of event. The event type values are:
    * <ul>
    * <li>{@link #REGISTERED} </li>
    * <li>{@link #MODIFIED} </li>
    * <li>{@link #MODIFIED_ENDMATCH} </li>
    * <li>{@link #UNREGISTERING} </li>
    * </ul>
    *
    * @return Type of service lifecycle change.
    */
   Type GetType() const;
 
 };
 
 /**
  * \ingroup MicroServices
  * @{
  */
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, const ServiceEvent::Type& type);
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, const ServiceEvent& event);
 /** @}*/
 
 US_END_NAMESPACE
 
 #endif // USSERVICEEVENT_H
diff --git a/Modules/CppMicroServices/core/include/usServiceEventListenerHook.h b/Modules/CppMicroServices/core/include/usServiceEventListenerHook.h
index 949f6df8a8..54e909b6af 100644
--- a/Modules/CppMicroServices/core/include/usServiceEventListenerHook.h
+++ b/Modules/CppMicroServices/core/include/usServiceEventListenerHook.h
@@ -1,70 +1,70 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEEVENTLISTENERHOOK_H
 #define USSERVICEEVENTLISTENERHOOK_H
 
 #include "usServiceInterface.h"
 #include "usServiceListenerHook.h"
 #include "usShrinkableVector.h"
 #include "usShrinkableMap.h"
 
 US_BEGIN_NAMESPACE
 
 class ModuleContext;
 class ServiceEvent;
 
 /**
  * @ingroup MicroServices
  *
  * Service Event Listener Hook Service.
  *
  * <p>
  * Modules registering this service will be called during service
  * (register, modify, and unregister service) operations.
  *
  * @remarks Implementations of this interface are required to be thread-safe.
  */
 struct US_Core_EXPORT ServiceEventListenerHook
 {
   typedef ShrinkableMap<ModuleContext*, ShrinkableVector<ServiceListenerHook::ListenerInfo> > ShrinkableMapType;
 
   virtual ~ServiceEventListenerHook();
 
   /**
    * Event listener hook method. This method is called prior to service event
    * delivery when a publishing module registers, modifies or unregisters a
    * service. This method can filter the listeners which receive the event.
    *
    * @param event The service event to be delivered.
    * @param listeners A map of Module Contexts to a list of Listener
    *        Infos for the module's listeners to which the specified event will
    *        be delivered. The implementation of this method may remove module
    *        contexts from the map and listener infos from the list
    *        values to prevent the event from being delivered to the associated
    *        listeners.
    */
   virtual void Event(const ServiceEvent& event, ShrinkableMapType& listeners) = 0;
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICEEVENTLISTENERHOOK_H
diff --git a/Modules/CppMicroServices/core/include/usServiceException.h b/Modules/CppMicroServices/core/include/usServiceException.h
index 0004e25398..0f34b94f84 100644
--- a/Modules/CppMicroServices/core/include/usServiceException.h
+++ b/Modules/CppMicroServices/core/include/usServiceException.h
@@ -1,126 +1,126 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICEEXCEPTION_H
 #define USSERVICEEXCEPTION_H
 
 #include <stdexcept>
 
 #include <usCoreConfig.h>
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable:4275)
 #endif
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * A service exception used to indicate that a service problem occurred.
  *
  * <p>
  * A <code>ServiceException</code> object is created by the framework or
  * to denote an exception condition in the service. An enum
  * type is used to identify the exception type for future extendability.
  *
  * <p>
  * This exception conforms to the general purpose exception chaining mechanism.
  */
 class US_Core_EXPORT ServiceException : public std::runtime_error
 {
 public:
 
   enum Type {
     /**
      * No exception type is unspecified.
      */
     UNSPECIFIED = 0,
     /**
      * The service has been unregistered.
      */
     UNREGISTERED = 1,
     /**
      * The service factory produced an invalid service object.
      */
     FACTORY_ERROR = 2,
     /**
      * The service factory threw an exception.
      */
     FACTORY_EXCEPTION = 3,
     /**
      * An error occurred invoking a remote service.
      */
     REMOTE = 5,
     /**
      * The service factory resulted in a recursive call to itself for the
      * requesting module.
      */
     FACTORY_RECURSION = 6
   };
 
   /**
    * Creates a <code>ServiceException</code> with the specified message,
    * type and exception cause.
    *
    * @param msg The associated message.
    * @param type The type for this exception.
    */
   ServiceException(const std::string& msg, const Type& type = UNSPECIFIED);
 
   ServiceException(const ServiceException& o);
   ServiceException& operator=(const ServiceException& o);
 
   ~ServiceException() throw() override { }
 
   /**
    * Returns the type for this exception or <code>UNSPECIFIED</code> if the
    * type was unspecified or unknown.
    *
    * @return The type of this exception.
    */
   Type GetType() const;
 
 private:
 
   /**
    * Type of service exception.
    */
   Type type;
 
 };
 
 US_END_NAMESPACE
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
 /**
  * \ingroup MicroServices
  * @{
  */
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, const US_PREPEND_NAMESPACE(ServiceException)& exc);
 /** @}*/
 
 #endif // USSERVICEEXCEPTION_H
diff --git a/Modules/CppMicroServices/core/include/usServiceFactory.h b/Modules/CppMicroServices/core/include/usServiceFactory.h
index 906c457094..e201da0e18 100644
--- a/Modules/CppMicroServices/core/include/usServiceFactory.h
+++ b/Modules/CppMicroServices/core/include/usServiceFactory.h
@@ -1,119 +1,119 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEFACTORY_H
 #define USSERVICEFACTORY_H
 
 #include "usServiceInterface.h"
 #include "usServiceRegistration.h"
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * A factory for \link ServiceConstants::SCOPE_MODULE module scope\endlink services.
  * The factory can provide service objects unique to each module.
  *
  * <p>
  * When registering a service, a <code>ServiceFactory</code> object can be
  * used instead of a service object, so that the module developer can gain
  * control of the specific service object granted to a module that is using the
  * service.
  *
  * <p>
  * When this happens, the
  * <code>ModuleContext::GetService(const ServiceReference&)</code> method calls the
  * <code>ServiceFactory::GetService</code> method to create a service object
  * specifically for the requesting module. The service object returned by the
  * <code>ServiceFactory</code> is cached by the framework until the module
  * releases its use of the service.
  *
  * <p>
  * When the module's use count for the service equals zero (including the module
  * unloading or the service being unregistered), the
  * <code>ServiceFactory::UngetService</code> method is called.
  *
  * <p>
  * <code>ServiceFactory</code> objects are only used by the framework and are
  * not made available to other modules in the module environment. The framework
  * may concurrently call a <code>ServiceFactory</code>.
  *
  * @see ModuleContext#GetService
  * @see PrototypeServiceFactory
  * @remarks This class is thread safe.
  */
 class ServiceFactory
 {
 
 public:
 
   virtual ~ServiceFactory() {}
 
   /**
    * Creates a new service object.
    *
    * <p>
    * The Framework invokes this method the first time the specified
    * <code>module</code> requests a service object using the
    * <code>ModuleContext::GetService(const ServiceReferenceBase&)</code> method. The
    * service factory can then return a specific service object for each
    * module.
    *
    * <p>
    * The framework caches the value returned (unless the InterfaceMap is empty),
    * and will return the same service object on any future call to
    * <code>ModuleContext::GetService</code> for the same modules. This means the
    * framework does not allow this method to be concurrently called for the
    * same module.
    *
    * @param module The module using the service.
    * @param registration The <code>ServiceRegistrationBase</code> object for the
    *        service.
    * @return A service object that <strong>must</strong> contain entries for all
    *         the interfaces named when the service was registered.
    * @see ModuleContext#GetService
    * @see InterfaceMap
    */
   virtual InterfaceMap GetService(Module* module, const ServiceRegistrationBase& registration) = 0;
 
   /**
    * Releases a service object.
    *
    * <p>
    * The framework invokes this method when a service has been released by a
    * module. The service object may then be destroyed.
    *
    * @param module The Module releasing the service.
    * @param registration The <code>ServiceRegistration</code> object for the
    *        service.
    * @param service The service object returned by a previous call to the
    *        <code>ServiceFactory::GetService</code> method.
    * @see ModuleContext#UngetService
    * @see InterfaceMap
    */
   virtual void UngetService(Module* module, const ServiceRegistrationBase& registration,
                             const InterfaceMap& service) = 0;
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICEFACTORY_H
diff --git a/Modules/CppMicroServices/core/include/usServiceFindHook.h b/Modules/CppMicroServices/core/include/usServiceFindHook.h
index 5ffb9ec048..9e6e6ffde1 100644
--- a/Modules/CppMicroServices/core/include/usServiceFindHook.h
+++ b/Modules/CppMicroServices/core/include/usServiceFindHook.h
@@ -1,74 +1,74 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEFINDHOOK_H
 #define USSERVICEFINDHOOK_H
 
 #include "usServiceInterface.h"
 #include "usShrinkableVector.h"
 
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 class Module;
 class ModuleContext;
 class ServiceReferenceBase;
 
 /**
  * @ingroup MicroServices
  *
  * Service Find Hook Service.
  *
  * <p>
  * Modules registering this service will be called during service find
  * (get service references) operations.
  *
  * @remarks Implementations of this interface are required to be thread-safe.
  */
 struct US_Core_EXPORT ServiceFindHook
 {
 
   virtual ~ServiceFindHook();
 
   /**
    * Find hook method. This method is called during the service find operation
    * (for example, ModuleContext::GetServiceReferences<S>()). This method can
    * filter the result of the find operation.
    *
    * @param context The module context of the module performing the find
    *        operation.
    * @param name The class name of the services to find or an empty string to
    *        find all services.
    * @param filter The filter criteria of the services to find or an empty string
    *        for no filter criteria.
    * @param references A list of Service References to be returned as a result of the
    *        find operation. The implementation of this method may remove
    *        service references from the list to prevent the references from being
    *        returned to the module performing the find operation.
    */
   virtual void Find(const ModuleContext* context, const std::string& name,
                     const std::string& filter, ShrinkableVector<ServiceReferenceBase>& references) = 0;
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICEFINDHOOK_H
diff --git a/Modules/CppMicroServices/core/include/usServiceInterface.h b/Modules/CppMicroServices/core/include/usServiceInterface.h
index 66a2b4afe7..0c1927374a 100644
--- a/Modules/CppMicroServices/core/include/usServiceInterface.h
+++ b/Modules/CppMicroServices/core/include/usServiceInterface.h
@@ -1,343 +1,343 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICEINTERFACE_H
 #define USSERVICEINTERFACE_H
 
 #include <usGlobalConfig.h>
 #include <usServiceException.h>
 
 #include <map>
 #include <string>
 #include <typeinfo>
 
 US_BEGIN_NAMESPACE
 std::string GetDemangledName(const std::type_info& typeInfo);
 US_END_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * Returns a unique id for a given type. By default, the
  * demangled name of \c T is returned.
  *
  * This template method may be specialized directly or be
  * using the macro #US_DECLARE_SERVICE_INTERFACE to return
  * a custom id for each service interface.
  *
  * @tparam T The service interface type.
  * @return A unique id for the service interface type T.
  */
 template<class T> std::string us_service_interface_iid()
 {
   return US_PREPEND_NAMESPACE(GetDemangledName)(typeid(T));
 }
 
 /// \cond
 template<> inline std::string us_service_interface_iid<void>() { return std::string(); }
 /// \endcond
 
 
 /**
  * \ingroup MicroServices
  *
  * \brief Declare a service interface id.
  *
  * This macro associates the given identifier \e _service_interface_id (a string literal) to the
  * interface class called _service_interface_type. The Identifier must be unique. For example:
  *
  * \code
  * #include <usServiceInterface.h>
  *
  * struct ISomeInterace { ... };
  *
  * US_DECLARE_SERVICE_INTERFACE(ISomeInterface, "com.mycompany.service.ISomeInterface/1.0")
  * \endcode
  *
  * The usage of this macro is optional and the service interface id which is automatically
  * associated with any type is usually good enough (the demangled type name). However, care must
  * be taken if the default id is compared with a string literal hard-coding a service interface
  * id. E.g. the default id for templated types in the STL may differ between platforms. For
  * user-defined types and templates the ids are typically consistent, but platform specific
  * default template arguments will lead to different ids.
  *
  * This macro is normally used right after the class definition for _service_interface_type,
  * in a header file.
  *
  * If you want to use #US_DECLARE_SERVICE_INTERFACE with interface classes declared in a
  * namespace then you have to make sure the #US_DECLARE_SERVICE_INTERFACE macro call is not
  * inside a namespace though. For example:
  *
  * \code
  * #include <usServiceInterface.h>
  *
  * namespace Foo
  * {
  *   struct ISomeInterface { ... };
  * }
  *
  * US_DECLARE_SERVICE_INTERFACE(Foo::ISomeInterface, "com.mycompany.service.ISomeInterface/1.0")
  * \endcode
  *
  * @param _service_interface_type The service interface type.
  * @param _service_interface_id A string literal representing a globally unique identifier.
  */
 #define US_DECLARE_SERVICE_INTERFACE(_service_interface_type, _service_interface_id)               \
   template<> inline std::string us_service_interface_iid<_service_interface_type>()                \
   { return _service_interface_id; }                                                                \
 
 
 US_BEGIN_NAMESPACE
 
 class ServiceFactory;
 
 /**
  * @ingroup MicroServices
  *
  * A helper type used in several methods to get proper
  * method overload resolutions.
  */
 template<class Interface>
 struct InterfaceType {};
 
 /**
  * @ingroup MicroServices
  *
  * A map containing interfaces ids and their corresponding service object
  * pointers. InterfaceMap instances represent a complete service object
  * which implementes one or more service interfaces. For each implemented
  * service interface, there is an entry in the map with the key being
  * the service interface id and the value a pointer to the service
  * interface implementation.
  *
  * To create InterfaceMap instances, use the MakeInterfaceMap helper class.
  *
  * @note This is a low-level type and should only rarely be used.
  *
  * @see MakeInterfaceMap
  */
 typedef std::map<std::string, void*> InterfaceMap;
 
 
 template<class I>
 bool InsertInterfaceType(InterfaceMap& im, I* i)
 {
   if (us_service_interface_iid<I>().empty())
   {
     throw ServiceException(std::string("The interface class ") + typeid(I).name() +
                                 " uses an invalid id in its US_DECLARE_SERVICE_INTERFACE macro call.");
   }
   im.insert(std::make_pair(std::string(us_service_interface_iid<I>()),
                            static_cast<void*>(static_cast<I*>(i))));
   return true;
 }
 
 template<>
 inline bool InsertInterfaceType<void>(InterfaceMap&, void*)
 {
   return false;
 }
 
 
 /**
  * @ingroup MicroServices
  *
  * Helper class for constructing InterfaceMap instances based
  * on service implementations or service factories.
  *
  * Example usage:
  * \code
  * MyService service; // implementes I1 and I2
  * InterfaceMap im = MakeInterfaceMap<I1,I2>(&service);
  * \endcode
  *
  * The MakeInterfaceMap supports service implementations with
  * up to three service interfaces.
  *
  * @see InterfaceMap
  */
 template<class I1, class I2 = void, class I3 = void>
 struct MakeInterfaceMap
 {
   ServiceFactory* m_factory;
   I1* m_interface1;
   I2* m_interface2;
   I3* m_interface3;
 
   /**
    * Constructor taking a service implementation pointer.
    *
    * @param impl A service implementation pointer, which must
    *        be castable to a all specified service interfaces.
    */
   template<class Impl>
   MakeInterfaceMap(Impl* impl)
     : m_factory(nullptr)
     , m_interface1(static_cast<I1*>(impl))
     , m_interface2(static_cast<I2*>(impl))
     , m_interface3(static_cast<I3*>(impl))
   {}
 
   /**
    * Constructor taking a service factory.
    *
    * @param factory A service factory.
    */
   MakeInterfaceMap(ServiceFactory* factory)
     : m_factory(factory)
     , m_interface1(nullptr)
     , m_interface2(nullptr)
     , m_interface3(nullptr)
   {
     if (factory == nullptr)
     {
       throw ServiceException("The service factory argument must not be nullptr.");
     }
   }
 
   operator InterfaceMap ()
   {
     InterfaceMap sim;
     InsertInterfaceType(sim, m_interface1);
     InsertInterfaceType(sim, m_interface2);
     InsertInterfaceType(sim, m_interface3);
 
     if (m_factory)
     {
       sim.insert(std::make_pair(std::string("org.cppmicroservices.factory"),
                                 static_cast<void*>(m_factory)));
     }
 
     return sim;
   }
 };
 
 /// \cond
 template<class I1, class I2>
 struct MakeInterfaceMap<I1,I2,void>
 {
   ServiceFactory* m_factory;
   I1* m_interface1;
   I2* m_interface2;
 
   template<class Impl>
   MakeInterfaceMap(Impl* impl)
     : m_factory(nullptr)
     , m_interface1(static_cast<I1*>(impl))
     , m_interface2(static_cast<I2*>(impl))
   {}
 
   MakeInterfaceMap(ServiceFactory* factory)
     : m_factory(factory)
     , m_interface1(nullptr)
     , m_interface2(nullptr)
   {
     if (factory == nullptr)
     {
       throw ServiceException("The service factory argument must not be nullptr.");
     }
   }
 
   operator InterfaceMap ()
   {
     InterfaceMap sim;
     InsertInterfaceType(sim, m_interface1);
     InsertInterfaceType(sim, m_interface2);
 
     if (m_factory)
     {
       sim.insert(std::make_pair(std::string("org.cppmicroservices.factory"),
                                 static_cast<void*>(m_factory)));
     }
 
     return sim;
   }
 };
 
 template<class I1>
 struct MakeInterfaceMap<I1,void,void>
 {
   ServiceFactory* m_factory;
   I1* m_interface1;
 
   template<class Impl>
   MakeInterfaceMap(Impl* impl)
     : m_factory(nullptr)
     , m_interface1(static_cast<I1*>(impl))
   {}
 
   MakeInterfaceMap(ServiceFactory* factory)
     : m_factory(factory)
     , m_interface1(nullptr)
   {
     if (factory == nullptr)
     {
       throw ServiceException("The service factory argument must not be nullptr.");
     }
   }
 
   operator InterfaceMap ()
   {
     InterfaceMap sim;
     InsertInterfaceType(sim, m_interface1);
 
     if (m_factory)
     {
       sim.insert(std::make_pair(std::string("org.cppmicroservices.factory"),
                                 static_cast<void*>(m_factory)));
     }
 
     return sim;
   }
 };
 
 template<>
 struct MakeInterfaceMap<void,void,void>;
 /// \endcond
 
 /**
  * @ingroup MicroServices
  *
  * Extract a service interface pointer from a given InterfaceMap instance.
  *
  * @param map a InterfaceMap instance.
  * @return The service interface pointer for the service interface id of the
  *         \c I1 interface type or nullptr if \c map does not contain an entry
  *         for the given type.
  *
  * @see MakeInterfaceMap
  */
 template<class I1>
 I1* ExtractInterface(const InterfaceMap& map)
 {
   InterfaceMap::const_iterator iter = map.find(us_service_interface_iid<I1>());
   if (iter != map.end())
   {
     return reinterpret_cast<I1*>(iter->second);
   }
   return nullptr;
 }
 
 US_END_NAMESPACE
 
 
 #endif // USSERVICEINTERFACE_H
diff --git a/Modules/CppMicroServices/core/include/usServiceListenerHook.h b/Modules/CppMicroServices/core/include/usServiceListenerHook.h
index 599af5b196..7cdc2ceed7 100644
--- a/Modules/CppMicroServices/core/include/usServiceListenerHook.h
+++ b/Modules/CppMicroServices/core/include/usServiceListenerHook.h
@@ -1,174 +1,174 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICELISTENERHOOK_H
 #define USSERVICELISTENERHOOK_H
 
 #include "usServiceInterface.h"
 #include "usShrinkableVector.h"
 #include "usSharedData.h"
 
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 class ModuleContext;
 class ServiceListenerEntry;
 
 /**
  * @ingroup MicroServices
  *
  * Service Listener Hook Service.
  *
  * <p>
  * Modules registering this service will be called during service listener
  * addition and removal.
  *
  * @remarks Implementations of this interface are required to be thread-safe.
  */
 struct US_Core_EXPORT ServiceListenerHook
 {
 
   class ListenerInfoData;
 
   /**
    * Information about a Service Listener. This class describes the module
    * which added the Service Listener and the filter with which it was added.
    *
    * @remark This class is not intended to be implemented by clients.
    */
   struct US_Core_EXPORT ListenerInfo
   {
     ListenerInfo();
 
     ListenerInfo(const ListenerInfo& other);
 
     ~ListenerInfo();
 
     ListenerInfo& operator=(const ListenerInfo& other);
 
     /**
      * Can be used to check if this ListenerInfo instance is valid,
      * or if it has been constructed using the default constructor.
      *
      * @return <code>true</code> if this listener object is valid,
      *         <code>false</code> otherwise.
      */
     bool IsNull() const;
 
     /**
      * Return the context of the module which added the listener.
      *
      * @return The context of the module which added the listener.
      */
     ModuleContext* GetModuleContext() const;
 
     /**
      * Return the filter string with which the listener was added.
      *
      * @return The filter string with which the listener was added. This may
      *         be empty if the listener was added without a filter.
      */
     std::string GetFilter() const;
 
     /**
      * Return the state of the listener for this addition and removal life
      * cycle. Initially this method will return \c false indicating the
      * listener has been added but has not been removed. After the listener
      * has been removed, this method must always returns \c true.
      *
      * <p>
      * There is an extremely rare case in which removed notification to
      * {@link ServiceListenerHook}s can be made before added notification if two
      * threads are racing to add and remove the same service listener.
      * Because {@link ServiceListenerHook}s are called synchronously during service
      * listener addition and removal, the CppMicroServices library cannot guarantee
      * in-order delivery of added and removed notification for a given
      * service listener. This method can be used to detect this rare
      * occurrence.
      *
      * @return \c false if the listener has not been been removed,
      *         \c true otherwise.
      */
     bool IsRemoved() const;
 
     /**
      * Compares this \c ListenerInfo to another \c ListenerInfo.
      * Two {@code ListenerInfo}s are equal if they refer to the same
      * listener for a given addition and removal life cycle. If the same
      * listener is added again, it will have a different
      * \c ListenerInfo which is not equal to this \c ListenerInfo.
      *
      * @param other The object to compare against this \c ListenerInfo.
      * @return \c true if the other object is a \c ListenerInfo
      *         object and both objects refer to the same listener for a
      *         given addition and removal life cycle.
      */
     bool operator==(const ListenerInfo& other) const;
 
   private:
 
     friend class ServiceListenerEntry;
 
     US_HASH_FUNCTION_FRIEND(ServiceListenerHook::ListenerInfo);
 
     ListenerInfo(ListenerInfoData* data);
 
     ExplicitlySharedDataPointer<ListenerInfoData> d;
   };
 
   virtual ~ServiceListenerHook();
 
   /**
    * Added listeners hook method. This method is called to provide the hook
    * implementation with information on newly added service listeners. This
    * method will be called as service listeners are added while this hook is
    * registered. Also, immediately after registration of this hook, this
    * method will be called to provide the current collection of service
    * listeners which had been added prior to the hook being registered.
    *
    * @param listeners A collection of \c ListenerInfo objects for newly added
    *        service listeners which are now listening to service events.
    */
   virtual void Added(const std::vector<ListenerInfo>& listeners) = 0;
 
   /**
    * Removed listeners hook method. This method is called to provide the hook
    * implementation with information on newly removed service listeners. This
    * method will be called as service listeners are removed while this hook is
    * registered.
    *
    * @param listeners A collection of \c ListenerInfo objects for newly removed
    *        service listeners which are no longer listening to service events.
    */
   virtual void Removed(const std::vector<ListenerInfo>& listeners) = 0;
 
 };
 
 US_END_NAMESPACE
 
 US_HASH_FUNCTION_NAMESPACE_BEGIN
 US_HASH_FUNCTION_BEGIN(US_PREPEND_NAMESPACE(ServiceListenerHook::ListenerInfo))
   return US_HASH_FUNCTION(const US_PREPEND_NAMESPACE(ServiceListenerHook::ListenerInfoData)*, arg.d.Data());
 US_HASH_FUNCTION_END
 US_HASH_FUNCTION_NAMESPACE_END
 
 #endif // USSERVICELISTENERHOOK_H
diff --git a/Modules/CppMicroServices/core/include/usServiceObjects.h b/Modules/CppMicroServices/core/include/usServiceObjects.h
index 4a3bd1bcaf..07bfe4f230 100644
--- a/Modules/CppMicroServices/core/include/usServiceObjects.h
+++ b/Modules/CppMicroServices/core/include/usServiceObjects.h
@@ -1,259 +1,259 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEOBJECTS_H
 #define USSERVICEOBJECTS_H
 
 #include <usCoreExport.h>
 
 #include <usModuleContext.h>
 #include <usPrototypeServiceFactory.h>
 #include <usServiceReference.h>
 #include <usServiceProperties.h>
 
 US_BEGIN_NAMESPACE
 
 class ServiceObjectsBasePrivate;
 
 class US_Core_EXPORT ServiceObjectsBase
 {
 
 private:
 
   ServiceObjectsBasePrivate* d;
 
 protected:
 
   ServiceObjectsBase(ModuleContext* context, const ServiceReferenceBase& reference);
 
   ServiceObjectsBase(const ServiceObjectsBase& other);
 
   ~ServiceObjectsBase();
 
   ServiceObjectsBase& operator=(const ServiceObjectsBase& other);
 
   // Called by ServiceObjects<S> with S != void
   void* GetService() const;
 
   // Called by the ServiceObjects<void> specialization
   InterfaceMap GetServiceInterfaceMap() const;
 
   // Called by ServiceObjects<S> with S != void
   void UngetService(void* service);
 
   // Called by the ServiceObjects<void> specialization
   void UngetService(const InterfaceMap& interfaceMap);
 
   ServiceReferenceBase GetReference() const;
 
 };
 
 /**
  * @ingroup MicroServices
  *
  * Allows multiple service objects for a service to be obtained.
  *
  * For services with \link ServiceConstants::SCOPE_PROTOTYPE prototype\endlink scope,
  * multiple service objects for the service can be obtained. For services with
  * \link ServiceConstants::SCOPE_SINGLETON singleton\endlink or
  * \link ServiceConstants::SCOPE_MODULE module \endlink scope, only one, use-counted
  * service object is available. Any unreleased service objects obtained from this
  * ServiceObjects object are automatically released by the framework when the modules
  * associated with the ModuleContext used to create this ServiceObjects object is
  * stopped.
  *
  * @tparam S Type of Service.
  */
 template<class S>
 class ServiceObjects : private ServiceObjectsBase
 {
 
 public:
 
   /**
    * Returns a service object for the referenced service.
    *
    * This ServiceObjects object can be used to obtain multiple service objects for
    * the referenced service if the service has \link ServiceConstants::SCOPE_PROTOTYPE prototype\endlink
    * scope. If the referenced service has \link ServiceConstants::SCOPE_SINGLETON singleton\endlink
    * or \link ServiceConstants::SCOPE_MODULE module\endlink scope, this method
    * behaves the same as calling the ModuleContext::GetService(const ServiceReferenceBase&)
    * method for the referenced service. That is, only one, use-counted service object
    * is available from this ServiceObjects object.
    *
    * This method will always return \c nullptr when the referenced service has been unregistered.
    *
    * For a prototype scope service, the following steps are taken to get the service object:
    *
    * <ol>
    *   <li>If the referenced service has been unregistered, \c nullptr is returned.</li>
    *   <li>The PrototypeServiceFactory::GetService(Module*, const ServiceRegistrationBase&)
    *       method is called to create a service object for the caller.</li>
    *   <li>If the service object (an instance of InterfaceMap) returned by the
    *       PrototypeServiceFactory object is empty, does not contain all the interfaces
    *       named when the service was registered or the PrototypeServiceFactory object
    *       throws an exception, \c nullptr is returned and a warning message is issued.</li>
    *   <li>The service object is returned.</li>
    * </ol>
    *
    * @return A service object for the referenced service or \c nullptr if the service is not
    *         registered, the service object returned by a ServiceFactory does not contain
    *         all the classes under which it was registered or the ServiceFactory threw an
    *         exception.
    *
    * @throw std::logic_error If the ModuleContext used to create this ServiceObjects object
    *        is no longer valid.
    *
    * @see UngetService()
    */
   S* GetService() const
   {
     return reinterpret_cast<S*>(this->ServiceObjectsBase::GetService());
   }
 
   /**
    * Releases a service object for the referenced service.
    *
    * This ServiceObjects object can be used to obtain multiple service objects for
    * the referenced service if the service has \link ServiceConstants::SCOPE_PROTOTYPE prototype\endlink
    * scope. If the referenced service has \link ServiceConstants::SCOPE_SINGLETON singleton\endlink
    * or \link ServiceConstants::SCOPE_MODULE module\endlink scope, this method
    * behaves the same as calling the ModuleContext::UngetService(const ServiceReferenceBase&)
    * method for the referenced service. That is, only one, use-counted service object
    * is available from this ServiceObjects object.
    *
    * For a prototype scope service, the following steps are take to release the service object:
    *
    * <ol>
    *   <li>If the referenced service has been unregistered, this method returns without
    *       doing anything.</li>
    *   <li>The PrototypeServiceFactory::UngetService(Module*, const ServiceRegistrationBase&, const InterfaceMap&)
    *       method is called to release the specified service object.</li>
    *   <li>The specified service object must no longer be used and all references to it
    *       should be destroyed after calling this method.</li>
    * </ol>
    *
    * @param service A service object previously provided by this ServiceObjects object.
    *
    * @throw std::logic_error If the ModuleContext used to create this ServiceObjects
    *        object is no longer valid.
    * @throw std::invalid_argument If the specified service was not provided by this
    *        ServiceObjects object.
    *
    * @see GetService()
    */
   void UngetService(S* service)
   {
     this->ServiceObjectsBase::UngetService(service);
   }
 
   /**
    * Returns the ServiceReference for this ServiceObjects object.
    *
    * @return The ServiceReference for this ServiceObjects object.
    */
   ServiceReference<S> GetServiceReference() const
   {
     return this->ServiceObjectsBase::GetReference();
   }
 
 private:
 
   friend class ModuleContext;
 
   ServiceObjects(ModuleContext* context, const ServiceReference<S>& reference)
     : ServiceObjectsBase(context, reference)
   {}
 
 };
 
 /**
  * @ingroup MicroServices
  *
  * Allows multiple service objects for a service to be obtained.
  *
  * This is a specialization of the ServiceObjects class template for
  * "void", which maps to all service interface types.
  *
  * @see ServiceObjects
  */
 template<>
 class US_Core_EXPORT ServiceObjects<void> : private ServiceObjectsBase
 {
 
 public:
 
   /**
    * Returns a service object as a InterfaceMap instance for the referenced service.
    *
    * This method is the same as ServiceObjects<S>::GetService() except for the
    * return type. Further, this method will always return an empty InterfaeMap
    * object when the referenced service has been unregistered.
    *
    * @return A InterfaceMap object for the referenced service, which is empty if the
    *         service is not registered, the InterfaceMap returned by a ServiceFactory
    *         does not contain all the classes under which the service object was
    *         registered or the ServiceFactory threw an exception.
    *
    * @throw std::logic_error If the ModuleContext used to create this ServiceObjects object
    *        is no longer valid.
    *
    * @see ServiceObjects<S>::GetService()
    * @see UngetService()
    */
   InterfaceMap GetService() const;
 
   /**
    * Releases a service object for the referenced service.
    *
    * This method is the same as ServiceObjects<S>::UngetService() except for the
    * parameter type.
    *
    * @param service An InterfaceMap object previously provided by this ServiceObjects object.
    *
    * @throw std::logic_error If the ModuleContext used to create this ServiceObjects
    *        object is no longer valid.
    * @throw std::invalid_argument If the specified service was not provided by this
    *        ServiceObjects object.
    *
    * @see ServiceObjects<S>::UngetService()
    * @see GetService()
    */
   void UngetService(const InterfaceMap& service);
 
   /**
    * Returns the ServiceReference for this ServiceObjects object.
    *
    * @return The ServiceReference for this ServiceObjects object.
    */
   ServiceReferenceU GetServiceReference() const;
 
 private:
 
   friend class ModuleContext;
 
   ServiceObjects(ModuleContext* context, const ServiceReferenceU& reference);
 
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICEOBJECTS_H
diff --git a/Modules/CppMicroServices/core/include/usServiceProperties.h b/Modules/CppMicroServices/core/include/usServiceProperties.h
index c72545a836..83e5044174 100644
--- a/Modules/CppMicroServices/core/include/usServiceProperties.h
+++ b/Modules/CppMicroServices/core/include/usServiceProperties.h
@@ -1,138 +1,138 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef US_SERVICE_PROPERTIES_H
 #define US_SERVICE_PROPERTIES_H
 
 
 #include <usCoreConfig.h>
 
 #include <cctype>
 
 #include "usAny.h"
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * A hash table with std::string as the key type and Any as the value
  * type. It is typically used for passing service properties to
  * ModuleContext::RegisterService.
  */
 typedef US_UNORDERED_MAP_TYPE<std::string, Any> ServiceProperties;
 
 /**
  * \ingroup MicroServices
  */
 namespace ServiceConstants {
 
 /**
  * Service property identifying all of the class names under which a service
  * was registered in the framework. The value of this property must be of
  * type <code>std::vector&lt;std::string&gt;</code>.
  *
  * <p>
  * This property is set by the framework when a service is registered.
  */
 US_Core_EXPORT const std::string& OBJECTCLASS(); // = "objectclass"
 
 /**
  * Service property identifying a service's registration number. The value
  * of this property must be of type <code>long int</code>.
  *
  * <p>
  * The value of this property is assigned by the framework when a service is
  * registered. The framework assigns a unique value that is larger than all
  * previously assigned values since the framework was started. These values
  * are NOT persistent across restarts of the framework.
  */
 US_Core_EXPORT const std::string& SERVICE_ID(); // = "service.id"
 
 /**
  * Service property identifying a service's ranking number.
  *
  * <p>
  * This property may be supplied in the
  * <code>ServiceProperties</code> object passed to the
  * <code>ModuleContext::RegisterService</code> method. The value of this
  * property must be of type <code>int</code>.
  *
  * <p>
  * The service ranking is used by the framework to determine the <i>natural
  * order</i> of services, see ServiceReference::operator<(const ServiceReference&),
  * and the <i>default</i> service to be returned from a call to the
  * {@link ModuleContext::GetServiceReference} method.
  *
  * <p>
  * The default ranking is zero (0). A service with a ranking of
  * <code>std::numeric_limits<int>::max()</code> is very likely to be returned as the
  * default service, whereas a service with a ranking of
  * <code>std::numeric_limits<int>::min()</code> is very unlikely to be returned.
  *
  * <p>
  * If the supplied property value is not of type <code>int</code>, it is
  * deemed to have a ranking value of zero.
  */
 US_Core_EXPORT const std::string& SERVICE_RANKING(); // = "service.ranking"
 
 /**
  * Service property identifying a service's scope.
  * This property is set by the framework when a service is registered. If the
  * registered object implements PrototypeServiceFactory, then the value of this
  * service property will be SCOPE_PROTOTYPE(). Otherwise, if the registered
  * object implements ServiceFactory, then the value of this service property will
  * be SCOPE_MODULE(). Otherwise, the value of this service property will be
  * SCOPE_SINGLETON().
  */
 US_Core_EXPORT const std::string& SERVICE_SCOPE(); // = "service.scope"
 
 /**
  * Service scope is singleton. All modules using the service receive the same
  * service object.
  *
  * @see SERVICE_SCOPE()
  */
 US_Core_EXPORT const std::string& SCOPE_SINGLETON(); // = "singleton"
 
 /**
  * Service scope is module. Each module using the service receives a distinct
  * service object.
  *
  * @see SERVICE_SCOPE()
  */
 US_Core_EXPORT const std::string& SCOPE_MODULE(); // = "module"
 
 /**
  * Service scope is prototype. Each module using the service receives either
  * a distinct service object or can request multiple distinct service objects
  * via ServiceObjects.
  *
  * @see SERVICE_SCOPE()
  */
 US_Core_EXPORT const std::string& SCOPE_PROTOTYPE(); // = "prototype"
 
 }
 
 US_END_NAMESPACE
 
 #endif // US_SERVICE_PROPERTIES_H
diff --git a/Modules/CppMicroServices/core/include/usServiceReference.h b/Modules/CppMicroServices/core/include/usServiceReference.h
index 031f774d85..64cad4406a 100644
--- a/Modules/CppMicroServices/core/include/usServiceReference.h
+++ b/Modules/CppMicroServices/core/include/usServiceReference.h
@@ -1,142 +1,142 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEREFERENCE_H
 #define USSERVICEREFERENCE_H
 
 #include <usServiceInterface.h>
 #include <usServiceReferenceBase.h>
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * A reference to a service.
  *
  * <p>
  * The framework returns <code>ServiceReference</code> objects from the
  * <code>ModuleContext::GetServiceReference</code> and
  * <code>ModuleContext::GetServiceReferences</code> methods.
  * <p>
  * A <code>ServiceReference</code> object may be shared between modules and
  * can be used to examine the properties of the service and to get the service
  * object.
  * <p>
  * Every service registered in the framework has a unique
  * <code>ServiceRegistration</code> object and may have multiple, distinct
  * <code>ServiceReference</code> objects referring to it.
  * <code>ServiceReference</code> objects associated with a
  * <code>ServiceRegistration</code> are considered equal
  * (more specifically, their <code>operator==()</code>
  * method will return <code>true</code> when compared).
  * <p>
  * If the same service object is registered multiple times,
  * <code>ServiceReference</code> objects associated with different
  * <code>ServiceRegistration</code> objects are not equal.
  *
  * @tparam S The class type of the service interface
  * @see ModuleContext::GetServiceReference
  * @see ModuleContext::GetServiceReferences
  * @see ModuleContext::GetService
  * @remarks This class is thread safe.
  */
 template<class S>
 class ServiceReference : public ServiceReferenceBase {
 
 public:
 
   typedef S ServiceType;
 
   /**
    * Creates an invalid ServiceReference object. You can use
    * this object in boolean expressions and it will evaluate to
    * <code>false</code>.
    */
   ServiceReference() : ServiceReferenceBase()
   {
   }
 
   ServiceReference(const ServiceReferenceBase& base)
     : ServiceReferenceBase(base)
   {
     const std::string interfaceId(us_service_interface_iid<S>());
     if (GetInterfaceId() != interfaceId)
     {
       if (this->IsConvertibleTo(interfaceId))
       {
         this->SetInterfaceId(interfaceId);
       }
       else
       {
         this->operator =(0);
       }
     }
   }
 
   using ServiceReferenceBase::operator=;
 
 };
 
 /**
  * \cond
  *
  * Specialization for void, representing a generic service
  * reference not bound to any interface identifier.
  *
  */
 template<>
 class ServiceReference<void> : public ServiceReferenceBase
 {
 
 public:
 
   /**
    * Creates an invalid ServiceReference object. You can use
    * this object in boolean expressions and it will evaluate to
    * <code>false</code>.
    */
   ServiceReference() : ServiceReferenceBase()
   {
   }
 
   ServiceReference(const ServiceReferenceBase& base)
     : ServiceReferenceBase(base)
   {
   }
 
   using ServiceReferenceBase::operator=;
 
   typedef void ServiceType;
 };
 /// \endcond
 
 /**
  * \ingroup MicroServices
  *
  * A service reference of unknown type, which is not bound to any
  * interface identifier.
  */
 typedef ServiceReference<void> ServiceReferenceU;
 
 US_END_NAMESPACE
 
 #endif // USSERVICEREFERENCE_H
diff --git a/Modules/CppMicroServices/core/include/usServiceReferenceBase.h b/Modules/CppMicroServices/core/include/usServiceReferenceBase.h
index 69b78b5c08..7ce3d84636 100644
--- a/Modules/CppMicroServices/core/include/usServiceReferenceBase.h
+++ b/Modules/CppMicroServices/core/include/usServiceReferenceBase.h
@@ -1,234 +1,234 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEREFERENCEBASE_H
 #define USSERVICEREFERENCEBASE_H
 
 #include <usAny.h>
 
 US_MSVC_PUSH_DISABLE_WARNING(4396)
 
 US_BEGIN_NAMESPACE
 
 class Module;
 class ServiceRegistrationBasePrivate;
 class ServiceReferenceBasePrivate;
 
 /**
  * \ingroup MicroServices
  *
  * A reference to a service.
  *
  * \note This class is provided as public API for low-level service queries only.
  *       In almost all cases you should use the template ServiceReference instead.
  */
 class US_Core_EXPORT ServiceReferenceBase {
 
 private:
 
   typedef ServiceReferenceBasePrivate* ServiceReferenceBase::*bool_type;
 
 public:
 
   ServiceReferenceBase(const ServiceReferenceBase& ref);
 
   /**
    * Converts this ServiceReferenceBase instance into a boolean
    * expression. If this instance was default constructed or
    * the service it references has been unregistered, the conversion
    * returns <code>false</code>, otherwise it returns <code>true</code>.
    */
   operator bool_type() const;
 
   /**
    * Releases any resources held or locked by this
    * <code>ServiceReferenceBase</code> and renders it invalid.
    */
   ServiceReferenceBase& operator=(int null);
 
   ~ServiceReferenceBase();
 
   /**
    * Returns the property value to which the specified property key is mapped
    * in the properties <code>ServiceProperties</code> object of the service
    * referenced by this <code>ServiceReferenceBase</code> object.
    *
    * <p>
    * Property keys are case-insensitive.
    *
    * <p>
    * This method continues to return property values after the service has
    * been unregistered. This is so references to unregistered services can
    * still be interrogated.
    *
    * @param key The property key.
    * @return The property value to which the key is mapped; an invalid Any
    *         if there is no property named after the key.
    */
   Any GetProperty(const std::string& key) const;
 
   /**
    * Returns a list of the keys in the <code>ServiceProperties</code>
    * object of the service referenced by this <code>ServiceReferenceBase</code>
    * object.
    *
    * <p>
    * This method will continue to return the keys after the service has been
    * unregistered. This is so references to unregistered services can
    * still be interrogated.
    *
    * @param keys A vector being filled with the property keys.
    */
   void GetPropertyKeys(std::vector<std::string>& keys) const;
 
   /**
    * Returns the module that registered the service referenced by this
    * <code>ServiceReferenceBase</code> object.
    *
    * <p>
    * This method must return <code>0</code> when the service has been
    * unregistered. This can be used to determine if the service has been
    * unregistered.
    *
    * @return The module that registered the service referenced by this
    *         <code>ServiceReferenceBase</code> object; <code>0</code> if that
    *         service has already been unregistered.
    * @see ModuleContext::RegisterService(const InterfaceMap&, const ServiceProperties&)
    */
   Module* GetModule() const;
 
   /**
    * Returns the modules that are using the service referenced by this
    * <code>ServiceReferenceBase</code> object. Specifically, this method returns
    * the modules whose usage count for that service is greater than zero.
    *
    * @param modules A list of modules whose usage count for the service referenced
    *         by this <code>ServiceReferenceBase</code> object is greater than
    *         zero.
    */
   void GetUsingModules(std::vector<Module*>& modules) const;
 
   /**
    * Returns the interface identifier this ServiceReferenceBase object
    * is bound to.
    *
    * A default constructed ServiceReferenceBase object is not bound to
    * any interface identifier and calling this method will return an
    * empty string.
    *
    * @return The interface identifier for this ServiceReferenceBase object.
    */
   std::string GetInterfaceId() const;
 
   /**
    * Checks wether this ServiceReferenceBase object can be converted to
    * another ServiceReferenceBase object, which will be bound to the
    * given interface identifier.
    *
    * ServiceReferenceBase objects can be converted if the underlying service
    * implementation was registered under multiple service interfaces.
    *
    * @param interfaceid
    * @return \c true if this ServiceReferenceBase object can be converted,
    *         \c false otherwise.
    */
   bool IsConvertibleTo(const std::string& interfaceid) const;
 
   /**
    * Compares this <code>ServiceReferenceBase</code> with the specified
    * <code>ServiceReferenceBase</code> for order.
    *
    * <p>
    * If this <code>ServiceReferenceBase</code> and the specified
    * <code>ServiceReferenceBase</code> have the same \link ServiceConstants::SERVICE_ID()
    * service id\endlink they are equal. This <code>ServiceReferenceBase</code> is less
    * than the specified <code>ServiceReferenceBase</code> if it has a lower
    * {@link ServiceConstants::SERVICE_RANKING service ranking} and greater if it has a
    * higher service ranking. Otherwise, if this <code>ServiceReferenceBase</code>
    * and the specified <code>ServiceReferenceBase</code> have the same
    * {@link ServiceConstants::SERVICE_RANKING service ranking}, this
    * <code>ServiceReferenceBase</code> is less than the specified
    * <code>ServiceReferenceBase</code> if it has a higher
    * {@link ServiceConstants::SERVICE_ID service id} and greater if it has a lower
    * service id.
    *
    * @param reference The <code>ServiceReferenceBase</code> to be compared.
    * @return Returns a false or true if this
    *         <code>ServiceReferenceBase</code> is less than or greater
    *         than the specified <code>ServiceReferenceBase</code>.
    */
   bool operator<(const ServiceReferenceBase& reference) const;
 
   bool operator==(const ServiceReferenceBase& reference) const;
 
   ServiceReferenceBase& operator=(const ServiceReferenceBase& reference);
 
 private:
 
   friend class ModulePrivate;
   friend class ModuleContext;
   friend class ModuleHooks;
   friend class ServiceHooks;
   friend class ServiceObjectsBase;
   friend class ServiceObjectsBasePrivate;
   friend class ServiceRegistrationBase;
   friend class ServiceRegistrationBasePrivate;
   friend class ServiceListeners;
   friend class ServiceRegistry;
   friend class LDAPFilter;
 
   template<class S> friend class ServiceReference;
 
   US_HASH_FUNCTION_FRIEND(ServiceReferenceBase);
 
   std::size_t Hash() const;
 
   /**
    * Creates an invalid ServiceReferenceBase object. You can use
    * this object in boolean expressions and it will evaluate to
    * <code>false</code>.
    */
   ServiceReferenceBase();
 
   ServiceReferenceBase(ServiceRegistrationBasePrivate* reg);
 
   void SetInterfaceId(const std::string& interfaceId);
 
   ServiceReferenceBasePrivate* d;
 
 };
 
 US_END_NAMESPACE
 
 US_MSVC_POP_WARNING
 
 /**
  * \ingroup MicroServices
  */
 US_Core_EXPORT std::ostream& operator<<(std::ostream& os, const US_PREPEND_NAMESPACE(ServiceReferenceBase)& serviceRef);
 
 US_HASH_FUNCTION_NAMESPACE_BEGIN
 US_HASH_FUNCTION_BEGIN(US_PREPEND_NAMESPACE(ServiceReferenceBase))
   return arg.Hash();
 US_HASH_FUNCTION_END
 US_HASH_FUNCTION_NAMESPACE_END
 
 #endif // USSERVICEREFERENCEBASE_H
diff --git a/Modules/CppMicroServices/core/include/usServiceRegistration.h b/Modules/CppMicroServices/core/include/usServiceRegistration.h
index 34be9ee3dd..8c925bd588 100644
--- a/Modules/CppMicroServices/core/include/usServiceRegistration.h
+++ b/Modules/CppMicroServices/core/include/usServiceRegistration.h
@@ -1,203 +1,203 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEREGISTRATION_H
 #define USSERVICEREGISTRATION_H
 
 #include "usServiceRegistrationBase.h"
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * A registered service.
  *
  * <p>
  * The framework returns a <code>ServiceRegistration</code> object when a
  * <code>ModuleContext#RegisterService()</code> method invocation is successful.
  * The <code>ServiceRegistration</code> object is for the private use of the
  * registering module and should not be shared with other modules.
  * <p>
  * The <code>ServiceRegistration</code> object may be used to update the
  * properties of the service or to unregister the service.
  *
  * @tparam S Class tyoe of the service interface
  * @see ModuleContext#RegisterService()
  * @remarks This class is thread safe.
  */
 template<class I1, class I2 = void, class I3 = void>
 class ServiceRegistration : public ServiceRegistrationBase
 {
 
 public:
 
   /**
    * Creates an invalid ServiceRegistration object. You can use
    * this object in boolean expressions and it will evaluate to
    * <code>false</code>.
    */
   ServiceRegistration() : ServiceRegistrationBase()
   {
   }
 
   ///@{
   /**
    * Returns a <code>ServiceReference</code> object for a service being
    * registered.
    * <p>
    * The <code>ServiceReference</code> object may be shared with other
    * modules.
    *
    * @throws std::logic_error If this
    *         <code>ServiceRegistration</code> object has already been
    *         unregistered or if it is invalid.
    * @return <code>ServiceReference</code> object.
    */
   ServiceReference<I1> GetReference(InterfaceType<I1>) const
   {
     return this->ServiceRegistrationBase::GetReference(us_service_interface_iid<I1>());
   }
   ServiceReference<I2> GetReference(InterfaceType<I2>) const
   {
     return this->ServiceRegistrationBase::GetReference(us_service_interface_iid<I2>());
   }
   ServiceReference<I3> GetReference(InterfaceType<I3>) const
   {
     return this->ServiceRegistrationBase::GetReference(us_service_interface_iid<I3>());
   }
   ///@}
 
   using ServiceRegistrationBase::operator=;
 
 
 private:
 
   friend class ModuleContext;
 
   ServiceRegistration(const ServiceRegistrationBase& base)
     : ServiceRegistrationBase(base)
   {
   }
 
 };
 
 /// \cond
 template<class I1, class I2>
 class ServiceRegistration<I1, I2, void> : public ServiceRegistrationBase
 {
 
 public:
 
   ServiceRegistration() : ServiceRegistrationBase()
   {
   }
 
   ServiceReference<I1> GetReference(InterfaceType<I1>) const
   {
     return ServiceReference<I1>(this->ServiceRegistrationBase::GetReference(us_service_interface_iid<I1>()));
   }
 
   ServiceReference<I2> GetReference(InterfaceType<I2>) const
   {
     return ServiceReference<I2>(this->ServiceRegistrationBase::GetReference(us_service_interface_iid<I2>()));
   }
 
   using ServiceRegistrationBase::operator=;
 
 
 private:
 
   friend class ModuleContext;
 
   ServiceRegistration(const ServiceRegistrationBase& base)
     : ServiceRegistrationBase(base)
   {
   }
 
 };
 
 template<class I1>
 class ServiceRegistration<I1, void, void> : public ServiceRegistrationBase
 {
 
 public:
 
   ServiceRegistration() : ServiceRegistrationBase()
   {
   }
 
   ServiceReference<I1> GetReference() const
   {
     return this->GetReference(InterfaceType<I1>());
   }
 
   ServiceReference<I1> GetReference(InterfaceType<I1>) const
   {
     return ServiceReference<I1>(this->ServiceRegistrationBase::GetReference(us_service_interface_iid<I1>()));
   }
 
   using ServiceRegistrationBase::operator=;
 
 private:
 
   friend class ModuleContext;
 
   ServiceRegistration(const ServiceRegistrationBase& base)
     : ServiceRegistrationBase(base)
   {
   }
 
 };
 
 template<>
 class ServiceRegistration<void, void, void> : public ServiceRegistrationBase
 {
 public:
 
   /**
    * Creates an invalid ServiceReference object. You can use
    * this object in boolean expressions and it will evaluate to
    * <code>false</code>.
    */
   ServiceRegistration() : ServiceRegistrationBase()
   {
   }
 
   ServiceRegistration(const ServiceRegistrationBase& base)
     : ServiceRegistrationBase(base)
   {
   }
 
   using ServiceRegistrationBase::operator=;
 };
 /// \endcond
 
 /**
  * \ingroup MicroServices
  *
  * A service registration object of unknown type.
  */
 typedef ServiceRegistration<void> ServiceRegistrationU;
 
 US_END_NAMESPACE
 
 #endif // USSERVICEREGISTRATION_H
diff --git a/Modules/CppMicroServices/core/include/usServiceRegistrationBase.h b/Modules/CppMicroServices/core/include/usServiceRegistrationBase.h
index e6c5072ba4..1577aac8a1 100644
--- a/Modules/CppMicroServices/core/include/usServiceRegistrationBase.h
+++ b/Modules/CppMicroServices/core/include/usServiceRegistrationBase.h
@@ -1,223 +1,223 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEREGISTRATIONBASE_H
 #define USSERVICEREGISTRATIONBASE_H
 
 #include "usServiceProperties.h"
 #include "usServiceReference.h"
 
 US_MSVC_PUSH_DISABLE_WARNING(4396)
 
 US_BEGIN_NAMESPACE
 
 class ModulePrivate;
 class ServiceRegistrationBasePrivate;
 class ServicePropertiesImpl;
 
 /**
  * \ingroup MicroServices
  *
  * A registered service.
  *
  * <p>
  * The framework returns a <code>ServiceRegistrationBase</code> object when a
  * <code>ModuleContext#RegisterService()</code> method invocation is successful.
  * The <code>ServiceRegistrationBase</code> object is for the private use of the
  * registering module and should not be shared with other modules.
  * <p>
  * The <code>ServiceRegistrationBase</code> object may be used to update the
  * properties of the service or to unregister the service.
  *
  * \note This class is provided as public API for low-level service management only.
  *       In almost all cases you should use the template ServiceRegistration instead.
  *
  * @see ModuleContext#RegisterService()
  * @remarks This class is thread safe.
  */
 class US_Core_EXPORT ServiceRegistrationBase
 {
 
 private:
 
   typedef ServiceRegistrationBasePrivate* ServiceRegistrationBase::*bool_type;
 
 public:
 
   ServiceRegistrationBase(const ServiceRegistrationBase& reg);
 
   /**
    * A boolean conversion operator converting this ServiceRegistrationBase object
    * to \c true if it is valid and to \c false otherwise. A SeriveRegistration
    * object is invalid if it was default-constructed or was invalidated by
    * assigning 0 to it.
    *
    * \see operator=(int)
    *
    * \return \c true if this ServiceRegistrationBase object is valid, \c false
    *         otherwise.
    */
   operator bool_type() const;
 
   /**
    * Releases any resources held or locked by this
    * <code>ServiceRegistrationBase</code> and renders it invalid.
    *
    * \return This ServiceRegistrationBase object.
    */
   ServiceRegistrationBase& operator=(int null);
 
   ~ServiceRegistrationBase();
 
   /**
    * Returns a <code>ServiceReference</code> object for a service being
    * registered.
    * <p>
    * The <code>ServiceReference</code> object may be shared with other
    * modules.
    *
    * @throws std::logic_error If this
    *         <code>ServiceRegistrationBase</code> object has already been
    *         unregistered or if it is invalid.
    * @return <code>ServiceReference</code> object.
    */
   ServiceReferenceBase GetReference(const std::string& interfaceId = std::string()) const;
 
   /**
    * Updates the properties associated with a service.
    *
    * <p>
    * The ServiceConstants#OBJECTCLASS and ServiceConstants#SERVICE_ID keys
    * cannot be modified by this method. These values are set by the framework
    * when the service is registered in the environment.
    *
    * <p>
    * The following steps are taken to modify service properties:
    * <ol>
    * <li>The service's properties are replaced with the provided properties.
    * <li>A service event of type ServiceEvent#MODIFIED is fired.
    * </ol>
    *
    * @param properties The properties for this service. See {@link ServiceProperties}
    *        for a list of standard service property keys. Changes should not
    *        be made to this object after calling this method. To update the
    *        service's properties this method should be called again.
    *
    * @throws std::logic_error If this <code>ServiceRegistrationBase</code>
    *         object has already been unregistered or if it is invalid.
    * @throws std::invalid_argument If <code>properties</code> contains
    *         case variants of the same key name.
    */
   void SetProperties(const ServiceProperties& properties);
 
   /**
    * Unregisters a service. Remove a <code>ServiceRegistrationBase</code> object
    * from the framework service registry. All <code>ServiceRegistrationBase</code>
    * objects associated with this <code>ServiceRegistrationBase</code> object
    * can no longer be used to interact with the service once unregistration is
    * complete.
    *
    * <p>
    * The following steps are taken to unregister a service:
    * <ol>
    * <li>The service is removed from the framework service registry so that
    * it can no longer be obtained.
    * <li>A service event of type ServiceEvent#UNREGISTERING is fired
    * so that modules using this service can release their use of the service.
    * Once delivery of the service event is complete, the
    * <code>ServiceRegistrationBase</code> objects for the service may no longer be
    * used to get a service object for the service.
    * <li>For each module whose use count for this service is greater than
    * zero: <br>
    * The module's use count for this service is set to zero. <br>
    * If the service was registered with a ServiceFactory object, the
    * <code>ServiceFactory#UngetService</code> method is called to release
    * the service object for the module.
    * </ol>
    *
    * @throws std::logic_error If this
    *         <code>ServiceRegistrationBase</code> object has already been
    *         unregistered or if it is invalid.
    * @see ModuleContext#UngetService
    * @see ServiceFactory#UngetService
    */
   void Unregister();
 
   /**
    * Compare two ServiceRegistrationBase objects.
    *
    * If both ServiceRegistrationBase objects are valid, the comparison is done
    * using the underlying ServiceReference object. Otherwise, this ServiceRegistrationBase
    * object is less than the other object if and only if this object is invalid and
    * the other object is valid.
    *
    * @param o The ServiceRegistrationBase object to compare with.
    * @return \c true if this ServiceRegistrationBase object is less than the other object.
    */
   bool operator<(const ServiceRegistrationBase& o) const;
 
   bool operator==(const ServiceRegistrationBase& registration) const;
 
   ServiceRegistrationBase& operator=(const ServiceRegistrationBase& registration);
 
 
 private:
 
   friend class ServiceRegistry;
   friend class ServiceReferenceBasePrivate;
 
   template<class I1, class I2, class I3> friend class ServiceRegistration;
 
   US_HASH_FUNCTION_FRIEND(ServiceRegistrationBase);
 
   /**
    * Creates an invalid ServiceRegistrationBase object. You can use
    * this object in boolean expressions and it will evaluate to
    * <code>false</code>.
    */
   ServiceRegistrationBase();
 
   ServiceRegistrationBase(ServiceRegistrationBasePrivate* registrationPrivate);
 
   ServiceRegistrationBase(ModulePrivate* module, const InterfaceMap& service,
                           const ServicePropertiesImpl& props);
 
   ServiceRegistrationBasePrivate* d;
 
 };
 
 US_END_NAMESPACE
 
 US_MSVC_POP_WARNING
 
 US_HASH_FUNCTION_NAMESPACE_BEGIN
 US_HASH_FUNCTION_BEGIN(US_PREPEND_NAMESPACE(ServiceRegistrationBase))
   return US_HASH_FUNCTION(US_PREPEND_NAMESPACE(ServiceRegistrationBasePrivate)*, arg.d);
 US_HASH_FUNCTION_END
 US_HASH_FUNCTION_NAMESPACE_END
 
 
 inline std::ostream& operator<<(std::ostream& os, const US_PREPEND_NAMESPACE(ServiceRegistrationBase)& /*reg*/)
 {
   return os << "US_PREPEND_NAMESPACE(ServiceRegistrationBase) object";
 }
 
 #endif // USSERVICEREGISTRATIONBASE_H
diff --git a/Modules/CppMicroServices/core/include/usServiceTracker.h b/Modules/CppMicroServices/core/include/usServiceTracker.h
index 49a309fd22..abff1471e6 100644
--- a/Modules/CppMicroServices/core/include/usServiceTracker.h
+++ b/Modules/CppMicroServices/core/include/usServiceTracker.h
@@ -1,597 +1,597 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICETRACKER_H
 #define USSERVICETRACKER_H
 
 #include <map>
 
 #include "usServiceReference.h"
 #include "usServiceTrackerCustomizer.h"
 #include "usLDAPFilter.h"
 
 US_BEGIN_NAMESPACE
 
 template<class S, class T> class TrackedService;
 template<class S, class T> class ServiceTrackerPrivate;
 class ModuleContext;
 
 /**
  * \ingroup MicroServices
  *
  * A base class template for type traits for objects tracked by a
  * ServiceTracker instance. It provides the \c TrackedType typedef
  * and two dummy method definitions.
  *
  * Tracked type traits (TTT) classes must additionally provide the
  * following methods:
  *
  * <ul>
  *   <li><em>static bool IsValid(const TrackedType& t)</em> Returns \c true if \c t is a valid object, \c false otherwise.</li>
  *   <li><em>static void Dispose(TrackedType& t)</em> Clears any resources held by the tracked object \c t.</li>
  *   <li><em>static TrackedType DefaultValue()</em> Returns the default value for newly created tracked objects.</li>
  * </ul>
  *
  * @tparam T The type of the tracked object.
  * @tparam TTT The tracked type traits class deriving from this class.
  *
  * @see ServiceTracker
  */
 template<class T, class TTT>
 struct TrackedTypeTraitsBase
 {
   typedef T TrackedType;
 
   // Needed for S == void
   static TrackedType ConvertToTrackedType(const InterfaceMap&)
   {
     throw std::runtime_error("A custom ServiceTrackerCustomizer instance is required for custom tracked objects.");
     //return TTT::DefaultValue();
   }
 
   // Needed for S != void
   static TrackedType ConvertToTrackedType(void*)
   {
     throw std::runtime_error("A custom ServiceTrackerCustomizer instance is required for custom tracked objects.");
     //return TTT::DefaultValue();
   }
 };
 
 /// \cond
 template<class S, class T>
 struct TrackedTypeTraits;
 /// \endcond
 
 /**
  * \ingroup MicroServices
  *
  * Default type traits for custom tracked objects of pointer type.
  *
  * Use this tracked type traits template for custom tracked objects of
  * pointer type with the ServiceTracker class.
  *
  * @tparam S The type of the service being tracked.
  * @tparam T The type of the tracked object.
  */
 template<class S, class T>
 struct TrackedTypeTraits<S,T*> : public TrackedTypeTraitsBase<T*,TrackedTypeTraits<S,T*> >
 {
   typedef T* TrackedType;
 
   static bool IsValid(const TrackedType& t)
   {
     return t != nullptr;
   }
 
   static TrackedType DefaultValue()
   {
     return nullptr;
   }
 
   static void Dispose(TrackedType& t)
   {
     t = nullptr;
   }
 };
 
 /// \cond
 template<class S>
 struct TrackedTypeTraits<S,S*>
 {
   typedef S* TrackedType;
 
   static bool IsValid(const TrackedType& t)
   {
     return t != nullptr;
   }
 
   static TrackedType DefaultValue()
   {
     return nullptr;
   }
 
   static void Dispose(TrackedType& t)
   {
     t = nullptr;
   }
 
   static TrackedType ConvertToTrackedType(S* s)
   {
     return s;
   }
 };
 /// \endcond
 
 /// \cond
 /*
  * This specialization is "special" because the tracked type is not
  * void* (as specified in the second template parameter) but InterfaceMap.
  * This is in line with the ModuleContext::GetService(...) overloads to
  * return either S* or InterfaceMap dependening on the template parameter.
  */
 template<>
 struct TrackedTypeTraits<void,void*>
 {
   typedef InterfaceMap TrackedType;
 
   static bool IsValid(const TrackedType& t)
   {
     return !t.empty();
   }
 
   static TrackedType DefaultValue()
   {
     return TrackedType();
   }
 
   static void Dispose(TrackedType& t)
   {
     t.clear();
   }
 
   static TrackedType ConvertToTrackedType(const InterfaceMap& im)
   {
     return im;
   }
 };
 /// \endcond
 
 /**
  * \ingroup MicroServices
  *
  * The <code>ServiceTracker</code> class simplifies using services from the
  * framework's service registry.
  * <p>
  * A <code>ServiceTracker</code> object is constructed with search criteria and
  * a <code>ServiceTrackerCustomizer</code> object. A <code>ServiceTracker</code>
  * can use a <code>ServiceTrackerCustomizer</code> to customize the service
  * objects to be tracked. The <code>ServiceTracker</code> can then be opened to
  * begin tracking all services in the framework's service registry that match
  * the specified search criteria. The <code>ServiceTracker</code> correctly
  * handles all of the details of listening to <code>ServiceEvent</code>s and
  * getting and ungetting services.
  * <p>
  * The <code>GetServiceReferences</code> method can be called to get references
  * to the services being tracked. The <code>GetService</code> and
  * <code>GetServices</code> methods can be called to get the service objects for
  * the tracked service.
  *
  * \note The <code>ServiceTracker</code> class is thread-safe. It does not call a
  *       <code>ServiceTrackerCustomizer</code> while holding any locks.
  *       <code>ServiceTrackerCustomizer</code> implementations must also be
  *       thread-safe.
  *
  * Customization of the services to be tracked requires a custom tracked type traits
  * class if the custom tracked type is not a pointer type. To customize a tracked
  * service using a custom type with value-semantics like
  * \snippet uServices-servicetracker/main.cpp tt
  * the custom tracked type traits class should look like this:
  * \snippet uServices-servicetracker/main.cpp ttt
  *
  * For a custom tracked type, a ServiceTrackerCustomizer is required, which knows
  * how to associate the tracked service with the custom tracked type:
  * \snippet uServices-servicetracker/main.cpp customizer
  * The custom tracking type traits class and customizer can now be used to instantiate
  * a ServiceTracker:
  * \snippet uServices-servicetracker/main.cpp tracker
  *
  * If the custom tracked type is a pointer type, a suitable tracked type traits
  * template is provided by the framework and only a ServiceTrackerCustomizer needs
  * to be provided:
  * \snippet uServices-servicetracker/main.cpp tracker2
  *
  *
  * @tparam S The type of the service being tracked. The type S* must be an
  *         assignable datatype.
  * @tparam TTT Type traits of the tracked object. The type traits class provides
  *         information about the customized service object, see TrackedTypeTraitsBase.
  *
  * @remarks This class is thread safe.
  */
 template<class S, class TTT = TrackedTypeTraits<S,S*> >
 class ServiceTracker : protected ServiceTrackerCustomizer<S,typename TTT::TrackedType>
 {
 public:
 
   /// The type of the service being tracked
   typedef S ServiceType;
   /// The type of the tracked object
   typedef typename TTT::TrackedType T;
 
   typedef ServiceReference<S> ServiceReferenceType;
 
   typedef std::map<ServiceReference<S>,T> TrackingMap;
 
   ~ServiceTracker() override;
 
   /**
    * Create a <code>ServiceTracker</code> on the specified
    * <code>ServiceReference</code>.
    *
    * <p>
    * The service referenced by the specified <code>ServiceReference</code>
    * will be tracked by this <code>ServiceTracker</code>.
    *
    * @param context The <code>ModuleContext</code> against which the tracking
    *        is done.
    * @param reference The <code>ServiceReference</code> for the service to be
    *        tracked.
    * @param customizer The customizer object to call when services are added,
    *        modified, or removed in this <code>ServiceTracker</code>. If
    *        customizer is <code>null</code>, then this
    *        <code>ServiceTracker</code> will be used as the
    *        <code>ServiceTrackerCustomizer</code> and this
    *        <code>ServiceTracker</code> will call the
    *        <code>ServiceTrackerCustomizer</code> methods on itself.
    */
   ServiceTracker(ModuleContext* context,
                  const ServiceReferenceType& reference,
                  ServiceTrackerCustomizer<S,T>* customizer = nullptr);
 
   /**
    * Create a <code>ServiceTracker</code> on the specified class name.
    *
    * <p>
    * Services registered under the specified class name will be tracked by
    * this <code>ServiceTracker</code>.
    *
    * @param context The <code>ModuleContext</code> against which the tracking
    *        is done.
    * @param clazz The class name of the services to be tracked.
    * @param customizer The customizer object to call when services are added,
    *        modified, or removed in this <code>ServiceTracker</code>. If
    *        customizer is <code>null</code>, then this
    *        <code>ServiceTracker</code> will be used as the
    *        <code>ServiceTrackerCustomizer</code> and this
    *        <code>ServiceTracker</code> will call the
    *        <code>ServiceTrackerCustomizer</code> methods on itself.
    */
   ServiceTracker(ModuleContext* context, const std::string& clazz,
                  ServiceTrackerCustomizer<S,T>* customizer = 0);
 
   /**
    * Create a <code>ServiceTracker</code> on the specified
    * <code>LDAPFilter</code> object.
    *
    * <p>
    * Services which match the specified <code>LDAPFilter</code> object will be
    * tracked by this <code>ServiceTracker</code>.
    *
    * @param context The <code>ModuleContext</code> against which the tracking
    *        is done.
    * @param filter The <code>LDAPFilter</code> to select the services to be
    *        tracked.
    * @param customizer The customizer object to call when services are added,
    *        modified, or removed in this <code>ServiceTracker</code>. If
    *        customizer is null, then this <code>ServiceTracker</code> will be
    *        used as the <code>ServiceTrackerCustomizer</code> and this
    *        <code>ServiceTracker</code> will call the
    *        <code>ServiceTrackerCustomizer</code> methods on itself.
    */
   ServiceTracker(ModuleContext* context, const LDAPFilter& filter,
                  ServiceTrackerCustomizer<S,T>* customizer = nullptr);
 
   /**
    * Create a <code>ServiceTracker</code> on the class template
    * argument S.
    *
    * <p>
    * Services registered under the interface name of the class template
    * argument S will be tracked by this <code>ServiceTracker</code>.
    *
    * @param context The <code>ModuleContext</code> against which the tracking
    *        is done.
    * @param customizer The customizer object to call when services are added,
    *        modified, or removed in this <code>ServiceTracker</code>. If
    *        customizer is null, then this <code>ServiceTracker</code> will be
    *        used as the <code>ServiceTrackerCustomizer</code> and this
    *        <code>ServiceTracker</code> will call the
    *        <code>ServiceTrackerCustomizer</code> methods on itself.
    */
   ServiceTracker(ModuleContext* context, ServiceTrackerCustomizer<S,T>* customizer = nullptr);
 
   /**
    * Open this <code>ServiceTracker</code> and begin tracking services.
    *
    * <p>
    * Services which match the search criteria specified when this
    * <code>ServiceTracker</code> was created are now tracked by this
    * <code>ServiceTracker</code>.
    *
    * @throws std::logic_error If the <code>ModuleContext</code>
    *         with which this <code>ServiceTracker</code> was created is no
    *         longer valid.
    */
   virtual void Open();
 
   /**
    * Close this <code>ServiceTracker</code>.
    *
    * <p>
    * This method should be called when this <code>ServiceTracker</code> should
    * end the tracking of services.
    *
    * <p>
    * This implementation calls GetServiceReferences() to get the list
    * of tracked services to remove.
    */
   virtual void Close();
 
   /**
    * Wait for at least one service to be tracked by this
    * <code>ServiceTracker</code>. This method will also return when this
    * <code>ServiceTracker</code> is closed.
    *
    * <p>
    * It is strongly recommended that <code>WaitForService</code> is not used
    * during the calling of the <code>ModuleActivator</code> methods.
    * <code>ModuleActivator</code> methods are expected to complete in a short
    * period of time.
    *
    * <p>
    * This implementation calls GetService() to determine if a service
    * is being tracked.
    *
    * @return Returns the result of GetService().
    */
   virtual T WaitForService(unsigned long timeoutMillis = 0);
 
   /**
    * Return a list of <code>ServiceReference</code>s for all services being
    * tracked by this <code>ServiceTracker</code>.
    *
    * @return List of <code>ServiceReference</code>s.
    */
   virtual std::vector<ServiceReferenceType> GetServiceReferences() const;
 
   /**
    * Returns a <code>ServiceReference</code> for one of the services being
    * tracked by this <code>ServiceTracker</code>.
    *
    * <p>
    * If multiple services are being tracked, the service with the highest
    * ranking (as specified in its <code>service.ranking</code> property) is
    * returned. If there is a tie in ranking, the service with the lowest
    * service ID (as specified in its <code>service.id</code> property); that
    * is, the service that was registered first is returned. This is the same
    * algorithm used by <code>ModuleContext::GetServiceReference()</code>.
    *
    * <p>
    * This implementation calls GetServiceReferences() to get the list
    * of references for the tracked services.
    *
    * @return A <code>ServiceReference</code> for a tracked service.
    * @throws ServiceException if no services are being tracked.
    */
   virtual ServiceReferenceType GetServiceReference() const;
 
   /**
    * Returns the service object for the specified
    * <code>ServiceReference</code> if the specified referenced service is
    * being tracked by this <code>ServiceTracker</code>.
    *
    * @param reference The reference to the desired service.
    * @return A service object or <code>null</code> if the service referenced
    *         by the specified <code>ServiceReference</code> is not being
    *         tracked.
    */
   virtual T GetService(const ServiceReferenceType& reference) const;
 
   /**
    * Return a list of service objects for all services being tracked by this
    * <code>ServiceTracker</code>.
    *
    * <p>
    * This implementation calls GetServiceReferences() to get the list
    * of references for the tracked services and then calls
    * GetService(const ServiceReference&) for each reference to get the
    * tracked service object.
    *
    * @return A list of service objects or an empty list if no services
    *         are being tracked.
    */
   virtual std::vector<T> GetServices() const;
 
   /**
    * Returns a service object for one of the services being tracked by this
    * <code>ServiceTracker</code>.
    *
    * <p>
    * If any services are being tracked, this implementation returns the result
    * of calling <code>%GetService(%GetServiceReference())</code>.
    *
    * @return A service object or <code>null</code> if no services are being
    *         tracked.
    */
   virtual T GetService() const;
 
   /**
    * Remove a service from this <code>ServiceTracker</code>.
    *
    * The specified service will be removed from this
    * <code>ServiceTracker</code>. If the specified service was being tracked
    * then the <code>ServiceTrackerCustomizer::RemovedService</code> method will
    * be called for that service.
    *
    * @param reference The reference to the service to be removed.
    */
   virtual void Remove(const ServiceReferenceType& reference);
 
   /**
    * Return the number of services being tracked by this
    * <code>ServiceTracker</code>.
    *
    * @return The number of services being tracked.
    */
   virtual int Size() const;
 
   /**
    * Returns the tracking count for this <code>ServiceTracker</code>.
    *
    * The tracking count is initialized to 0 when this
    * <code>ServiceTracker</code> is opened. Every time a service is added,
    * modified or removed from this <code>ServiceTracker</code>, the tracking
    * count is incremented.
    *
    * <p>
    * The tracking count can be used to determine if this
    * <code>ServiceTracker</code> has added, modified or removed a service by
    * comparing a tracking count value previously collected with the current
    * tracking count value. If the value has not changed, then no service has
    * been added, modified or removed from this <code>ServiceTracker</code>
    * since the previous tracking count was collected.
    *
    * @return The tracking count for this <code>ServiceTracker</code> or -1 if
    *         this <code>ServiceTracker</code> is not open.
    */
   virtual int GetTrackingCount() const;
 
   /**
    * Return a sorted map of the <code>ServiceReference</code>s and
    * service objects for all services being tracked by this
    * <code>ServiceTracker</code>. The map is sorted in natural order
    * of <code>ServiceReference</code>. That is, the last entry is the service
    * with the highest ranking and the lowest service id.
    *
    * @param tracked A <code>TrackingMap</code> with the <code>ServiceReference</code>s
    *         and service objects for all services being tracked by this
    *         <code>ServiceTracker</code>. If no services are being tracked,
    *         then the returned map is empty.
    */
   virtual void GetTracked(TrackingMap& tracked) const;
 
   /**
    * Return if this <code>ServiceTracker</code> is empty.
    *
    * @return <code>true</code> if this <code>ServiceTracker</code> is not tracking any
    *         services.
    */
   virtual bool IsEmpty() const;
 
 protected:
 
   /**
    * Default implementation of the
    * <code>ServiceTrackerCustomizer::AddingService</code> method.
    *
    * <p>
    * This method is only called when this <code>ServiceTracker</code> has been
    * constructed with a <code>null</code> ServiceTrackerCustomizer argument.
    *
    * <p>
    * This implementation returns the result of calling <code>GetService</code>
    * on the <code>ModuleContext</code> with which this
    * <code>ServiceTracker</code> was created passing the specified
    * <code>ServiceReference</code>.
    * <p>
    * This method can be overridden in a subclass to customize the service
    * object to be tracked for the service being added. In that case, take care
    * not to rely on the default implementation of
    * \link RemovedService(const ServiceReferenceType&, T service) removedService\endlink
    * to unget the service.
    *
    * @param reference The reference to the service being added to this
    *        <code>ServiceTracker</code>.
    * @return The service object to be tracked for the service added to this
    *         <code>ServiceTracker</code>.
    * @see ServiceTrackerCustomizer::AddingService(const ServiceReference&)
    */
   T AddingService(const ServiceReferenceType& reference) override;
 
   /**
    * Default implementation of the
    * <code>ServiceTrackerCustomizer::ModifiedService</code> method.
    *
    * <p>
    * This method is only called when this <code>ServiceTracker</code> has been
    * constructed with a <code>null</code> ServiceTrackerCustomizer argument.
    *
    * <p>
    * This implementation does nothing.
    *
    * @param reference The reference to modified service.
    * @param service The service object for the modified service.
    * @see ServiceTrackerCustomizer::ModifiedService(const ServiceReference&, T)
    */
   void ModifiedService(const ServiceReferenceType& reference, T service) override;
 
   /**
    * Default implementation of the
    * <code>ServiceTrackerCustomizer::RemovedService</code> method.
    *
    * <p>
    * This method is only called when this <code>ServiceTracker</code> has been
    * constructed with a <code>null</code> ServiceTrackerCustomizer argument.
    *
    * <p>
    * This implementation calls <code>UngetService</code>, on the
    * <code>ModuleContext</code> with which this <code>ServiceTracker</code>
    * was created, passing the specified <code>ServiceReference</code>.
    * <p>
    * This method can be overridden in a subclass. If the default
    * implementation of \link AddingService(const ServiceReferenceType&) AddingService\endlink
    * method was used, this method must unget the service.
    *
    * @param reference The reference to removed service.
    * @param service The service object for the removed service.
    * @see ServiceTrackerCustomizer::RemovedService(const ServiceReferenceType&, T)
    */
   void RemovedService(const ServiceReferenceType& reference, T service) override;
 
 private:
 
   typedef ServiceTracker<S,TTT> _ServiceTracker;
   typedef TrackedService<S,TTT> _TrackedService;
   typedef ServiceTrackerPrivate<S,TTT> _ServiceTrackerPrivate;
   typedef ServiceTrackerCustomizer<S,T> _ServiceTrackerCustomizer;
 
   friend class TrackedService<S,TTT>;
   friend class ServiceTrackerPrivate<S,TTT>;
 
   _ServiceTrackerPrivate* const d;
 };
 
 US_END_NAMESPACE
 
 #include "usServiceTracker.tpp"
 
 #endif // USSERVICETRACKER_H
diff --git a/Modules/CppMicroServices/core/include/usServiceTrackerCustomizer.h b/Modules/CppMicroServices/core/include/usServiceTrackerCustomizer.h
index 8c728d6f5a..3e7ab79c94 100644
--- a/Modules/CppMicroServices/core/include/usServiceTrackerCustomizer.h
+++ b/Modules/CppMicroServices/core/include/usServiceTrackerCustomizer.h
@@ -1,118 +1,118 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICETRACKERCUSTOMIZER_H
 #define USSERVICETRACKERCUSTOMIZER_H
 
 #include "usServiceReference.h"
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServices
  *
  * The <code>ServiceTrackerCustomizer</code> interface allows a
  * <code>ServiceTracker</code> to customize the service objects that are
  * tracked. A <code>ServiceTrackerCustomizer</code> is called when a service is
  * being added to a <code>ServiceTracker</code>. The
  * <code>ServiceTrackerCustomizer</code> can then return an object for the
  * tracked service. A <code>ServiceTrackerCustomizer</code> is also called when
  * a tracked service is modified or has been removed from a
  * <code>ServiceTracker</code>.
  *
  * <p>
  * The methods in this interface may be called as the result of a
  * <code>ServiceEvent</code> being received by a <code>ServiceTracker</code>.
  * Since <code>ServiceEvent</code>s are synchronously delivered,
  * it is highly recommended that implementations of these methods do
  * not register (<code>ModuleContext::RegisterService</code>), modify (
  * <code>ServiceRegistration::SetProperties</code>) or unregister (
  * <code>ServiceRegistration::Unregister</code>) a service while being
  * synchronized on any object.
  *
  * <p>
  * The <code>ServiceTracker</code> class is thread-safe. It does not call a
  * <code>ServiceTrackerCustomizer</code> while holding any locks.
  * <code>ServiceTrackerCustomizer</code> implementations must also be
  * thread-safe.
  *
  * \tparam S The type of the service being tracked
  * \tparam T The type of the tracked object.
  * \remarks This class is thread safe.
  */
 template<class S, class T = S*>
 struct ServiceTrackerCustomizer {
 
   typedef S ServiceType;
   typedef T TrackedType;
   typedef ServiceReference<ServiceType> ServiceReferenceType;
 
   virtual ~ServiceTrackerCustomizer() {}
 
   /**
    * A service is being added to the <code>ServiceTracker</code>.
    *
    * <p>
    * This method is called before a service which matched the search
    * parameters of the <code>ServiceTracker</code> is added to the
    * <code>ServiceTracker</code>. This method should return the service object
    * to be tracked for the specified <code>ServiceReference</code>. The
    * returned service object is stored in the <code>ServiceTracker</code> and
    * is available from the <code>GetService</code> and
    * <code>GetServices</code> methods.
    *
    * @param reference The reference to the service being added to the
    *        <code>ServiceTracker</code>.
    * @return The service object to be tracked for the specified referenced
    *         service or <code>0</code> if the specified referenced service
    *         should not be tracked.
    */
   virtual TrackedType AddingService(const ServiceReferenceType& reference) = 0;
 
   /**
    * A service tracked by the <code>ServiceTracker</code> has been modified.
    *
    * <p>
    * This method is called when a service being tracked by the
    * <code>ServiceTracker</code> has had it properties modified.
    *
    * @param reference The reference to the service that has been modified.
    * @param service The service object for the specified referenced service.
    */
   virtual void ModifiedService(const ServiceReferenceType& reference, TrackedType service) = 0;
 
   /**
    * A service tracked by the <code>ServiceTracker</code> has been removed.
    *
    * <p>
    * This method is called after a service is no longer being tracked by the
    * <code>ServiceTracker</code>.
    *
    * @param reference The reference to the service that has been removed.
    * @param service The service object for the specified referenced service.
    */
   virtual void RemovedService(const ServiceReferenceType& reference, TrackedType service) = 0;
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICETRACKERCUSTOMIZER_H
diff --git a/Modules/CppMicroServices/core/include/usSharedData.h b/Modules/CppMicroServices/core/include/usSharedData.h
index 33a442ce7f..d3edd48ae3 100644
--- a/Modules/CppMicroServices/core/include/usSharedData.h
+++ b/Modules/CppMicroServices/core/include/usSharedData.h
@@ -1,277 +1,277 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 /*============================================================================
 
 Modified version of qshareddata.h from Qt 4.7.3 for CppMicroServices.
 Original copyright (c) Nokia Corporation. Usage covered by the
 GNU Lesser General Public License version 2.1
-(http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html) and the Nokia Qt
+(https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html) and the Nokia Qt
 LGPL Exception version 1.1 (file LGPL_EXCEPTION.txt in Qt 4.7.3 package).
 
 ============================================================================*/
 
 #ifndef USSHAREDDATA_H
 #define USSHAREDDATA_H
 
 #include "usAtomicInt_p.h"
 
 #include <algorithm>
 #include <utility>
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServicesUtils
  */
 class SharedData
 {
 public:
   mutable AtomicInt ref;
 
   inline SharedData() : ref(0) { }
   inline SharedData(const SharedData&) : ref(0) { }
 
 private:
   // using the assignment operator would lead to corruption in the ref-counting
   SharedData& operator=(const SharedData&);
 };
 
 /**
  * \ingroup MicroServicesUtils
  */
 template <class T>
 class SharedDataPointer
 {
 public:
   typedef T Type;
   typedef T* pointer;
 
   inline void Detach() { if (d && d->ref != 1) Detach_helper(); }
   inline T& operator*() { Detach(); return *d; }
   inline const T& operator*() const { return *d; }
   inline T* operator->() { Detach(); return d; }
   inline const T* operator->() const { return d; }
   inline operator T*() { Detach(); return d; }
   inline operator const T*() const { return d; }
   inline T* Data() { Detach(); return d; }
   inline const T* Data() const { return d; }
   inline const T* ConstData() const { return d; }
 
   inline bool operator==(const SharedDataPointer<T>& other) const { return d == other.d; }
   inline bool operator!=(const SharedDataPointer<T>& other) const { return d != other.d; }
 
   inline SharedDataPointer() : d(nullptr) { }
   inline ~SharedDataPointer() { if (d && !d->ref.Deref()) delete d; }
 
   explicit SharedDataPointer(T* data);
   inline SharedDataPointer(const SharedDataPointer<T>& o) : d(o.d) { if (d) d->ref.Ref(); }
 
   inline SharedDataPointer<T> & operator=(const SharedDataPointer<T>& o)
   {
     if (o.d != d)
     {
       if (o.d)
         o.d->ref.Ref();
       T *old = d;
       d = o.d;
       if (old && !old->ref.Deref())
         delete old;
     }
     return *this;
   }
 
   inline SharedDataPointer &operator=(T *o)
   {
     if (o != d)
     {
       if (o)
         o->ref.Ref();
       T *old = d;
       d = o;
       if (old && !old->ref.Deref())
         delete old;
     }
     return *this;
   }
 
   inline bool operator!() const { return !d; }
 
   inline void Swap(SharedDataPointer& other)
   {
     using std::swap;
     swap(d, other.d);
   }
 
 protected:
   T* Clone();
 
 private:
   void Detach_helper();
 
   T *d;
 };
 
 /**
  * \ingroup MicroServicesUtils
  */
 template <class T> class ExplicitlySharedDataPointer
 {
 public:
   typedef T Type;
   typedef T* pointer;
 
   inline T& operator*() const { return *d; }
   inline T* operator->() { return d; }
   inline T* operator->() const { return d; }
   inline T* Data() const { return d; }
   inline const T* ConstData() const { return d; }
 
   inline void Detach() { if (d && d->ref != 1) Detach_helper(); }
 
   inline void Reset()
   {
     if(d && !d->ref.Deref())
       delete d;
 
     d = 0;
   }
 
   inline operator bool () const { return d != nullptr; }
 
   inline bool operator==(const ExplicitlySharedDataPointer<T>& other) const { return d == other.d; }
   inline bool operator!=(const ExplicitlySharedDataPointer<T>& other) const { return d != other.d; }
   inline bool operator==(const T* ptr) const { return d == ptr; }
   inline bool operator!=(const T* ptr) const { return d != ptr; }
 
   inline ExplicitlySharedDataPointer() { d = 0; }
   inline ~ExplicitlySharedDataPointer() { if (d && !d->ref.Deref()) delete d; }
 
   explicit ExplicitlySharedDataPointer(T* data);
   inline ExplicitlySharedDataPointer(const ExplicitlySharedDataPointer<T> &o)
     : d(o.d) { if (d) d->ref.Ref(); }
 
   template<class X>
   inline ExplicitlySharedDataPointer(const ExplicitlySharedDataPointer<X>& o)
     : d(static_cast<T*>(o.Data()))
   {
     if(d)
       d->ref.Ref();
   }
 
   inline ExplicitlySharedDataPointer<T>& operator=(const ExplicitlySharedDataPointer<T>& o)
   {
     if (o.d != d)
     {
       if (o.d)
         o.d->ref.Ref();
       T *old = d;
       d = o.d;
       if (old && !old->ref.Deref())
         delete old;
     }
     return *this;
   }
 
   inline ExplicitlySharedDataPointer& operator=(T* o)
   {
     if (o != d)
     {
       if (o)
         o->ref.Ref();
       T *old = d;
       d = o;
       if (old && !old->ref.Deref())
         delete old;
     }
     return *this;
   }
 
   inline bool operator!() const { return !d; }
 
   inline void Swap(ExplicitlySharedDataPointer& other)
   {
     using std::swap;
     swap(d, other.d);
   }
 
 protected:
   T* Clone();
 
 private:
   void Detach_helper();
 
   T *d;
 };
 
 
 template <class T>
 SharedDataPointer<T>::SharedDataPointer(T* adata) : d(adata)
 { if (d) d->ref.Ref(); }
 
 template <class T>
 T* SharedDataPointer<T>::Clone()
 {
   return new T(*d);
 }
 
 template <class T>
 void SharedDataPointer<T>::Detach_helper()
 {
   T *x = Clone();
   x->ref.Ref();
   if (!d->ref.Deref())
     delete d;
   d = x;
 }
 
 template <class T>
 T* ExplicitlySharedDataPointer<T>::Clone()
 {
   return new T(*d);
 }
 
 template <class T>
 void ExplicitlySharedDataPointer<T>::Detach_helper()
 {
   T *x = Clone();
     x->ref.Ref();
   if (!d->ref.Deref())
     delete d;
   d = x;
 }
 
 template <class T>
 ExplicitlySharedDataPointer<T>::ExplicitlySharedDataPointer(T* adata)
   : d(adata)
 { if (d) d->ref.Ref(); }
 
 template <class T>
 void swap(US_PREPEND_NAMESPACE(SharedDataPointer<T)>& p1, US_PREPEND_NAMESPACE(SharedDataPointer<T)>& p2)
 { p1.Swap(p2); }
 
 template <class T>
 void swap(US_PREPEND_NAMESPACE(ExplicitlySharedDataPointer<T)>& p1, US_PREPEND_NAMESPACE(ExplicitlySharedDataPointer<T)>& p2)
 { p1.Swap(p2); }
 
 US_END_NAMESPACE
 
 #endif // USSHAREDDATA_H
diff --git a/Modules/CppMicroServices/core/include/usSharedLibrary.h b/Modules/CppMicroServices/core/include/usSharedLibrary.h
index 81a7981aa9..2a7f3453ff 100644
--- a/Modules/CppMicroServices/core/include/usSharedLibrary.h
+++ b/Modules/CppMicroServices/core/include/usSharedLibrary.h
@@ -1,214 +1,214 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSHAREDLIBRARY_H
 #define USSHAREDLIBRARY_H
 
 #include "usCoreConfig.h"
 #include "usSharedData.h"
 
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 class SharedLibraryPrivate;
 
 /**
  * \ingroup MicroServicesUtils
  *
  * The SharedLibrary class loads shared libraries at runtime.
  */
 class US_Core_EXPORT SharedLibrary
 {
 public:
 
   SharedLibrary();
   SharedLibrary(const SharedLibrary& other);
 
   /**
    * Construct a SharedLibrary object using a library search path and
    * a library base name.
    *
    * @param libPath An absolute path containing the shared library
    * @param name The base name of the shared library, without prefix
    *        and suffix.
    */
   SharedLibrary(const std::string& libPath, const std::string& name);
 
   /**
    * Construct a SharedLibrary object using an absolute file path to
    * the shared library. Using this constructor effectively disables
    * all setters except SetFilePath().
    *
    * @param absoluteFilePath The absolute path to the shared library.
    */
   SharedLibrary(const std::string& absoluteFilePath);
 
   /**
    * Destroys this object but does not unload the shared library.
    */
   ~SharedLibrary();
 
   SharedLibrary& operator=(const SharedLibrary& other);
 
   /**
    * Loads the shared library pointed to by this SharedLibrary object.
    * On POSIX systems dlopen() is called with the RTLD_LAZY and
    * RTLD_LOCAL flags unless the compiler is gcc 4.4.x or older. Then
    * the RTLD_LAZY and RTLD_GLOBAL flags are used to load the shared library
    * to work around RTTI problems across shared library boundaries.
    *
    * @throws std::logic_error If the library is already loaded.
    * @throws std::runtime_error If loading the library failed.
    */
   void Load();
 
   /**
    * Loads the shared library pointed to by this SharedLibrary object,
    * using the specified flags on POSIX systems.
    *
    * @throws std::logic_error If the library is already loaded.
    * @throws std::runtime_error If loading the library failed.
    */
   void Load(int flags);
 
   /**
    * Un-loads the shared library pointed to by this SharedLibrary object.
    *
    * @throws std::runtime_error If an error occurred while un-loading the
    *         shared library.
    */
   void Unload();
 
   /**
    * Sets the base name of the shared library. Does nothing if the shared
    * library is already loaded or the SharedLibrary(const std::string&)
    * constructor was used.
    *
    * @param name The base name of the shared library, without prefix and
    *        suffix.
    */
   void SetName(const std::string& name);
 
   /**
    * Gets the base name of the shared library.
    * @return The shared libraries base name.
    */
   std::string GetName() const;
 
   /**
    * Gets the absolute file path for the shared library with base name
    * \c name, using the search path returned by GetLibraryPath().
    *
    * @param name The shared library base name.
    * @return The absolute file path of the shared library.
    */
   std::string GetFilePath(const std::string& name) const;
 
   /**
    * Sets the absolute file path of this SharedLibrary object.
    * Using this methods with a non-empty \c absoluteFilePath argument
    * effectively disables all other setters.
    *
    * @param absoluteFilePath The new absolute file path of this SharedLibrary
    *        object.
    */
   void SetFilePath(const std::string& absoluteFilePath);
 
   /**
    * Gets the absolute file path of this SharedLibrary object.
    *
    * @return The absolute file path of the shared library.
    */
   std::string GetFilePath() const;
 
   /**
    * Sets a new library search path. Does nothing if the shared
    * library is already loaded or the SharedLibrary(const std::string&)
    * constructor was used.
    *
    * @param path The new shared library search path.
    */
   void SetLibraryPath(const std::string& path);
 
   /**
    * Gets the library search path of this SharedLibrary object.
    *
    * @return The library search path.
    */
   std::string GetLibraryPath() const;
 
   /**
    * Sets the suffix for shared library names (e.g. lib). Does nothing if the shared
    * library is already loaded or the SharedLibrary(const std::string&)
    * constructor was used.
    *
    * @param suffix The shared library name suffix.
    */
   void SetSuffix(const std::string& suffix);
 
   /**
    * Gets the file name suffix of this SharedLibrary object.
    *
    * @return The file name suffix of the shared library.
    */
   std::string GetSuffix() const;
 
   /**
    * Sets the file name prefix for shared library names (e.g. .dll or .so).
    * Does nothing if the shared library is already loaded or the
    * SharedLibrary(const std::string&) constructor was used.
    *
    * @param prefix The shared library name prefix.
    */
   void SetPrefix(const std::string& prefix);
 
   /**
    * Gets the file name prefix of this SharedLibrary object.
    *
    * @return The file name prefix of the shared library.
    */
   std::string GetPrefix() const;
 
   /**
    * Gets the internal handle of this SharedLibrary object.
    *
    * @return \c nullptr if the shared library is not loaded, the operating
    * system specific handle otherwise.
    */
   void* GetHandle() const;
 
   /**
    * Gets the loaded/unloaded stated of this SharedLibrary object.
    *
    * @return \c true if the shared library is loaded, \c false otherwise.
    */
   bool IsLoaded() const;
 
 private:
 
   ExplicitlySharedDataPointer<SharedLibraryPrivate> d;
 
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTUTILSHAREDLIBRARY_H
diff --git a/Modules/CppMicroServices/core/include/usShrinkableMap.h b/Modules/CppMicroServices/core/include/usShrinkableMap.h
index 604e6c6e24..f5b72c2998 100644
--- a/Modules/CppMicroServices/core/include/usShrinkableMap.h
+++ b/Modules/CppMicroServices/core/include/usShrinkableMap.h
@@ -1,181 +1,181 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSHRINKABLEMAP_H
 #define USSHRINKABLEMAP_H
 
 #include "usGlobalConfig.h"
 
 #include <map>
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServicesUtils
  *
  * A std::map style associative container allowing query and removal
  * operations only.
  */
 template<class Key, class T>
 class ShrinkableMap
 {
 private:
   static std::map<Key,T> emptyContainer;
 
 public:
 
   typedef std::map<Key,T> container_type;
   typedef typename container_type::iterator iterator;
   typedef typename container_type::const_iterator const_iterator;
   typedef typename container_type::size_type size_type;
   typedef typename container_type::key_type key_type;
   typedef typename container_type::mapped_type mapped_type;
   typedef typename container_type::value_type value_type;
   typedef typename container_type::reference reference;
   typedef typename container_type::const_reference const_reference;
 
   ShrinkableMap()
     : container(emptyContainer)
   {
   }
 
   iterator begin()
   {
     return container.begin();
   }
 
   const_iterator begin() const
   {
     return container.begin();
   }
 
   iterator end()
   {
     return container.end();
   }
 
   const_iterator end() const
   {
     return container.end();
   }
 
   void erase(iterator pos)
   {
     return container.erase(pos);
   }
 
   void erase(iterator first, iterator last)
   {
     return container.erase(first, last);
   }
 
   size_type erase(const Key& key)
   {
     return container.erase(key);
   }
 
   bool empty() const
   {
     return container.empty();
   }
 
   void clear()
   {
     container.clear();
   }
 
   size_type size() const
   {
     return container.size();
   }
 
   size_type max_size() const
   {
     return container.max_size();
   }
 
   T& operator[](const Key& key)
   {
     return container[key];
   }
 
   size_type count(const Key& key) const
   {
     return container.count(key);
   }
 
   iterator find(const Key& key)
   {
     return container.find(key);
   }
 
   const_iterator find(const Key& key) const
   {
     return container.find(key);
   }
 
   std::pair<iterator,iterator> equal_range(const Key& key)
   {
     return container.equal_range(key);
   }
 
   std::pair<const_iterator,const_iterator> equal_range(const Key& key) const
   {
     return container.equal_range(key);
   }
 
   iterator lower_bound(const Key& key)
   {
     return container.lower_bound(key);
   }
 
   const_iterator lower_bound(const Key& key) const
   {
     return container.lower_bound(key);
   }
 
   iterator upper_bound(const Key& key)
   {
     return container.upper_bound(key);
   }
 
   const_iterator upper_bound(const Key& key) const
   {
     return container.upper_bound(key);
   }
 
 private:
 
   friend class ServiceHooks;
 
   ShrinkableMap(container_type& container)
     : container(container)
   {}
 
   container_type& container;
 };
 
 template<class Key, class T>
 std::map<Key,T> ShrinkableMap<Key,T>::emptyContainer;
 
 US_END_NAMESPACE
 
 #endif // USSHRINKABLEMAP_H
diff --git a/Modules/CppMicroServices/core/include/usShrinkableVector.h b/Modules/CppMicroServices/core/include/usShrinkableVector.h
index b823650c17..27e0ac3e6d 100644
--- a/Modules/CppMicroServices/core/include/usShrinkableVector.h
+++ b/Modules/CppMicroServices/core/include/usShrinkableVector.h
@@ -1,164 +1,164 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSHRINKABLEVECTOR_H
 #define USSHRINKABLEVECTOR_H
 
 #include "usGlobalConfig.h"
 
 #include <vector>
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServicesUtils
  *
  * A std::vector style container allowing query and removal
  * operations only.
  */
 template<class E>
 class ShrinkableVector
 {
 private:
   static std::vector<E> emptyVector;
 
 public:
 
   typedef std::vector<E> container_type;
   typedef typename container_type::iterator iterator;
   typedef typename container_type::const_iterator const_iterator;
   typedef typename container_type::size_type size_type;
   typedef typename container_type::reference reference;
   typedef typename container_type::const_reference const_reference;
 
   ShrinkableVector()
   : container(emptyVector)
   {
   }
 
   iterator begin()
   {
     return container.begin();
   }
 
   const_iterator begin() const
   {
     return container.begin();
   }
 
   iterator end()
   {
     return container.end();
   }
 
   const_iterator end() const
   {
     return container.end();
   }
 
   reference front()
   {
     return container.front();
   }
 
   const_reference front() const
   {
     return container.front();
   }
 
   reference back()
   {
     return container.back();
   }
 
   const_reference back() const
   {
     return container.back();
   }
 
   iterator erase(iterator pos)
   {
     return container.erase(pos);
   }
 
   iterator erase(iterator first, iterator last)
   {
     return container.erase(first, last);
   }
 
   void pop_back()
   {
     container.pop_back();
   }
 
   bool empty() const
   {
     return container.empty();
   }
 
   void clear()
   {
     container.clear();
   }
 
   size_type size() const
   {
     return container.size();
   }
 
   reference at(size_type pos)
   {
     return container.at(pos);
   }
 
   const_reference at(size_type pos) const
   {
     return container.at(pos);
   }
 
   const_reference operator[](size_type i) const
   {
     return container[i];
   }
 
   reference operator[](size_type i)
   {
     return container[i];
   }
 
 private:
 
   friend class ModuleHooks;
   friend class ServiceHooks;
 
   ShrinkableVector(container_type& container)
     : container(container)
   {}
 
   container_type& container;
 };
 
 template<class E>
 std::vector<E> ShrinkableVector<E>::emptyVector;
 
 US_END_NAMESPACE
 
 #endif // USSHRINKABLEVECTOR_H
diff --git a/Modules/CppMicroServices/core/src/module/usCoreModuleActivator.cpp b/Modules/CppMicroServices/core/src/module/usCoreModuleActivator.cpp
index c5064e1f4b..8eccfe3007 100644
--- a/Modules/CppMicroServices/core/src/module/usCoreModuleActivator.cpp
+++ b/Modules/CppMicroServices/core/src/module/usCoreModuleActivator.cpp
@@ -1,47 +1,47 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleActivator.h"
 
 #include "usModule.h"
 #include "usModulePrivate.h"
 #include "usCoreModuleContext_p.h"
 
 US_BEGIN_NAMESPACE
 
 class CoreModuleActivator : public ModuleActivator
 {
 
   void Load(ModuleContext* mc) override
   {
     mc->GetModule()->d->coreCtx->Init();
   }
 
   void Unload(ModuleContext* /*mc*/) override
   {
     //mc->GetModule()->d->coreCtx->Uninit();
   }
 
 };
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(CoreModuleActivator))
diff --git a/Modules/CppMicroServices/core/src/module/usCoreModuleContext.cpp b/Modules/CppMicroServices/core/src/module/usCoreModuleContext.cpp
index b48ee75cc7..2b836b4c23 100644
--- a/Modules/CppMicroServices/core/src/module/usCoreModuleContext.cpp
+++ b/Modules/CppMicroServices/core/src/module/usCoreModuleContext.cpp
@@ -1,53 +1,53 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usGlobalConfig.h>
 
 US_MSVC_DISABLE_WARNING(4355)
 
 #include "usCoreModuleContext_p.h"
 
 US_BEGIN_NAMESPACE
 
 CoreModuleContext::CoreModuleContext()
   : listeners(this)
   , services(this)
   , serviceHooks(this)
   , moduleHooks(this)
 {
 }
 
 CoreModuleContext::~CoreModuleContext()
 {
 }
 
 void CoreModuleContext::Init()
 {
   serviceHooks.Open();
 }
 
 void CoreModuleContext::Uninit()
 {
   serviceHooks.Close();
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usCoreModuleContext_p.h b/Modules/CppMicroServices/core/src/module/usCoreModuleContext_p.h
index ee01d8bf1e..85af6542d6 100644
--- a/Modules/CppMicroServices/core/src/module/usCoreModuleContext_p.h
+++ b/Modules/CppMicroServices/core/src/module/usCoreModuleContext_p.h
@@ -1,76 +1,76 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USCOREMODULECONTEXT_H
 #define USCOREMODULECONTEXT_H
 
 #include "usServiceListeners_p.h"
 #include "usServiceRegistry_p.h"
 #include "usModuleHooks_p.h"
 #include "usServiceHooks_p.h"
 
 US_BEGIN_NAMESPACE
 
 /**
  * This class is not part of the public API.
  */
 class CoreModuleContext
 {
 public:
 
   /**
    * All listeners in this framework.
    */
   ServiceListeners listeners;
 
   /**
    * All registered services in this framework.
    */
   ServiceRegistry services;
 
   /**
    * All service hooks.
    */
   ServiceHooks serviceHooks;
 
   /**
    * All module hooks.
    */
   ModuleHooks moduleHooks;
 
   /**
    * Contruct a core context
    *
    */
   CoreModuleContext();
 
   ~CoreModuleContext();
 
   void Init();
 
   void Uninit();
 
 };
 
 US_END_NAMESPACE
 
 #endif // USCOREMODULECONTEXT_H
diff --git a/Modules/CppMicroServices/core/src/module/usModule.cpp b/Modules/CppMicroServices/core/src/module/usModule.cpp
index 9b4fb91d13..ef282a92c0 100644
--- a/Modules/CppMicroServices/core/src/module/usModule.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModule.cpp
@@ -1,313 +1,313 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModule.h"
 
 #include "usModuleContext.h"
 #include "usModuleActivator.h"
 #include "usModulePrivate.h"
 #include "usModuleResource.h"
 #include "usModuleSettings.h"
 #include "usCoreModuleContext_p.h"
 
 #include "usCoreConfig.h"
 
 US_BEGIN_NAMESPACE
 
 const std::string& Module::PROP_ID()
 {
   static const std::string s("module.id");
   return s;
 }
 const std::string& Module::PROP_NAME()
 {
   static const std::string s("module.name");
   return s;
 }
 const std::string& Module::PROP_LOCATION()
 {
   static const std::string s("module.location");
   return s;
 }
 const std::string& Module::PROP_VERSION()
 {
   static const std::string s("module.version");
   return s;
 }
 
 const std::string&Module::PROP_VENDOR()
 {
   static const std::string s("module.vendor");
   return s;
 }
 
 const std::string&Module::PROP_DESCRIPTION()
 {
   static const std::string s("module.description");
   return s;
 }
 
 const std::string&Module::PROP_AUTOLOAD_DIR()
 {
   static const std::string s("module.autoload_dir");
   return s;
 }
 
 const std::string&Module::PROP_AUTOLOADED_MODULES()
 {
   static const std::string s("module.autoloaded_modules");
   return s;
 }
 
 Module::Module()
 : d(nullptr)
 {
 
 }
 
 Module::~Module()
 {
   delete d;
 }
 
 void Module::Init(CoreModuleContext* coreCtx,
                   ModuleInfo* info)
 {
   ModulePrivate* mp = new ModulePrivate(this, coreCtx, info);
   std::swap(mp, d);
   delete mp;
 }
 
 void Module::Uninit()
 {
   if (d->moduleContext != nullptr)
   {
     //d->coreCtx->listeners.HooksModuleStopped(d->moduleContext);
     d->RemoveModuleResources();
     delete d->moduleContext;
     d->moduleContext = nullptr;
     d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::UNLOADED, this));
 
     d->moduleActivator = nullptr;
   }
 }
 
 bool Module::IsLoaded() const
 {
   return d->moduleContext != nullptr;
 }
 
 void Module::Start()
 {
 
   if (d->moduleContext)
   {
     US_WARN << "Module " << d->info.name << " already started.";
     return;
   }
 
   d->moduleContext = new ModuleContext(this->d);
 
   typedef ModuleActivator*(*ModuleActivatorHook)(void);
   ModuleActivatorHook activatorHook = nullptr;
 
   std::string activator_func = "_us_module_activator_instance_" + d->info.name;
   void* activatorHookSym = ModuleUtils::GetSymbol(d->info, activator_func.c_str());
   std::memcpy(&activatorHook, &activatorHookSym, sizeof(void*));
 
   d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::LOADING, this));
   // try to get a ModuleActivator instance
 
   if (activatorHook)
   {
     try
     {
       d->moduleActivator = activatorHook();
     }
     catch (...)
     {
       US_ERROR << "Creating the module activator of " << d->info.name << " failed";
       throw;
     }
 
     // This method should be "noexcept" and by not catching exceptions
     // here we semantically treat it that way since any exception during
     // static initialization will either terminate the program or cause
     // the dynamic loader to report an error.
     d->moduleActivator->Load(d->moduleContext);
   }
 
 #ifdef US_ENABLE_AUTOLOADING_SUPPORT
   if (ModuleSettings::IsAutoLoadingEnabled())
   {
     const std::vector<std::string> loadedPaths = AutoLoadModules(d->info);
     if (!loadedPaths.empty())
     {
       d->moduleManifest.SetValue(PROP_AUTOLOADED_MODULES(), Any(loadedPaths));
     }
   }
 #endif
 
   d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::LOADED, this));
 }
 
 void Module::Stop()
 {
   if (d->moduleContext == nullptr)
   {
     US_WARN << "Module " << d->info.name << " already stopped.";
     return;
   }
 
   try
   {
     d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::UNLOADING, this));
 
     if (d->moduleActivator)
     {
       d->moduleActivator->Unload(d->moduleContext);
     }
   }
   catch (...)
   {
     US_WARN << "Calling the module activator Unload() method of " << d->info.name << " failed!";
 
     try
     {
       this->Uninit();
     }
     catch (...) {}
 
     throw;
   }
 
   this->Uninit();
 }
 
 ModuleContext* Module::GetModuleContext() const
 {
   return d->moduleContext;
 }
 
 long Module::GetModuleId() const
 {
   return d->info.id;
 }
 
 std::string Module::GetLocation() const
 {
   return d->info.location;
 }
 
 std::string Module::GetName() const
 {
   return d->info.name;
 }
 
 ModuleVersion Module::GetVersion() const
 {
   return d->version;
 }
 
 Any Module::GetProperty(const std::string& key) const
 {
   return d->moduleManifest.GetValue(key);
 }
 
 std::vector<std::string> Module::GetPropertyKeys() const
 {
   return d->moduleManifest.GetKeys();
 }
 
 std::vector<ServiceReferenceU> Module::GetRegisteredServices() const
 {
   std::vector<ServiceRegistrationBase> sr;
   std::vector<ServiceReferenceU> res;
   d->coreCtx->services.GetRegisteredByModule(d, sr);
   for (std::vector<ServiceRegistrationBase>::const_iterator i = sr.begin();
        i != sr.end(); ++i)
   {
     res.push_back(i->GetReference());
   }
   return res;
 }
 
 std::vector<ServiceReferenceU> Module::GetServicesInUse() const
 {
   std::vector<ServiceRegistrationBase> sr;
   std::vector<ServiceReferenceU> res;
   d->coreCtx->services.GetUsedByModule(const_cast<Module*>(this), sr);
   for (std::vector<ServiceRegistrationBase>::const_iterator i = sr.begin();
        i != sr.end(); ++i)
   {
     res.push_back(i->GetReference());
   }
   return res;
 }
 
 ModuleResource Module::GetResource(const std::string& path) const
 {
   if (!d->resourceContainer.IsValid())
   {
     return ModuleResource();
   }
   ModuleResource result(path, d->resourceContainer);
   if (result) return result;
   return ModuleResource();
 }
 
 std::vector<ModuleResource> Module::FindResources(const std::string& path, const std::string& filePattern,
                                                   bool recurse) const
 {
   std::vector<ModuleResource> result;
   if (!d->resourceContainer.IsValid())
   {
     return result;
   }
 
   std::string normalizedPath = path;
   // add a leading and trailing slash
   if (normalizedPath.empty()) normalizedPath.push_back('/');
   if (*normalizedPath.begin() != '/') normalizedPath = '/' + normalizedPath;
   if (*normalizedPath.rbegin() != '/') normalizedPath.push_back('/');
   d->resourceContainer.FindNodes(d->info.name + normalizedPath,
                                  filePattern.empty() ? "*" : filePattern,
                                  recurse, result);
   return result;
 }
 
 US_END_NAMESPACE
 
 US_USE_NAMESPACE
 
 std::ostream& operator<<(std::ostream& os, const Module& module)
 {
   os << "Module[" << "id=" << module.GetModuleId() <<
         ", loc=" << module.GetLocation() <<
         ", name=" << module.GetName() << "]";
   return os;
 }
 
 std::ostream& operator<<(std::ostream& os, Module const * module)
 {
   return operator<<(os, *module);
 }
diff --git a/Modules/CppMicroServices/core/src/module/usModuleAbstractTracked.tpp b/Modules/CppMicroServices/core/src/module/usModuleAbstractTracked.tpp
index ae1a27f8bd..148991d0a1 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleAbstractTracked.tpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleAbstractTracked.tpp
@@ -1,316 +1,316 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usUtils_p.h>
 #include <iterator>
 
 US_BEGIN_NAMESPACE
 
 template<class S, class TTT, class R>
 const bool ModuleAbstractTracked<S,TTT,R>::DEBUG_OUTPUT = false;
 
 template<class S, class TTT, class R>
 ModuleAbstractTracked<S,TTT,R>::ModuleAbstractTracked()
 {
   closed = false;
 }
 
 template<class S, class TTT, class R>
 ModuleAbstractTracked<S,TTT,R>::~ModuleAbstractTracked()
 {
 
 }
 
 template<class S, class TTT, class R>
 void ModuleAbstractTracked<S,TTT,R>::SetInitial(const std::vector<S>& initiallist)
 {
   std::copy(initiallist.begin(), initiallist.end(), std::back_inserter(initial));
 
   if (DEBUG_OUTPUT)
   {
     for(typename std::list<S>::const_iterator item = initial.begin();
       item != initial.end(); ++item)
     {
       US_DEBUG << "ModuleAbstractTracked::setInitial: " << (*item);
     }
   }
 }
 
 template<class S, class TTT, class R>
 void ModuleAbstractTracked<S,TTT,R>::TrackInitial()
 {
   while (true)
   {
     S item;
     {
       US_UNUSED(Lock(this));
       if (closed || (initial.size() == 0))
       {
         /*
          * if there are no more initial items
          */
         return; /* we are done */
       }
       /*
        * move the first item from the initial list to the adding list
        * within this synchronized block.
        */
       item = initial.front();
       initial.pop_front();
       if (TTT::IsValid(tracked[item]))
       {
         /* if we are already tracking this item */
         US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::trackInitial[already tracked]: " << item;
         continue; /* skip this item */
       }
       if (std::find(adding.begin(), adding.end(), item) != adding.end())
       {
         /*
          * if this item is already in the process of being added.
          */
         US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::trackInitial[already adding]: " << item;
         continue; /* skip this item */
       }
       adding.push_back(item);
     }
     US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::trackInitial: " << item;
     TrackAdding(item, R());
     /*
      * Begin tracking it. We call trackAdding
      * since we have already put the item in the
      * adding list.
      */
   }
 }
 
 template<class S, class TTT, class R>
 void ModuleAbstractTracked<S,TTT,R>::Close()
 {
   closed = true;
 }
 
 template<class S, class TTT, class R>
 void ModuleAbstractTracked<S,TTT,R>::Track(S item, R related)
 {
   T object = TTT::DefaultValue();
   {
     US_UNUSED(Lock(this));
     if (closed)
     {
       return;
     }
     object = tracked[item];
     if (!TTT::IsValid(object))
     { /* we are not tracking the item */
       if (std::find(adding.begin(), adding.end(),item) != adding.end())
       {
         /* if this item is already in the process of being added. */
         US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::track[already adding]: " << item;
         return;
       }
       adding.push_back(item); /* mark this item is being added */
     }
     else
     { /* we are currently tracking this item */
       US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::track[modified]: " << item;
       Modified(); /* increment modification count */
     }
   }
 
   if (!TTT::IsValid(object))
   { /* we are not tracking the item */
     TrackAdding(item, related);
   }
   else
   {
     /* Call customizer outside of synchronized region */
     CustomizerModified(item, related, object);
     /*
      * If the customizer throws an unchecked exception, it is safe to
      * let it propagate
      */
   }
 }
 
 template<class S, class TTT, class R>
 void ModuleAbstractTracked<S,TTT,R>::Untrack(S item, R related)
 {
   T object = TTT::DefaultValue();
   {
     US_UNUSED(Lock(this));
     std::size_t initialSize = initial.size();
     initial.remove(item);
     if (initialSize != initial.size())
     { /* if this item is already in the list
        * of initial references to process
        */
       US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::untrack[removed from initial]: " << item;
       return; /* we have removed it from the list and it will not be
                * processed
                */
     }
 
     std::size_t addingSize = adding.size();
     adding.remove(item);
     if (addingSize != adding.size())
     { /* if the item is in the process of
        * being added
        */
       US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::untrack[being added]: " << item;
       return; /*
            * in case the item is untracked while in the process of
            * adding
            */
     }
     object = tracked[item];
     /*
      * must remove from tracker before
      * calling customizer callback
      */
     tracked.erase(item);
     if (!TTT::IsValid(object))
     { /* are we actually tracking the item */
       return;
     }
     Modified(); /* increment modification count */
   }
   US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::untrack[removed]: " << item;
   /* Call customizer outside of synchronized region */
   CustomizerRemoved(item, related, object);
   /*
    * If the customizer throws an unchecked exception, it is safe to let it
    * propagate
    */
 }
 
 template<class S, class TTT, class R>
 std::size_t ModuleAbstractTracked<S,TTT,R>::Size() const
 {
   return tracked.size();
 }
 
 template<class S, class TTT, class R>
 bool ModuleAbstractTracked<S,TTT,R>::IsEmpty() const
 {
   return tracked.empty();
 }
 
 template<class S, class TTT, class R>
 typename ModuleAbstractTracked<S,TTT,R>::T
 ModuleAbstractTracked<S,TTT,R>::GetCustomizedObject(S item) const
 {
   typename TrackingMap::const_iterator i = tracked.find(item);
   if (i != tracked.end()) return i->second;
   return T();
 }
 
 template<class S, class TTT, class R>
 void ModuleAbstractTracked<S,TTT,R>::GetTracked(std::vector<S>& items) const
 {
   for (typename TrackingMap::const_iterator i = tracked.begin();
        i != tracked.end(); ++i)
   {
     items.push_back(i->first);
   }
 }
 
 template<class S, class TTT, class R>
 void ModuleAbstractTracked<S,TTT,R>::Modified()
 {
   trackingCount.Ref();
 }
 
 template<class S, class TTT, class R>
 int ModuleAbstractTracked<S,TTT,R>::GetTrackingCount() const
 {
   return trackingCount;
 }
 
 template<class S, class TTT, class R>
 void ModuleAbstractTracked<S,TTT,R>::CopyEntries(TrackingMap& map) const
 {
   map.insert(tracked.begin(), tracked.end());
 }
 
 template<class S, class TTT, class R>
 bool ModuleAbstractTracked<S,TTT,R>::CustomizerAddingFinal(S item, const T& custom)
 {
   US_UNUSED(Lock(this));
   std::size_t addingSize = adding.size();
   adding.remove(item);
   if (addingSize != adding.size() && !closed)
   {
     /*
      * if the item was not untracked during the customizer
      * callback
      */
     if (TTT::IsValid(custom))
     {
       tracked[item] = custom;
       Modified(); /* increment modification count */
       this->NotifyAll(); /* notify any waiters */
     }
     return false;
   }
   else
   {
     return true;
   }
 }
 
 template<class S, class TTT, class R>
 void ModuleAbstractTracked<S,TTT,R>::TrackAdding(S item, R related)
 {
   US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::trackAdding:" << item;
   T object = TTT::DefaultValue();
   bool becameUntracked = false;
   /* Call customizer outside of synchronized region */
   try
   {
     object = CustomizerAdding(item, related);
     becameUntracked = this->CustomizerAddingFinal(item, object);
   }
   catch (...)
   {
     /*
      * If the customizer throws an exception, it will
      * propagate after the cleanup code.
      */
     this->CustomizerAddingFinal(item, object);
     throw;
   }
 
   /*
    * The item became untracked during the customizer callback.
    */
   if (becameUntracked && TTT::IsValid(object))
   {
     US_DEBUG(DEBUG_OUTPUT) << "ModuleAbstractTracked::trackAdding[removed]: " << item;
     /* Call customizer outside of synchronized region */
     CustomizerRemoved(item, related, object);
     /*
      * If the customizer throws an unchecked exception, it is safe to
      * let it propagate
      */
   }
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleAbstractTracked_p.h b/Modules/CppMicroServices/core/src/module/usModuleAbstractTracked_p.h
index 1f09be6aa1..c1a6ac0a13 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleAbstractTracked_p.h
+++ b/Modules/CppMicroServices/core/src/module/usModuleAbstractTracked_p.h
@@ -1,293 +1,293 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USMODULEABSTRACTTRACKED_H
 #define USMODULEABSTRACTTRACKED_H
 
 #include <vector>
 
 #include "usAtomicInt_p.h"
 #include "usAny.h"
 
 US_BEGIN_NAMESPACE
 
 /**
  * This class is not intended to be used directly. It is exported to support
  * the CppMicroServices module system.
  *
  * Abstract class to track items. If a Tracker is reused (closed then reopened),
  * then a new ModuleAbstractTracked object is used. This class acts as a map of tracked
  * item -> customized object. Subclasses of this class will act as the listener
  * object for the tracker. This class is used to synchronize access to the
  * tracked items. This is not a public class. It is only for use by the
  * implementation of the Tracker class.
  *
  * @tparam S The tracked item. It is the key.
  * @tparam T The value mapped to the tracked item.
  * @tparam R The reason the tracked item is  being tracked or untracked.
  * @ThreadSafe
  */
 template<class S, class TTT, class R>
 class ModuleAbstractTracked : public MultiThreaded<MutexLockingStrategy,WaitCondition>
 {
 
 public:
 
   typedef typename TTT::TrackedType T;
 
   /* set this to true to compile in debug messages */
   static const bool DEBUG_OUTPUT; // = false;
 
   typedef std::map<S,T> TrackingMap;
 
   /**
    * ModuleAbstractTracked constructor.
    */
   ModuleAbstractTracked();
 
   virtual ~ModuleAbstractTracked();
 
   /**
    * Set initial list of items into tracker before events begin to be
    * received.
    *
    * This method must be called from Tracker's open method while synchronized
    * on this object in the same synchronized block as the add listener call.
    *
    * @param list The initial list of items to be tracked. <code>null</code>
    *        entries in the list are ignored.
    * @GuardedBy this
    */
   void SetInitial(const std::vector<S>& list);
 
   /**
    * Track the initial list of items. This is called after events can begin to
    * be received.
    *
    * This method must be called from Tracker's open method while not
    * synchronized on this object after the add listener call.
    *
    */
   void TrackInitial();
 
   /**
    * Called by the owning Tracker object when it is closed.
    */
   void Close();
 
   /**
    * Begin to track an item.
    *
    * @param item S to be tracked.
    * @param related Action related object.
    */
   void Track(S item, R related);
 
   /**
    * Discontinue tracking the item.
    *
    * @param item S to be untracked.
    * @param related Action related object.
    */
   void Untrack(S item, R related);
 
   /**
    * Returns the number of tracked items.
    *
    * @return The number of tracked items.
    *
    * @GuardedBy this
    */
   std::size_t Size() const;
 
   /**
    * Returns if the tracker is empty.
    *
    * @return Whether the tracker is empty.
    *
    * @GuardedBy this
    */
   bool IsEmpty() const;
 
   /**
    * Return the customized object for the specified item
    *
    * @param item The item to lookup in the map
    * @return The customized object for the specified item.
    *
    * @GuardedBy this
    */
   T GetCustomizedObject(S item) const;
 
   /**
    * Return the list of tracked items.
    *
    * @return The tracked items.
    * @GuardedBy this
    */
   void GetTracked(std::vector<S>& items) const;
 
   /**
    * Increment the modification count. If this method is overridden, the
    * overriding method MUST call this method to increment the tracking count.
    *
    * @GuardedBy this
    */
   virtual void Modified();
 
   /**
    * Returns the tracking count for this <code>ServiceTracker</code> object.
    *
    * The tracking count is initialized to 0 when this object is opened. Every
    * time an item is added, modified or removed from this object the tracking
    * count is incremented.
    *
    * @GuardedBy this
    * @return The tracking count for this object.
    */
   int GetTrackingCount() const;
 
   /**
    * Copy the tracked items and associated values into the specified map.
    *
    * @param map The map into which to copy the tracked items and associated
    *        values. This map must not be a user provided map so that user code
    *        is not executed while synchronized on this.
    * @return The specified map.
    * @GuardedBy this
    */
   void CopyEntries(TrackingMap& map) const;
 
   /**
    * Call the specific customizer adding method. This method must not be
    * called while synchronized on this object.
    *
    * @param item S to be tracked.
    * @param related Action related object.
    * @return Customized object for the tracked item or <code>null</code> if
    *         the item is not to be tracked.
    */
   virtual T CustomizerAdding(S item, const R& related) = 0;
 
   /**
    * Call the specific customizer modified method. This method must not be
    * called while synchronized on this object.
    *
    * @param item Tracked item.
    * @param related Action related object.
    * @param object Customized object for the tracked item.
    */
   virtual void CustomizerModified(S item, const R& related,
                                   T object) = 0;
 
   /**
    * Call the specific customizer removed method. This method must not be
    * called while synchronized on this object.
    *
    * @param item Tracked item.
    * @param related Action related object.
    * @param object Customized object for the tracked item.
    */
   virtual void CustomizerRemoved(S item, const R& related,
                                  T object) = 0;
 
   /**
    * List of items in the process of being added. This is used to deal with
    * nesting of events. Since events may be synchronously delivered, events
    * can be nested. For example, when processing the adding of a service and
    * the customizer causes the service to be unregistered, notification to the
    * nested call to untrack that the service was unregistered can be made to
    * the track method.
    *
    * Since the std::vector implementation is not synchronized, all access to
    * this list must be protected by the same synchronized object for
    * thread-safety.
    *
    * @GuardedBy this
    */
   std::list<S> adding;
 
   /**
    * true if the tracked object is closed.
    *
    * This field is volatile because it is set by one thread and read by
    * another.
    */
   volatile bool closed;
 
   /**
    * Initial list of items for the tracker. This is used to correctly process
    * the initial items which could be modified before they are tracked. This
    * is necessary since the initial set of tracked items are not "announced"
    * by events and therefore the event which makes the item untracked could be
    * delivered before we track the item.
    *
    * An item must not be in both the initial and adding lists at the same
    * time. An item must be moved from the initial list to the adding list
    * "atomically" before we begin tracking it.
    *
    * Since the LinkedList implementation is not synchronized, all access to
    * this list must be protected by the same synchronized object for
    * thread-safety.
    *
    * @GuardedBy this
    */
   std::list<S> initial;
 
   /**
    * Common logic to add an item to the tracker used by track and
    * trackInitial. The specified item must have been placed in the adding list
    * before calling this method.
    *
    * @param item S to be tracked.
    * @param related Action related object.
    */
   void TrackAdding(S item, R related);
 
 private:
 
   typedef ModuleAbstractTracked<S,TTT,R> Self;
 
   /**
    * Map of tracked items to customized objects.
    *
    * @GuardedBy this
    */
   TrackingMap tracked;
 
   /**
    * Modification count. This field is initialized to zero and incremented by
    * modified.
    *
    * @GuardedBy this
    */
   AtomicInt trackingCount;
 
   bool CustomizerAddingFinal(S item, const T& custom);
 
 };
 
 US_END_NAMESPACE
 
 #include "usModuleAbstractTracked.tpp"
 
 #endif // USMODULEABSTRACTTRACKED_H
diff --git a/Modules/CppMicroServices/core/src/module/usModuleContext.cpp b/Modules/CppMicroServices/core/src/module/usModuleContext.cpp
index 05ffd4c5f5..1f92098b8b 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleContext.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleContext.cpp
@@ -1,196 +1,196 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleContext.h"
 
 #include "usModuleRegistry.h"
 #include "usModulePrivate.h"
 #include "usModuleSettings.h"
 #include "usCoreModuleContext_p.h"
 #include "usServiceRegistry_p.h"
 #include "usServiceReferenceBasePrivate.h"
 
 #include <cstdio>
 
 US_BEGIN_NAMESPACE
 
 class ModuleContextPrivate {
 
 public:
 
   ModuleContextPrivate(ModulePrivate* module)
   : module(module)
   {}
 
   ModulePrivate* module;
 };
 
 
 ModuleContext::ModuleContext(ModulePrivate* module)
   : d(new ModuleContextPrivate(module))
 {}
 
 ModuleContext::~ModuleContext()
 {
   delete d;
 }
 
 Module* ModuleContext::GetModule() const
 {
   return d->module->q;
 }
 
 Module* ModuleContext::GetModule(long id) const
 {
   return d->module->coreCtx->moduleHooks.FilterModule(this, ModuleRegistry::GetModule(id));
 }
 
 Module* ModuleContext::GetModule(const std::string& name)
 {
   return ModuleRegistry::GetModule(name);
 }
 
 std::vector<Module*> ModuleContext::GetModules() const
 {
   std::vector<Module*> modules = ModuleRegistry::GetModules();
   d->module->coreCtx->moduleHooks.FilterModules(this, modules);
   return modules;
 }
 
 ServiceRegistrationU ModuleContext::RegisterService(const InterfaceMap& service,
                                                     const ServiceProperties& properties)
 {
   return d->module->coreCtx->services.RegisterService(d->module, service, properties);
 }
 
 std::vector<ServiceReferenceU > ModuleContext::GetServiceReferences(const std::string& clazz,
                                                                     const std::string& filter)
 {
   std::vector<ServiceReferenceU> result;
   std::vector<ServiceReferenceBase> refs;
   d->module->coreCtx->services.Get(clazz, filter, d->module, refs);
   for (std::vector<ServiceReferenceBase>::const_iterator iter = refs.begin();
        iter != refs.end(); ++iter)
   {
     result.push_back(ServiceReferenceU(*iter));
   }
   return result;
 }
 
 ServiceReferenceU ModuleContext::GetServiceReference(const std::string& clazz)
 {
   return d->module->coreCtx->services.Get(d->module, clazz);
 }
 
 void* ModuleContext::GetService(const ServiceReferenceBase& reference)
 {
   if (!reference)
   {
     throw std::invalid_argument("Default constructed ServiceReference is not a valid input to GetService()");
   }
   return reference.d->GetService(d->module->q);
 }
 
 InterfaceMap ModuleContext::GetService(const ServiceReferenceU& reference)
 {
   if (!reference)
   {
     throw std::invalid_argument("Default constructed ServiceReference is not a valid input to GetService()");
   }
   return reference.d->GetServiceInterfaceMap(d->module->q);
 }
 
 bool ModuleContext::UngetService(const ServiceReferenceBase& reference)
 {
   ServiceReferenceBase ref = reference;
   return ref.d->UngetService(d->module->q, true);
 }
 
 void ModuleContext::AddServiceListener(const ServiceListener& delegate,
                                        const std::string& filter)
 {
   d->module->coreCtx->listeners.AddServiceListener(this, delegate, nullptr, filter);
 }
 
 void ModuleContext::RemoveServiceListener(const ServiceListener& delegate)
 {
   d->module->coreCtx->listeners.RemoveServiceListener(this, delegate, nullptr);
 }
 
 void ModuleContext::AddModuleListener(const ModuleListener& delegate)
 {
   d->module->coreCtx->listeners.AddModuleListener(this, delegate, nullptr);
 }
 
 void ModuleContext::RemoveModuleListener(const ModuleListener& delegate)
 {
   d->module->coreCtx->listeners.RemoveModuleListener(this, delegate, nullptr);
 }
 
 void ModuleContext::AddServiceListener(const ServiceListener& delegate, void* data,
                                        const std::string &filter)
 {
   d->module->coreCtx->listeners.AddServiceListener(this, delegate, data, filter);
 }
 
 void ModuleContext::RemoveServiceListener(const ServiceListener& delegate, void* data)
 {
   d->module->coreCtx->listeners.RemoveServiceListener(this, delegate, data);
 }
 
 void ModuleContext::AddModuleListener(const ModuleListener& delegate, void* data)
 {
   d->module->coreCtx->listeners.AddModuleListener(this, delegate, data);
 }
 
 void ModuleContext::RemoveModuleListener(const ModuleListener& delegate, void* data)
 {
   d->module->coreCtx->listeners.RemoveModuleListener(this, delegate, data);
 }
 
 std::string ModuleContext::GetDataFile(const std::string &filename) const
 {
   // compute the module storage path
 #ifdef US_PLATFORM_WINDOWS
     static const char separator = '\\';
 #else
     static const char separator = '/';
 #endif
 
   std::string baseStoragePath = ModuleSettings::GetStoragePath();
   if (baseStoragePath.empty()) return std::string();
   if (baseStoragePath != d->module->baseStoragePath)
   {
     d->module->baseStoragePath = baseStoragePath;
     d->module->storagePath.clear();
   }
 
   if (d->module->storagePath.empty())
   {
     char buf[50];
     sprintf(buf, "%ld", d->module->info.id);
     d->module->storagePath = baseStoragePath + separator + buf + "_" + d->module->info.name + separator;
   }
   return d->module->storagePath + filename;
 }
 
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleEvent.cpp b/Modules/CppMicroServices/core/src/module/usModuleEvent.cpp
index 3378fa788e..5b1613901b 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleEvent.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleEvent.cpp
@@ -1,119 +1,119 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleEvent.h"
 
 #include "usModule.h"
 
 US_BEGIN_NAMESPACE
 
 class ModuleEventData : public SharedData
 {
 public:
 
   ModuleEventData(ModuleEvent::Type type, Module* module)
     : type(type), module(module)
   {
 
   }
 
   ModuleEventData(const ModuleEventData& other)
     : SharedData(other), type(other.type), module(other.module)
   {
 
   }
 
   const ModuleEvent::Type type;
   Module* const module;
 
 private:
 
   // purposely not implemented
   ModuleEventData& operator=(const ModuleEventData&);
 };
 
 ModuleEvent::ModuleEvent()
   : d(nullptr)
 {
 
 }
 
 ModuleEvent::~ModuleEvent()
 {
 
 }
 
 bool ModuleEvent::IsNull() const
 {
   return !d;
 }
 
 ModuleEvent::ModuleEvent(Type type, Module* module)
   : d(new ModuleEventData(type, module))
 {
 
 }
 
 ModuleEvent::ModuleEvent(const ModuleEvent& other)
   : d(other.d)
 {
 
 }
 
 ModuleEvent& ModuleEvent::operator=(const ModuleEvent& other)
 {
   d = other.d;
   return *this;
 }
 
 Module* ModuleEvent::GetModule() const
 {
   return d->module;
 }
 
 ModuleEvent::Type ModuleEvent::GetType() const
 {
   return d->type;
 }
 
 std::ostream& operator<<(std::ostream& os, ModuleEvent::Type eventType)
 {
   switch (eventType)
   {
   case ModuleEvent::LOADED:    return os << "LOADED";
   case ModuleEvent::UNLOADED:  return os << "UNLOADED";
   case ModuleEvent::LOADING:   return os << "LOADING";
   case ModuleEvent::UNLOADING: return os << "UNLOADING";
 
   default: return os << "Unknown module event type (" << static_cast<int>(eventType) << ")";
   }
 }
 
 std::ostream& operator<<(std::ostream& os, const ModuleEvent& event)
 {
   if (event.IsNull()) return os << "NONE";
 
   Module* m = event.GetModule();
   os << event.GetType() << " #" << m->GetModuleId() << " (" << m->GetLocation() << ")";
   return os;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleEventHook.cpp b/Modules/CppMicroServices/core/src/module/usModuleEventHook.cpp
index f49842e6fa..43b579f020 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleEventHook.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleEventHook.cpp
@@ -1,30 +1,30 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleEventHook.h"
 
 US_BEGIN_NAMESPACE
 
 ModuleEventHook::~ModuleEventHook()
 {
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleFindHook.cpp b/Modules/CppMicroServices/core/src/module/usModuleFindHook.cpp
index 93c9880271..e928171051 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleFindHook.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleFindHook.cpp
@@ -1,30 +1,30 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleFindHook.h"
 
 US_BEGIN_NAMESPACE
 
 ModuleFindHook::~ModuleFindHook()
 {
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleHooks.cpp b/Modules/CppMicroServices/core/src/module/usModuleHooks.cpp
index 3014222275..2a9af393c3 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleHooks.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleHooks.cpp
@@ -1,170 +1,170 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleHooks_p.h"
 
 #include "usModuleEventHook.h"
 #include "usModuleFindHook.h"
 #include "usCoreModuleContext_p.h"
 #include "usGetModuleContext.h"
 #include "usModuleContext.h"
 #include "usServiceReferenceBasePrivate.h"
 
 US_BEGIN_NAMESPACE
 
 ModuleHooks::ModuleHooks(CoreModuleContext* ctx)
   : coreCtx(ctx)
 {
 }
 
 Module* ModuleHooks::FilterModule(const ModuleContext* mc, Module* module) const
 {
   if(module == nullptr)
   {
     return nullptr;
   }
 
   std::vector<ServiceRegistrationBase> srl;
   coreCtx->services.Get(us_service_interface_iid<ModuleFindHook>(), srl);
   if (srl.empty())
   {
     return module;
   }
   else
   {
     std::vector<Module*> ml;
     ml.push_back(module);
     this->FilterModules(mc, ml);
     return ml.empty() ? nullptr : module;
   }
 }
 
 void ModuleHooks::FilterModules(const ModuleContext* mc, std::vector<Module*>& modules) const
 {
   std::vector<ServiceRegistrationBase> srl;
   coreCtx->services.Get(us_service_interface_iid<ModuleFindHook>(), srl);
   ShrinkableVector<Module*> filtered(modules);
 
   std::sort(srl.begin(), srl.end());
   for (std::vector<ServiceRegistrationBase>::reverse_iterator srBaseIter = srl.rbegin(), srBaseEnd = srl.rend();
        srBaseIter != srBaseEnd; ++srBaseIter)
   {
     ServiceReference<ModuleFindHook> sr = srBaseIter->GetReference();
     ModuleFindHook* const fh = reinterpret_cast<ModuleFindHook*>(sr.d->GetService(GetModuleContext()->GetModule()));
     if (fh != nullptr)
     {
       try
       {
         fh->Find(mc, filtered);
       }
       catch (const std::exception& e)
       {
         US_WARN << "Failed to call Module FindHook  #" << sr.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                 << ": " << e.what();
       }
       catch (...)
       {
         US_WARN << "Failed to call Module FindHook  #" << sr.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                 << ": unknown exception type";
       }
     }
   }
 }
 
 void ModuleHooks::FilterModuleEventReceivers(const ModuleEvent& evt,
                                              ServiceListeners::ModuleListenerMap& moduleListeners)
 {
   std::vector<ServiceRegistrationBase> eventHooks;
   coreCtx->services.Get(us_service_interface_iid<ModuleEventHook>(), eventHooks);
 
   {
     MutexLock lock(coreCtx->listeners.moduleListenerMapMutex);
     moduleListeners = coreCtx->listeners.moduleListenerMap;
   }
 
   if(!eventHooks.empty())
   {
     std::vector<ModuleContext*> moduleContexts;
     for (ServiceListeners::ModuleListenerMap::iterator le = moduleListeners.begin(),
          leEnd = moduleListeners.end(); le != leEnd; ++le)
     {
       moduleContexts.push_back(le->first);
     }
     std::sort(moduleContexts.begin(), moduleContexts.end());
     moduleContexts.erase(std::unique(moduleContexts.begin(), moduleContexts.end()), moduleContexts.end());
 
     const std::size_t unfilteredSize = moduleContexts.size();
     ShrinkableVector<ModuleContext*> filtered(moduleContexts);
 
     std::sort(eventHooks.begin(), eventHooks.end());
     for (std::vector<ServiceRegistrationBase>::reverse_iterator iter = eventHooks.rbegin(),
          iterEnd = eventHooks.rend(); iter != iterEnd; ++iter)
     {
       ServiceReference<ModuleEventHook> sr;
       try
       {
         sr = iter->GetReference();
       }
       catch (const std::logic_error& e)
       {
         US_WARN << "Failed to get event hook service reference: " << e.what();
         continue;
       }
 
       ModuleEventHook* eh = reinterpret_cast<ModuleEventHook*>(sr.d->GetService(GetModuleContext()->GetModule()));
       if (eh != nullptr)
       {
         try
         {
           eh->Event(evt, filtered);
         }
         catch (const std::exception& e)
         {
           US_WARN << "Failed to call Module EventHook #" << sr.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                   << ": " << e.what();
         }
         catch (...)
         {
           US_WARN << "Failed to call Module EventHook #" << sr.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                   << ": unknown exception type";
         }
       }
     }
 
     if (unfilteredSize != moduleContexts.size())
     {
       for (ServiceListeners::ModuleListenerMap::iterator le = moduleListeners.begin();
            le != moduleListeners.end();)
       {
         if(std::find(moduleContexts.begin(), moduleContexts.end(), le->first) == moduleContexts.end())
         {
           moduleListeners.erase(le++);
         }
         else
         {
           ++le;
         }
       }
     }
   }
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleHooks_p.h b/Modules/CppMicroServices/core/src/module/usModuleHooks_p.h
index d32bad924a..37980a9c0e 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleHooks_p.h
+++ b/Modules/CppMicroServices/core/src/module/usModuleHooks_p.h
@@ -1,58 +1,58 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEHOOKS_P_H
 #define USMODULEHOOKS_P_H
 
 #include "usServiceListeners_p.h"
 
 #include <vector>
 
 US_BEGIN_NAMESPACE
 
 class CoreModuleContext;
 class Module;
 class ModuleContext;
 class ModuleEvent;
 
 class ModuleHooks
 {
 
 private:
 
   CoreModuleContext* const coreCtx;
 
 public:
 
   ModuleHooks(CoreModuleContext* ctx);
 
   Module* FilterModule(const ModuleContext* mc, Module* module) const;
 
   void FilterModules(const ModuleContext* mc, std::vector<Module*>& modules) const;
 
   void FilterModuleEventReceivers(const ModuleEvent& evt,
                                   ServiceListeners::ModuleListenerMap& moduleListeners);
 
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULEHOOKS_P_H
diff --git a/Modules/CppMicroServices/core/src/module/usModuleInfo.cpp b/Modules/CppMicroServices/core/src/module/usModuleInfo.cpp
index 36b13cf415..396ddccca0 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleInfo.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleInfo.cpp
@@ -1,33 +1,33 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleInfo.h"
 
 US_BEGIN_NAMESPACE
 
 ModuleInfo::ModuleInfo(const std::string& name)
   : name(name)
   , id(0)
 {
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleManifest.cpp b/Modules/CppMicroServices/core/src/module/usModuleManifest.cpp
index c897cfc168..1357195b35 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleManifest.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleManifest.cpp
@@ -1,156 +1,156 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleManifest_p.h"
 
 #include <nlohmann/json.hpp>
 
 #include <stdexcept>
 
 using namespace nlohmann;
 
 US_BEGIN_NAMESPACE
 
 namespace {
 
   typedef std::map<std::string, Any> AnyMap;
   typedef std::vector<Any> AnyVector;
 
   void ParseJsonObject(const json& jsonObject, AnyMap& anyMap);
   void ParseJsonArray(const json& jsonArray, AnyVector& anyVector);
 
   Any ParseJsonValue(const json& jsonValue)
   {
     if (jsonValue.is_object())
     {
       Any any = AnyMap();
       ParseJsonObject(jsonValue, ref_any_cast<AnyMap>(any));
       return any;
     }
     else if (jsonValue.is_array())
     {
       Any any = AnyVector();
       ParseJsonArray(jsonValue, ref_any_cast<AnyVector>(any));
       return any;
     }
     else if (jsonValue.is_string())
     {
       return Any(jsonValue.get<std::string>());
     }
     else if (jsonValue.is_boolean())
     {
       return Any(jsonValue.get<bool>());
     }
     else if (jsonValue.is_number_integer())
     {
       return Any(jsonValue.get<int>());
     }
     else if (jsonValue.is_number_float())
     {
       return Any(jsonValue.get<double>());
     }
 
     return Any();
   }
 
   void ParseJsonObject(const json& jsonObject, AnyMap& anyMap)
   {
     for (const auto& [key, jsonValue] : jsonObject.items())
     {
       Any anyValue = ParseJsonValue(jsonValue);
       if (!anyValue.Empty())
       {
         anyMap.insert(std::make_pair(key, anyValue));
       }
     }
   }
 
   void ParseJsonArray(const json& jsonArray, AnyVector& anyVector)
   {
     for (const auto& jsonValue : jsonArray)
     {
       Any anyValue = ParseJsonValue(jsonValue);
       if (!anyValue.Empty())
       {
         anyVector.push_back(anyValue);
       }
     }
   }
 
 }
 
 ModuleManifest::ModuleManifest()
 {
 }
 
 void ModuleManifest::Parse(std::istream& is)
 {
   json root;
 
   try
   {
     root = json::parse(is);
   }
   catch (const json::exception& e)
   {
     throw std::runtime_error(e.what());
   }
 
   if (!root.is_object())
   {
     throw std::runtime_error("The Json root element must be an object.");
   }
 
   ParseJsonObject(root, m_Properties);
 }
 
 bool ModuleManifest::Contains(const std::string& key) const
 {
   return m_Properties.count(key) > 0;
 }
 
 Any ModuleManifest::GetValue(const std::string& key) const
 {
   AnyMap::const_iterator iter = m_Properties.find(key);
   if (iter != m_Properties.end())
   {
     return iter->second;
   }
   return Any();
 }
 
 std::vector<std::string> ModuleManifest::GetKeys() const
 {
   std::vector<std::string> keys;
   for (AnyMap::const_iterator iter = m_Properties.begin();
        iter != m_Properties.end(); ++iter)
   {
     keys.push_back(iter->first);
   }
   return keys;
 }
 
 void ModuleManifest::SetValue(const std::string& key, const Any& value)
 {
   m_Properties[key] = value;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleManifest_p.h b/Modules/CppMicroServices/core/src/module/usModuleManifest_p.h
index 8a1b871780..8455c70345 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleManifest_p.h
+++ b/Modules/CppMicroServices/core/src/module/usModuleManifest_p.h
@@ -1,54 +1,54 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEMANIFEST_P_H
 #define USMODULEMANIFEST_P_H
 
 #include "usAny.h"
 
 US_BEGIN_NAMESPACE
 
 class ModuleManifest
 {
 public:
 
   ModuleManifest();
 
   void Parse(std::istream& is);
 
   bool Contains(const std::string& key) const;
 
   Any GetValue(const std::string& key) const;
 
   std::vector<std::string> GetKeys() const;
 
   void SetValue(const std::string& key, const Any& value);
 
 private:
 
   typedef std::map<std::string, Any> AnyMap;
 
   AnyMap m_Properties;
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULEMANIFEST_P_H
diff --git a/Modules/CppMicroServices/core/src/module/usModulePrivate.cpp b/Modules/CppMicroServices/core/src/module/usModulePrivate.cpp
index 21fcabbb3a..6dd0c70f05 100644
--- a/Modules/CppMicroServices/core/src/module/usModulePrivate.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModulePrivate.cpp
@@ -1,148 +1,148 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModulePrivate.h"
 
 #include "usModule.h"
 #include "usModuleContext.h"
 #include "usModuleActivator.h"
 #include "usModuleUtils_p.h"
 #include "usModuleSettings.h"
 #include "usModuleResource.h"
 #include "usModuleResourceStream.h"
 #include "usCoreModuleContext_p.h"
 #include "usServiceRegistration.h"
 #include "usServiceReferenceBasePrivate.h"
 
 #include <algorithm>
 #include <iterator>
 #include <cassert>
 #include <cstring>
 
 US_BEGIN_NAMESPACE
 
 AtomicInt ModulePrivate::idCounter;
 
 ModulePrivate::ModulePrivate(Module* qq, CoreModuleContext* coreCtx,
                              ModuleInfo* info)
   : coreCtx(coreCtx)
   , info(*info)
   , resourceContainer(info)
   , moduleContext(nullptr)
   , moduleActivator(nullptr)
   , q(qq)
 {
   // Check if the module provides a manifest.json file and if yes, parse it.
   if (resourceContainer.IsValid())
   {
     ModuleResource manifestRes("/manifest.json", resourceContainer);
     if (manifestRes)
     {
       ModuleResourceStream manifestStream(manifestRes);
       try
       {
         moduleManifest.Parse(manifestStream);
       }
       catch (const std::exception& e)
       {
         US_ERROR << "Parsing of manifest.json for module " << info->location << " failed: " << e.what();
       }
     }
   }
 
   // Check if we got version information and validate the version identifier
   if (moduleManifest.Contains(Module::PROP_VERSION()))
   {
     Any versionAny = moduleManifest.GetValue(Module::PROP_VERSION());
     std::string errMsg;
     if (versionAny.Type() != typeid(std::string))
     {
       errMsg = std::string("The version identifier must be a string");
     }
     try
     {
       version = ModuleVersion(versionAny.ToString());
     }
     catch (const std::exception& e)
     {
       errMsg = std::string("The version identifier is invalid: ") + e.what();
     }
 
     if (!errMsg.empty())
     {
       throw std::invalid_argument(std::string("The Json value for ") + Module::PROP_VERSION() + " for module " +
                                   info->location + " is not valid: " + errMsg);
     }
   }
 
   std::stringstream propId;
   propId << this->info.id;
   moduleManifest.SetValue(Module::PROP_ID(), propId.str());
   moduleManifest.SetValue(Module::PROP_LOCATION(), this->info.location);
   moduleManifest.SetValue(Module::PROP_NAME(), this->info.name);
 
   if (moduleManifest.Contains(Module::PROP_AUTOLOAD_DIR()))
   {
     this->info.autoLoadDir = moduleManifest.GetValue(Module::PROP_AUTOLOAD_DIR()).ToString();
   }
   else
   {
     this->info.autoLoadDir = this->info.name;
     moduleManifest.SetValue(Module::PROP_AUTOLOAD_DIR(), Any(this->info.autoLoadDir));
   }
 }
 
 ModulePrivate::~ModulePrivate()
 {
   delete moduleContext;
 }
 
 void ModulePrivate::RemoveModuleResources()
 {
   coreCtx->listeners.RemoveAllListeners(moduleContext);
 
   std::vector<ServiceRegistrationBase> srs;
   coreCtx->services.GetRegisteredByModule(this, srs);
   for (std::vector<ServiceRegistrationBase>::iterator i = srs.begin();
        i != srs.end(); ++i)
   {
     try
     {
       i->Unregister();
     }
     catch (const std::logic_error& /*ignore*/)
     {
       // Someone has unregistered the service after stop completed.
       // This should not occur, but we don't want get stuck in
       // an illegal state so we catch it.
     }
   }
 
   srs.clear();
   coreCtx->services.GetUsedByModule(q, srs);
   for (std::vector<ServiceRegistrationBase>::const_iterator i = srs.begin();
        i != srs.end(); ++i)
   {
     i->GetReference(std::string()).d->UngetService(q, false);
   }
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModulePrivate.h b/Modules/CppMicroServices/core/src/module/usModulePrivate.h
index a61b7928f1..47032ffc9e 100644
--- a/Modules/CppMicroServices/core/src/module/usModulePrivate.h
+++ b/Modules/CppMicroServices/core/src/module/usModulePrivate.h
@@ -1,97 +1,97 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULEPRIVATE_H
 #define USMODULEPRIVATE_H
 
 #include <map>
 #include <list>
 
 #include "usModuleRegistry.h"
 #include "usModuleVersion.h"
 #include "usModuleInfo.h"
 #include "usModuleManifest_p.h"
 #include "usModuleResourceContainer_p.h"
 
 #include "usAtomicInt_p.h"
 
 US_BEGIN_NAMESPACE
 
 class CoreModuleContext;
 class ModuleContext;
 struct ModuleActivator;
 
 /**
  * \ingroup MicroServices
  */
 class ModulePrivate {
 
 public:
 
   /**
    * Construct a new module based on a ModuleInfo object.
    */
   ModulePrivate(Module* qq, CoreModuleContext* coreCtx, ModuleInfo* info);
 
   virtual ~ModulePrivate();
 
   void RemoveModuleResources();
 
   CoreModuleContext* const coreCtx;
 
   /**
    * Module version
    */
   ModuleVersion version;
 
   ModuleInfo info;
 
   ModuleResourceContainer resourceContainer;
 
   /**
    * ModuleContext for the module
    */
   ModuleContext* moduleContext;
 
   ModuleActivator* moduleActivator;
 
   ModuleManifest moduleManifest;
 
   std::string baseStoragePath;
   std::string storagePath;
 
   Module* const q;
 
 private:
 
   void InitializeResources();
 
   static AtomicInt idCounter;
 
   // purposely not implemented
   ModulePrivate(const ModulePrivate&);
   ModulePrivate& operator=(const ModulePrivate&);
 
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULEPRIVATE_H
diff --git a/Modules/CppMicroServices/core/src/module/usModuleRegistry.cpp b/Modules/CppMicroServices/core/src/module/usModuleRegistry.cpp
index d70a4d4616..b59e19d059 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleRegistry.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleRegistry.cpp
@@ -1,224 +1,224 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleRegistry.h"
 
 #include "usModule.h"
 #include "usModuleInfo.h"
 #include "usModuleContext.h"
 #include "usModuleActivator.h"
 #include "usModuleInitialization.h"
 #include "usCoreModuleContext_p.h"
 #include "usGetModuleContext.h"
 #include "usStaticInit_p.h"
 
 #include <cassert>
 #include <map>
 
 
 US_BEGIN_NAMESPACE
 
 typedef US_UNORDERED_MAP_TYPE<std::string, Module*> ModuleMap;
 
 US_GLOBAL_STATIC(CoreModuleContext, coreModuleContext)
 
 template<typename T>
 struct ModuleDeleter
 {
   void operator()(GlobalStatic<T>& globalStatic) const
   {
     ModuleMap* moduleMap = globalStatic.pointer;
     for (ModuleMap::const_iterator i = moduleMap->begin();
          i != moduleMap->end(); ++i)
     {
       delete i->second;
     }
     DefaultGlobalStaticDeleter<T> defaultDeleter;
     defaultDeleter(globalStatic);
   }
 };
 
 /**
  * Table of all installed modules in this framework.
  * Key is the module id.
  */
 US_GLOBAL_STATIC_WITH_DELETER(ModuleMap, modules, ModuleDeleter)
 
 /**
  * Lock for protecting the modules object
  */
 US_GLOBAL_STATIC(Mutex, modulesLock)
 
 /**
  * Lock for protecting the register count
  */
 US_GLOBAL_STATIC(Mutex, countLock)
 
 void ModuleRegistry::Register(ModuleInfo* info)
 {
   static long regCount = 0;
   if (info->id > 0)
   {
     // The module was already registered
     Module* module = nullptr;
     {
       MutexLock lock(*modulesLock());
       module = modules()->operator[](info->name);
       assert(module != nullptr);
     }
     module->Start();
   }
   else
   {
     Module* module = nullptr;
     // check if the module is reloaded
     {
       MutexLock lock(*modulesLock());
       ModuleMap* map = modules();
       for (ModuleMap::const_iterator i = map->begin();
            i != map->end(); ++i)
       {
         if (i->second->GetLocation() == info->location &&
             i->second->GetName() == info->name)
         {
           module = i->second;
           info->id = module->GetModuleId();
         }
       }
     }
 
     if (!module)
     {
       module = new Module();
       countLock()->Lock();
       info->id = ++regCount;
       assert(info->id == 1 ? info->name == "CppMicroServices" : true);
       countLock()->Unlock();
 
       module->Init(coreModuleContext(), info);
 
       MutexLock lock(*modulesLock());
       ModuleMap* map = modules();
       map->insert(std::make_pair(info->name, module));
     }
     else
     {
       module->Init(coreModuleContext(), info);
     }
 
     module->Start();
   }
 }
 
 void ModuleRegistry::UnRegister(const ModuleInfo* info)
 {
   if (info->id > 1)
   {
     Module* curr = nullptr;
     {
       MutexLock lock(*modulesLock());
       curr = modules()->operator[](info->name);
       assert(curr != nullptr);
     }
     curr->Stop();
   }
 }
 
 Module* ModuleRegistry::GetModule(long id)
 {
   MutexLock lock(*modulesLock());
 
   ModuleMap::const_iterator iter = modules()->begin();
   ModuleMap::const_iterator iterEnd = modules()->end();
   for (; iter != iterEnd; ++iter)
   {
     if (iter->second->GetModuleId() == id)
     {
       return iter->second;
     }
   }
   return nullptr;
 }
 
 Module* ModuleRegistry::GetModule(const std::string& name)
 {
   MutexLock lock(*modulesLock());
 
   ModuleMap::const_iterator iter = modules()->find(name);
   if (iter != modules()->end())
   {
     return iter->second;
   }
   return nullptr;
 }
 
 std::vector<Module*> ModuleRegistry::GetModules()
 {
   MutexLock lock(*modulesLock());
 
   std::vector<Module*> result;
   ModuleMap* map = modules();
   ModuleMap::const_iterator iter = map->begin();
   ModuleMap::const_iterator iterEnd = map->end();
   for (; iter != iterEnd; ++iter)
   {
     result.push_back(iter->second);
   }
   return result;
 }
 
 std::vector<Module*> ModuleRegistry::GetLoadedModules()
 {
   MutexLock lock(*modulesLock());
 
   std::vector<Module*> result;
   ModuleMap::const_iterator iter = modules()->begin();
   ModuleMap::const_iterator iterEnd = modules()->end();
   for (; iter != iterEnd; ++iter)
   {
     if (iter->second->IsLoaded())
     {
       result.push_back(iter->second);
     }
   }
   return result;
 }
 
 // Control the static initialization order for several core objects
 struct StaticInitializationOrder
 {
   StaticInitializationOrder()
   {
     ModuleSettings::GetLogLevel();
     modulesLock();
     countLock();
     modules();
     coreModuleContext();
   }
 };
 
 static StaticInitializationOrder _staticInitializationOrder;
 
 US_END_NAMESPACE
 
 // We initialize the CppMicroService module after making sure
 // that all other global statics have been initialized above
 US_INITIALIZE_MODULE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleResource.cpp b/Modules/CppMicroServices/core/src/module/usModuleResource.cpp
index 7485267b3f..2470563beb 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleResource.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleResource.cpp
@@ -1,289 +1,289 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleResource.h"
 
 #include "usAtomicInt_p.h"
 #include "usModuleResourceContainer_p.h"
 #include "usModuleInfo.h"
 
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 class ModuleResourcePrivate
 {
 
 public:
 
   ModuleResourcePrivate(const ModuleResourceContainer* rc)
     : resourceContainer(rc)
     , ref(1)
   {}
 
   void InitFilePath(const std::string& file);
 
   const ModuleResourceContainer* const resourceContainer;
 
   ModuleResourceContainer::Stat stat;
 
   std::string fileName;
   std::string path;
 
   mutable std::vector<std::string> children;
   mutable std::vector<uint32_t> childNodes;
 
   /**
    * Reference count for implicitly shared private implementation.
    */
   AtomicInt ref;
 };
 
 void ModuleResourcePrivate::InitFilePath(const std::string& file)
 {
   std::string normalizedFile = file;
   if (normalizedFile.empty() || normalizedFile[0] != '/')
   {
     normalizedFile = '/' + normalizedFile;
   }
 
   std::string rawPath;
   std::size_t index = normalizedFile.find_last_of('/');
   if (index == std::string::npos)
   {
     fileName = normalizedFile;
   }
   else if (index < normalizedFile.size()-1)
   {
     fileName = normalizedFile.substr(index+1);
     rawPath = normalizedFile.substr(0,index+1);
   }
   else
   {
     rawPath = normalizedFile;
   }
 
   // remove duplicate /
   std::string::value_type lastChar = 0;
   for (std::size_t i = 0; i < rawPath.size(); ++i)
   {
     if (rawPath[i] == '/' && lastChar == '/')
     {
       continue;
     }
     lastChar = rawPath[i];
     path.push_back(lastChar);
   }
   if (path.empty())
   {
     path.push_back('/');
   }
 }
 
 ModuleResource::ModuleResource()
   : d(new ModuleResourcePrivate(nullptr))
 {
 }
 
 ModuleResource::ModuleResource(const ModuleResource &resource)
   : d(resource.d)
 {
   d->ref.Ref();
 }
 
 ModuleResource::ModuleResource(const std::string& file, const ModuleResourceContainer& resourceContainer)
   : d(new ModuleResourcePrivate(&resourceContainer))
 {
   d->InitFilePath(file);
 
   d->stat.filePath = d->resourceContainer->GetModuleInfo()->name + d->path + d->fileName;
 
   d->resourceContainer->GetStat(d->stat);
 }
 
 ModuleResource::ModuleResource(int index, const ModuleResourceContainer& resourceContainer)
   : d(new ModuleResourcePrivate(&resourceContainer))
 {
   d->resourceContainer->GetStat(index, d->stat);
   d->InitFilePath(d->stat.filePath.substr(d->resourceContainer->GetModuleInfo()->name.size()));
 }
 
 ModuleResource::~ModuleResource()
 {
   if (!d->ref.Deref())
     delete d;
 }
 
 ModuleResource& ModuleResource::operator =(const ModuleResource& resource)
 {
   ModuleResourcePrivate* curr_d = d;
   d = resource.d;
   d->ref.Ref();
 
   if (!curr_d->ref.Deref())
     delete curr_d;
 
   return *this;
 }
 
 bool ModuleResource::operator <(const ModuleResource& resource) const
 {
   return this->GetResourcePath() < resource.GetResourcePath();
 }
 
 bool ModuleResource::operator ==(const ModuleResource& resource) const
 {
   return d->resourceContainer == resource.d->resourceContainer &&
       this->GetResourcePath() == resource.GetResourcePath();
 }
 
 bool ModuleResource::operator !=(const ModuleResource &resource) const
 {
   return !(*this == resource);
 }
 
 bool ModuleResource::IsValid() const
 {
   return d->resourceContainer && d->resourceContainer->IsValid() && d->stat.index > -1;
 }
 
 ModuleResource::operator bool_type() const
 {
   return IsValid() ? &ModuleResource::d : nullptr;
 }
 
 std::string ModuleResource::GetName() const
 {
   return d->fileName;
 }
 
 std::string ModuleResource::GetPath() const
 {
   return d->path;
 }
 
 std::string ModuleResource::GetResourcePath() const
 {
   return d->path + d->fileName;
 }
 
 std::string ModuleResource::GetBaseName() const
 {
   return d->fileName.substr(0, d->fileName.find_first_of('.'));
 }
 
 std::string ModuleResource::GetCompleteBaseName() const
 {
   return d->fileName.substr(0, d->fileName.find_last_of('.'));
 }
 
 std::string ModuleResource::GetSuffix() const
 {
   std::size_t index = d->fileName.find_last_of('.');
   return index < d->fileName.size()-1 ? d->fileName.substr(index+1) : std::string("");
 }
 
 std::string ModuleResource::GetCompleteSuffix() const
 {
   std::size_t index = d->fileName.find_first_of('.');
   return index < d->fileName.size()-1 ? d->fileName.substr(index+1) : std::string("");
 }
 
 bool ModuleResource::IsDir() const
 {
   return d->stat.isDir;
 }
 
 bool ModuleResource::IsFile() const
 {
   return !d->stat.isDir;
 }
 
 std::vector<std::string> ModuleResource::GetChildren() const
 {
   if (!IsValid() || !IsDir()) return d->children;
 
   if (d->children.empty())
   {
     d->resourceContainer->GetChildren(d->stat.filePath, true,
                                       d->children, d->childNodes);
   }
   return d->children;
 }
 
 std::vector<ModuleResource> ModuleResource::GetChildResources() const
 {
   std::vector<ModuleResource> childResources;
 
   if (!IsValid() || !IsDir()) return childResources;
 
   if (d->childNodes.empty())
   {
     d->resourceContainer->GetChildren(this->GetResourcePath(), true,
                                       d->children, d->childNodes);
   }
 
   for (std::vector<uint32_t>::const_iterator iter = d->childNodes.begin(),
        iterEnd = d->childNodes.end(); iter != iterEnd; ++iter)
   {
     childResources.push_back(ModuleResource(static_cast<int>(*iter), *d->resourceContainer));
   }
   return childResources;
 }
 
 int ModuleResource::GetSize() const
 {
   return d->stat.uncompressedSize;
 }
 
 time_t ModuleResource::GetLastModified() const
 {
   return d->stat.modifiedTime;
 }
 
 std::size_t ModuleResource::Hash() const
 {
   using namespace US_HASH_FUNCTION_NAMESPACE;
   return US_HASH_FUNCTION(std::string, d->resourceContainer->GetModuleInfo()->name + this->GetResourcePath());
 }
 
 void* ModuleResource::GetData() const
 {
   if (!IsValid()) return nullptr;
 
   void* data = d->resourceContainer->GetData(d->stat.index);
   if (data == nullptr)
   {
     US_WARN << "Error uncompressing resource data for " << this->GetResourcePath() << " from "
             << d->resourceContainer->GetModuleInfo()->location;
   }
   return data;
 }
 
 US_END_NAMESPACE
 
 US_USE_NAMESPACE
 
 std::ostream& operator<<(std::ostream& os, const ModuleResource& resource)
 {
   return os << resource.GetResourcePath();
 }
diff --git a/Modules/CppMicroServices/core/src/module/usModuleResourceBuffer.cpp b/Modules/CppMicroServices/core/src/module/usModuleResourceBuffer.cpp
index 456ccf590a..3ffe225092 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleResourceBuffer.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleResourceBuffer.cpp
@@ -1,287 +1,287 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleResourceBuffer_p.h"
 
 #include "us_stdint.h"
 
 #include <limits>
 #include <cassert>
 #include <cstdlib>
 
 #ifdef US_PLATFORM_WINDOWS
 #define DATA_NEEDS_NEWLINE_CONVERSION 1
 #undef REMOVE_LAST_NEWLINE_IN_TEXT_MODE
 #else
 #undef DATA_NEEDS_NEWLINE_CONVERSION
 #define REMOVE_LAST_NEWLINE_IN_TEXT_MODE 1
 #endif
 
 US_BEGIN_NAMESPACE
 
 class ModuleResourceBufferPrivate
 {
 public:
 
   ModuleResourceBufferPrivate(void* data, std::size_t size, const char* begin, std::ios_base::openmode mode)
     : begin(begin)
     , end(begin + size)
     , current(begin)
     , mode(mode)
     , uncompressedData(reinterpret_cast<unsigned char*>(data))
   #ifdef DATA_NEEDS_NEWLINE_CONVERSION
     , pos(0)
   #endif
   {
   }
 
   ~ModuleResourceBufferPrivate()
   {
     free(uncompressedData);
   }
 
   const char* const begin;
   const char* const end;
   const char* current;
 
   const std::ios_base::openmode mode;
 
   unsigned char* uncompressedData;
 
 #ifdef DATA_NEEDS_NEWLINE_CONVERSION
   // records the stream position ignoring CR characters
   std::streambuf::pos_type pos;
 #endif
 
 };
 
 ModuleResourceBuffer::ModuleResourceBuffer(void* data, std::size_t _size,
                                            std::ios_base::openmode mode)
   : d(nullptr)
 {
   assert(_size < static_cast<std::size_t>(std::numeric_limits<uint32_t>::max()));
   // assert(data != nullptr);
 
   char* begin = reinterpret_cast<char*>(data);
   std::size_t size = _size;
 
 #ifdef DATA_NEEDS_NEWLINE_CONVERSION
   if (data != nullptr && !(mode & std::ios_base::binary) && begin[0] == '\r')
   {
     ++begin;
     --size;
   }
 #endif
 
 #ifdef REMOVE_LAST_NEWLINE_IN_TEXT_MODE
   if (data != nullptr && !(mode & std::ios_base::binary) && begin[size-1] == '\n')
   {
     --size;
   }
 #endif
 
   d = new ModuleResourceBufferPrivate(data, size, begin, mode);
 }
 
 ModuleResourceBuffer::~ModuleResourceBuffer()
 {
   delete d;
 }
 
 ModuleResourceBuffer::int_type ModuleResourceBuffer::underflow()
 {
   if (d->current == d->end)
     return traits_type::eof();
 
 #ifdef DATA_NEEDS_NEWLINE_CONVERSION
   char c = *d->current;
   if (!(d->mode & std::ios_base::binary))
   {
     if (c == '\r')
     {
       if (d->current + 1 == d->end)
       {
         return traits_type::eof();
       }
       c = d->current[1];
     }
   }
   return traits_type::to_int_type(c);
 #else
   return traits_type::to_int_type(*d->current);
 #endif
 }
 
 ModuleResourceBuffer::int_type ModuleResourceBuffer::uflow()
 {
   if (d->current == d->end)
     return traits_type::eof();
 
 #ifdef DATA_NEEDS_NEWLINE_CONVERSION
   char c = *d->current++;
   if (!(d->mode & std::ios_base::binary))
   {
     if (c == '\r')
     {
       if (d->current == d->end)
       {
         return traits_type::eof();
       }
       c = *d->current++;
     }
   }
   return traits_type::to_int_type(c);
 #else
   return traits_type::to_int_type(*d->current++);
 #endif
 }
 
 ModuleResourceBuffer::int_type ModuleResourceBuffer::pbackfail(int_type ch)
 {
   int backOffset = -1;
 #ifdef DATA_NEEDS_NEWLINE_CONVERSION
   if (!(d->mode & std::ios_base::binary))
   {
     while ((d->current - backOffset) >= d->begin && d->current[backOffset] == '\r')
     {
       --backOffset;
     }
     // d->begin always points to a character != '\r'
   }
 #endif
   if (d->current == d->begin || (ch != traits_type::eof() && ch != d->current[backOffset]))
   {
     return traits_type::eof();
   }
 
   d->current += backOffset;
   return traits_type::to_int_type(*d->current);
 }
 
 std::streamsize ModuleResourceBuffer::showmanyc()
 {
   assert(d->current <= d->end);
 
 #ifdef DATA_NEEDS_NEWLINE_CONVERSION
   std::streamsize ssize = 0;
   std::size_t chunkSize = d->end - d->current;
   for (std::size_t i = 0; i < chunkSize; ++i)
   {
     if (d->current[i] != '\r')
     {
       ++ssize;
     }
   }
   return ssize;
 #else
   return d->end - d->current;
 #endif
 }
 
 std::streambuf::pos_type ModuleResourceBuffer::seekoff(std::streambuf::off_type off,
                                                        std::ios_base::seekdir way,
                                                        std::ios_base::openmode /*which*/)
 {
 #ifdef DATA_NEEDS_NEWLINE_CONVERSION
   std::streambuf::off_type step = 1;
   if (way == std::ios_base::beg)
   {
     d->current = d->begin;
   }
   else if (way == std::ios_base::end)
   {
     d->current = d->end;
     step = -1;
   }
 
   if (!(d->mode & std::ios_base::binary))
   {
     if (way == std::ios_base::beg)
     {
       d->pos = 0;
     }
     else if (way == std::ios_base::end)
     {
       d->current -= 1;
     }
 
     std::streambuf::off_type i = 0;
     // scan through off amount of characters excluding '\r'
     while (i != off)
     {
       if (*d->current != '\r')
       {
         i += step;
         d->pos += step;
       }
       d->current += step;
     }
 
     // adjust the position in case of a "backwards" seek
     if (way == std::ios_base::end)
     {
       // fix pointer from previous while loop
       d->current += 1;
       d->pos = 0;
       i = 0;
       const std::streampos currInternalPos = d->current - d->begin;
       while (i != currInternalPos)
       {
         if (d->begin[i] != '\r')
         {
           d->pos += 1;
         }
         ++i;
       }
     }
   }
   else
   {
     d->current += off;
     d->pos = d->current - d->begin;
   }
   return d->pos;
 #else
   if (way == std::ios_base::beg)
   {
     d->current = d->begin + off;
     return off;
   }
   else if (way == std::ios_base::cur)
   {
     d->current += off;
     return d->current - d->begin;
   }
   else
   {
     d->current = d->end + off;
     return d->current - d->begin;
   }
 #endif
 }
 
 std::streambuf::pos_type ModuleResourceBuffer::seekpos(std::streambuf::pos_type sp,
                                                        std::ios_base::openmode /*which*/)
 {
   return this->seekoff(sp, std::ios_base::beg);
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleResourceBuffer_p.h b/Modules/CppMicroServices/core/src/module/usModuleResourceBuffer_p.h
index 63fa6f2911..e4b8a42a9f 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleResourceBuffer_p.h
+++ b/Modules/CppMicroServices/core/src/module/usModuleResourceBuffer_p.h
@@ -1,68 +1,68 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULERESOURCEBUFFER_P_H
 #define USMODULERESOURCEBUFFER_P_H
 
 #include <usCoreExport.h>
 
 #include <streambuf>
 
 US_BEGIN_NAMESPACE
 
 class ModuleResourceBufferPrivate;
 
 class US_Core_EXPORT ModuleResourceBuffer: public std::streambuf
 {
 
 public:
 
   explicit ModuleResourceBuffer(void* data, std::size_t size,
                                 std::ios_base::openmode mode);
 
   ~ModuleResourceBuffer() override;
 
 private:
 
   int_type underflow() override;
 
   int_type uflow() override;
 
   int_type pbackfail(int_type ch) override;
 
   std::streamsize showmanyc() override;
 
   pos_type seekoff (off_type off, std::ios_base::seekdir way, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out) override;
   pos_type seekpos (pos_type sp, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out) override;
 
   // purposely not implemented
   ModuleResourceBuffer(const ModuleResourceBuffer&);
   ModuleResourceBuffer& operator=(const ModuleResourceBuffer&);
 
 private:
 
   ModuleResourceBufferPrivate* d;
 
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULERESOURCEBUFFER_P_H
diff --git a/Modules/CppMicroServices/core/src/module/usModuleResourceContainer.cpp b/Modules/CppMicroServices/core/src/module/usModuleResourceContainer.cpp
index 6068e9900a..0ece7a461e 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleResourceContainer.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleResourceContainer.cpp
@@ -1,229 +1,229 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleResourceContainer_p.h"
 
 #include "usModuleInfo.h"
 #include "usModuleUtils_p.h"
 #include "usModuleResource.h"
 #include "usLog_p.h"
 
 #include "miniz.h"
 
 #include <set>
 #include <cstring>
 #include <climits>
 #include <cassert>
 
 US_BEGIN_NAMESPACE
 
 struct ModuleResourceContainerPrivate
 {
   ModuleResourceContainerPrivate(const ModuleInfo* moduleInfo)
     : m_ModuleInfo(moduleInfo)
     , m_IsValid(false)
     , m_ZipArchive()
   {}
 
   typedef std::pair<std::string, int> NameIndexPair;
 
   struct PairComp
   {
     bool operator()(const NameIndexPair& p1, const NameIndexPair& p2) const
     {
       return p1.first < p2.first;
     }
   };
 
   typedef std::set<NameIndexPair, PairComp> SetType;
 
   void InitSortedEntries()
   {
     if (m_SortedEntries.empty())
     {
       mz_uint numFiles = mz_zip_reader_get_num_files(&m_ZipArchive);
       for (mz_uint fileIndex = 0; fileIndex < numFiles; ++fileIndex)
       {
         char fileName[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE];
         mz_zip_reader_get_filename(&m_ZipArchive, fileIndex, fileName, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE);
         m_SortedEntries.insert(std::make_pair(std::string(fileName), fileIndex));
       }
     }
   }
 
   const ModuleInfo* m_ModuleInfo;
   bool m_IsValid;
 
   mz_zip_archive m_ZipArchive;
 
   std::set<NameIndexPair, PairComp> m_SortedEntries;
 };
 
 ModuleResourceContainer::ModuleResourceContainer(const ModuleInfo* moduleInfo)
   : d(new ModuleResourceContainerPrivate(moduleInfo))
 {
   if (mz_zip_reader_init_file(&d->m_ZipArchive, moduleInfo->location.c_str(), 0))
   {
     d->m_IsValid = true;
   }
   else
   {
     US_DEBUG << "Could not init zip archive for module " << moduleInfo->name;
   }
 }
 
 ModuleResourceContainer::~ModuleResourceContainer()
 {
   if (IsValid())
   {
     mz_zip_reader_end(&d->m_ZipArchive);
   }
   delete d;
 }
 
 bool ModuleResourceContainer::IsValid() const
 {
   return d->m_IsValid;
 }
 
 bool ModuleResourceContainer::GetStat(ModuleResourceContainer::Stat& stat) const
 {
   if (IsValid())
   {
     int fileIndex = mz_zip_reader_locate_file(&d->m_ZipArchive, stat.filePath.c_str(), nullptr, 0);
     if (fileIndex >= 0)
     {
       return GetStat(fileIndex, stat);
     }
   }
   return false;
 }
 
 bool ModuleResourceContainer::GetStat(int index, ModuleResourceContainer::Stat& stat) const
 {
   if (IsValid())
   {
     if (index >= 0)
     {
       mz_zip_archive_file_stat zipStat;
       if (!mz_zip_reader_file_stat(&d->m_ZipArchive, index, &zipStat))
       {
         return false;
       }
       stat.index = index;
       stat.filePath = zipStat.m_filename;
       stat.isDir = mz_zip_reader_is_file_a_directory(&d->m_ZipArchive, index) ? true : false;
       stat.modifiedTime = zipStat.m_time;
       // This will limit the size info from uint64 to uint32 on 32-bit
       // architectures. We don't care because we assume resources > 2GB
       // don't make sense to be embedded in a module anyway.
       assert(zipStat.m_comp_size < INT_MAX);
       assert(zipStat.m_uncomp_size < INT_MAX);
       stat.uncompressedSize = static_cast<int>(zipStat.m_uncomp_size);
       return true;
     }
   }
   return false;
 }
 
 void* ModuleResourceContainer::GetData(int index) const
 {
   return mz_zip_reader_extract_to_heap(&d->m_ZipArchive, index, nullptr, 0);
 }
 
 const ModuleInfo*ModuleResourceContainer::GetModuleInfo() const
 {
   return d->m_ModuleInfo;
 }
 
 void ModuleResourceContainer::GetChildren(const std::string& resourcePath, bool relativePaths,
                                           std::vector<std::string>& names, std::vector<uint32_t>& indices) const
 {
   d->InitSortedEntries();
 
   ModuleResourceContainerPrivate::SetType::const_iterator iter =
       d->m_SortedEntries.find(std::make_pair(resourcePath, 0));
   if (iter == d->m_SortedEntries.end())
   {
     return;
   }
 
   for (++iter; iter != d->m_SortedEntries.end(); ++iter)
   {
     if (resourcePath.size() > iter->first.size()) break;
     if (iter->first.compare(0, resourcePath.size(), resourcePath) == 0)
     {
       std::size_t pos = iter->first.find_first_of('/', resourcePath.size());
       if (pos == std::string::npos || pos == iter->first.size()-1)
       {
         if (relativePaths)
         {
           names.push_back(iter->first.substr(resourcePath.size()));
         }
         else
         {
           names.push_back(iter->first);
         }
         indices.push_back(iter->second);
       }
     }
   }
 }
 
 void ModuleResourceContainer::FindNodes(const std::string& path, const std::string& filePattern,
                                         bool recurse, std::vector<ModuleResource>& resources) const
 {
   std::vector<std::string> names;
   std::vector<uint32_t> indices;
 
   this->GetChildren(path, true, names, indices);
 
   for(std::size_t i = 0, s = names.size(); i < s; ++i)
   {
     if (*names[i].rbegin() == '/' && recurse)
     {
       this->FindNodes(path + names[i], filePattern, recurse, resources);
     }
     if (this->Matches(names[i], filePattern))
     {
       resources.push_back(ModuleResource(indices[i], *this));
     }
   }
 }
 
 bool ModuleResourceContainer::Matches(const std::string& name, const std::string& filePattern) const
 {
   // short-cut
   if (filePattern == "*") return true;
 
   std::stringstream ss(filePattern);
   std::string tok;
   std::size_t pos = 0;
   while(std::getline(ss, tok, '*'))
   {
     std::size_t index = name.find(tok, pos);
     if (index == std::string::npos) return false;
     pos = index + tok.size();
   }
   return true;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleResourceContainer_p.h b/Modules/CppMicroServices/core/src/module/usModuleResourceContainer_p.h
index 9692c25ceb..f215bcfafe 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleResourceContainer_p.h
+++ b/Modules/CppMicroServices/core/src/module/usModuleResourceContainer_p.h
@@ -1,88 +1,88 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USMODULERESOURCECONTAINER_P_H
 #define USMODULERESOURCECONTAINER_P_H
 
 #include "usGlobalConfig.h"
 #include "us_stdint.h"
 
 #include <ctime>
 #include <string>
 #include <vector>
 
 US_BEGIN_NAMESPACE
 
 struct ModuleInfo;
 class ModuleResource;
 struct ModuleResourceContainerPrivate;
 
 class ModuleResourceContainer
 {
 
 public:
 
   ModuleResourceContainer(const ModuleInfo* moduleInfo);
   ~ModuleResourceContainer();
 
   struct Stat
   {
     Stat()
       : index(-1)
       , uncompressedSize(0)
       , modifiedTime(0)
       , isDir(false)
     {}
 
     std::string filePath;
     int index;
     int uncompressedSize;
     time_t modifiedTime;
     bool isDir;
   };
 
   bool IsValid() const;
 
   bool GetStat(Stat& stat) const;
   bool GetStat(int index, Stat& stat) const;
 
   void* GetData(int index) const;
 
   const ModuleInfo* GetModuleInfo() const;
 
   void GetChildren(const std::string& resourcePath, bool relativePaths,
                    std::vector<std::string>& names, std::vector<uint32_t>& indices) const;
 
   void FindNodes(const std::string& path, const std::string& filePattern,
                  bool recurse, std::vector<ModuleResource>& resources) const;
 
 private:
 
   bool Matches(const std::string& name, const std::string& filePattern) const;
 
   ModuleResourceContainerPrivate* d;
 
 };
 
 
 US_END_NAMESPACE
 
 #endif // USMODULERESOURCECONTAINER_P_H
diff --git a/Modules/CppMicroServices/core/src/module/usModuleResourceStream.cpp b/Modules/CppMicroServices/core/src/module/usModuleResourceStream.cpp
index 21b84b4382..7f2d5814e5 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleResourceStream.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleResourceStream.cpp
@@ -1,39 +1,39 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleResourceStream.h"
 
 #include "usModuleResource.h"
 
 // 'this' used in base member initializer list
 US_MSVC_PUSH_DISABLE_WARNING(4355)
 
 US_BEGIN_NAMESPACE
 
 ModuleResourceStream::ModuleResourceStream(const ModuleResource& resource, std::ios_base::openmode mode)
   : ModuleResourceBuffer(resource.GetData(), resource.GetSize(), mode | std::ios_base::in)
   , std::istream(this)
 {
 }
 
 US_END_NAMESPACE
 
 US_MSVC_POP_WARNING
diff --git a/Modules/CppMicroServices/core/src/module/usModuleSettings.cpp b/Modules/CppMicroServices/core/src/module/usModuleSettings.cpp
index cf3176d306..8d9b38aad6 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleSettings.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleSettings.cpp
@@ -1,189 +1,189 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleSettings.h"
 #include "usThreads_p.h"
 #include "usStaticInit_p.h"
 
 #include <string>
 #include <sstream>
 #include <set>
 #include <algorithm>
 #include <cctype>
 
 US_BEGIN_NAMESPACE
 
 namespace {
 
   std::string RemoveTrailingPathSeparator(const std::string& in)
   {
 #ifdef US_PLATFORM_WINDOWS
     const char separator = '\\';
 #else
     const char separator = '/';
 #endif
     if (in.empty()) return in;
     std::string::const_iterator lastChar = --in.end();
     while (lastChar != in.begin() && std::isspace(*lastChar)) lastChar--;
     if (*lastChar != separator) lastChar++;
     std::string::const_iterator firstChar = in.begin();
     while (firstChar < lastChar && std::isspace(*firstChar)) firstChar++;
     return std::string(firstChar, lastChar);
   }
 
 }
 
 std::string ModuleSettings::CURRENT_MODULE_PATH()
 {
   static const std::string var = "us_current_module_path";
   return var;
 }
 
 struct ModuleSettingsPrivate : public MultiThreaded<>
 {
   ModuleSettingsPrivate()
     : autoLoadPaths()
   #ifdef US_ENABLE_AUTOLOADING_SUPPORT
     , autoLoadingEnabled(true)
   #else
     , autoLoadingEnabled(false)
   #endif
     , autoLoadingDisabled(false)
     , logLevel(DebugMsg)
   {
     autoLoadPaths.insert(ModuleSettings::CURRENT_MODULE_PATH());
 
     char* envPaths = getenv("US_AUTOLOAD_PATHS");
     if (envPaths != nullptr)
     {
       std::stringstream ss(envPaths);
       std::string envPath;
 #ifdef US_PLATFORM_WINDOWS
       const char separator = ';';
 #else
       const char separator = ':';
 #endif
       while (std::getline(ss, envPath, separator))
       {
         std::string normalizedEnvPath = RemoveTrailingPathSeparator(envPath);
         if (!normalizedEnvPath.empty())
         {
           extraPaths.insert(normalizedEnvPath);
         }
       }
     }
 
     if (getenv("US_DISABLE_AUTOLOADING"))
     {
       autoLoadingDisabled = true;
     }
   }
 
   std::set<std::string> autoLoadPaths;
   std::set<std::string> extraPaths;
   bool autoLoadingEnabled;
   bool autoLoadingDisabled;
   std::string storagePath;
   MsgType logLevel;
 };
 
 US_GLOBAL_STATIC(ModuleSettingsPrivate, moduleSettingsPrivate)
 
 bool ModuleSettings::IsThreadingSupportEnabled()
 {
 #ifdef US_ENABLE_THREADING_SUPPORT
   return true;
 #else
   return false;
 #endif
 }
 
 bool ModuleSettings::IsAutoLoadingEnabled()
 {
   US_UNUSED(ModuleSettingsPrivate::Lock(moduleSettingsPrivate()));
 #ifdef US_ENABLE_AUTOLOADING_SUPPORT
   return !moduleSettingsPrivate()->autoLoadingDisabled &&
       moduleSettingsPrivate()->autoLoadingEnabled;
 #else
   return false;
 #endif
 }
 
 void ModuleSettings::SetAutoLoadingEnabled(bool enable)
 {
   US_UNUSED(ModuleSettingsPrivate::Lock(moduleSettingsPrivate()));
   moduleSettingsPrivate()->autoLoadingEnabled = enable;
 }
 
 ModuleSettings::PathList ModuleSettings::GetAutoLoadPaths()
 {
   US_UNUSED(ModuleSettingsPrivate::Lock(moduleSettingsPrivate()));
   ModuleSettings::PathList paths(moduleSettingsPrivate()->autoLoadPaths.begin(),
                                  moduleSettingsPrivate()->autoLoadPaths.end());
   paths.insert(paths.end(), moduleSettingsPrivate()->extraPaths.begin(),
                moduleSettingsPrivate()->extraPaths.end());
   std::sort(paths.begin(), paths.end());
   paths.erase(std::unique(paths.begin(), paths.end()), paths.end());
   return paths;
 }
 
 void ModuleSettings::SetAutoLoadPaths(const PathList& paths)
 {
   PathList normalizedPaths;
   normalizedPaths.resize(paths.size());
   std::transform(paths.begin(), paths.end(), normalizedPaths.begin(), RemoveTrailingPathSeparator);
 
   US_UNUSED(ModuleSettingsPrivate::Lock(moduleSettingsPrivate()));
   moduleSettingsPrivate()->autoLoadPaths.clear();
   moduleSettingsPrivate()->autoLoadPaths.insert(normalizedPaths.begin(), normalizedPaths.end());
 }
 
 void ModuleSettings::AddAutoLoadPath(const std::string& path)
 {
   US_UNUSED(ModuleSettingsPrivate::Lock(moduleSettingsPrivate()));
   moduleSettingsPrivate()->autoLoadPaths.insert(RemoveTrailingPathSeparator(path));
 }
 
 void ModuleSettings::SetStoragePath(const std::string &path)
 {
   US_UNUSED(ModuleSettingsPrivate::Lock(moduleSettingsPrivate()));
   moduleSettingsPrivate()->storagePath = RemoveTrailingPathSeparator(path);
 }
 
 std::string ModuleSettings::GetStoragePath()
 {
   US_UNUSED(ModuleSettingsPrivate::Lock(moduleSettingsPrivate()));
   return moduleSettingsPrivate()->storagePath;
 }
 
 void ModuleSettings::SetLogLevel(MsgType level)
 {
   US_UNUSED(ModuleSettingsPrivate::Lock(moduleSettingsPrivate()));
   moduleSettingsPrivate()->logLevel = level;
 }
 
 MsgType ModuleSettings::GetLogLevel()
 {
   US_UNUSED(ModuleSettingsPrivate::Lock(moduleSettingsPrivate()));
   return moduleSettingsPrivate()->logLevel;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleUtils.cpp b/Modules/CppMicroServices/core/src/module/usModuleUtils.cpp
index 8cf8e7fedb..29357cc58c 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleUtils.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleUtils.cpp
@@ -1,171 +1,171 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleUtils_p.h"
 
 #include <usLog_p.h>
 #include <usModuleInfo.h>
 #include <usUtils_p.h>
 
 US_BEGIN_NAMESPACE
 
 namespace {
 #ifdef US_BUILD_SHARED_LIBS
   const bool sharedLibMode = true;
 #else
   const bool sharedLibMode = false;
 #endif
 }
 
 #ifdef __GNUC__
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
 
 #include <dlfcn.h>
 
 std::string GetLibraryPath_impl(void* symbol)
 {
   Dl_info info;
   if (dladdr(symbol, &info))
   {
     return info.dli_fname;
   }
   else
   {
     US_DEBUG << "GetLibraryPath_impl() failed for address " << symbol;
   }
   return "";
 }
 
 void* GetSymbol_impl(const ModuleInfo& moduleInfo, const char* symbol)
 {
   // Clear the last error message
   dlerror();
 
   void* selfHandle = nullptr;
   if (!sharedLibMode || moduleInfo.name == "main")
   {
     // Get the handle of the executable
     selfHandle = dlopen(nullptr, RTLD_LAZY);
   }
   else
   {
     selfHandle = dlopen(moduleInfo.location.c_str(), RTLD_LAZY);
   }
 
   if (selfHandle)
   {
     void* addr = dlsym(selfHandle, symbol);
     if (!addr)
     {
       const char* dlerrorMsg = dlerror();
       if (dlerrorMsg)
       {
         US_DEBUG << "GetSymbol_impl() failed: " << dlerrorMsg;
       }
     }
     dlclose(selfHandle);
     return addr;
   }
   else
   {
     US_DEBUG << "GetSymbol_impl() dlopen() failed: " << dlerror();
   }
   return nullptr;
 }
 
 #elif _WIN32
 
 #include <windows.h>
 
 std::string GetLibraryPath_impl(void *symbol)
 {
   HMODULE handle = 0;
   BOOL handleError = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                                        static_cast<LPCTSTR>(symbol), &handle);
   if (!handleError)
   {
     // Test
     US_DEBUG << "GetLibraryPath_impl():GetModuleHandle() " << GetLastErrorStr();
     return "";
   }
 
   char modulePath[512];
   if (GetModuleFileName(handle, modulePath, 512))
   {
     return modulePath;
   }
 
   US_DEBUG << "GetLibraryPath_impl():GetModuleFileName() " << GetLastErrorStr();
   return "";
 }
 
 void* GetSymbol_impl(const ModuleInfo& moduleInfo, const char* symbol)
 {
   HMODULE handle = nullptr;
   if (!sharedLibMode || moduleInfo.name == "main")
   {
     handle = GetModuleHandle(nullptr);
   }
   else
   {
     handle = GetModuleHandle(moduleInfo.location.c_str());
   }
 
   if (!handle)
   {
     US_DEBUG << "GetSymbol_impl():GetModuleHandle() " << GetLastErrorStr();
     return 0;
   }
 
   void* addr = (void*)GetProcAddress(handle, symbol);
   if (!addr)
   {
     US_DEBUG << "GetSymbol_impl():GetProcAddress(handle," << symbol << ") " << GetLastErrorStr();
   }
   return addr;
 }
 #else
 std::string GetLibraryPath_impl(void*)
 {
   return "";
 }
 
 void* GetSymbol_impl(const ModuleInfo&, const char* symbol)
 {
   return 0;
 }
 #endif
 
 std::string ModuleUtils::GetLibraryPath(void* symbol)
 {
   return GetLibraryPath_impl(symbol);
 }
 
 void* ModuleUtils::GetSymbol(const ModuleInfo& module, const char* symbol)
 {
   return GetSymbol_impl(module, symbol);
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/module/usModuleUtils_p.h b/Modules/CppMicroServices/core/src/module/usModuleUtils_p.h
index c5291e22f6..5915f9a9f5 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleUtils_p.h
+++ b/Modules/CppMicroServices/core/src/module/usModuleUtils_p.h
@@ -1,52 +1,52 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USMODULEUTILS_H
 #define USMODULEUTILS_H
 
 #include <usCoreExport.h>
 
 #include <string>
 
 #define US_STR_(x) #x
 #define US_STR(x) US_STR_(x)
 #define US_CONCAT_(x,y) x ## y
 #define US_CONCAT(x,y) US_CONCAT_(x,y)
 
 US_BEGIN_NAMESPACE
 
 struct ModuleInfo;
 
 /**
  * This class is not intended to be used directly. It is exported to support
  * the CppMicroServices module system.
  */
 struct US_Core_EXPORT ModuleUtils
 {
   static std::string GetLibraryPath(void* symbol);
 
   static void* GetSymbol(const ModuleInfo& module, const char* symbol);
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULEUTILS_H
diff --git a/Modules/CppMicroServices/core/src/module/usModuleVersion.cpp b/Modules/CppMicroServices/core/src/module/usModuleVersion.cpp
index 6ecc56ed03..a62d5bddd5 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleVersion.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleVersion.cpp
@@ -1,275 +1,275 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usModuleVersion.h"
 
 #include <vector>
 #include <sstream>
 #include <stdexcept>
 #include <algorithm>
 #include <cctype>
 
 US_BEGIN_NAMESPACE
 
 const char ModuleVersion::SEPARATOR = '.';
 
 bool IsInvalidQualifier(char c)
 {
   return !(std::isalnum(c) || c == '_' || c == '-');
 }
 
 ModuleVersion ModuleVersion::EmptyVersion()
 {
   static ModuleVersion emptyV(false);
   return emptyV;
 }
 
 ModuleVersion ModuleVersion::UndefinedVersion()
 {
   static ModuleVersion undefinedV(true);
   return undefinedV;
 }
 
 ModuleVersion& ModuleVersion::operator=(const ModuleVersion& v)
 {
   majorVersion = v.majorVersion;
   minorVersion = v.minorVersion;
   microVersion = v.microVersion;
   qualifier = v.qualifier;
   undefined = v.undefined;
   return *this;
 }
 
 ModuleVersion::ModuleVersion(bool undefined)
   : majorVersion(0), minorVersion(0), microVersion(0), qualifier(""), undefined(undefined)
 {
 
 }
 
 void ModuleVersion::Validate()
 {
   if (std::find_if(qualifier.begin(), qualifier.end(), IsInvalidQualifier) != qualifier.end())
     throw std::invalid_argument(std::string("invalid qualifier: ") + qualifier);
 
   undefined = false;
 }
 
 ModuleVersion::ModuleVersion(unsigned int majorVersion, unsigned int minorVersion, unsigned int microVersion)
   : majorVersion(majorVersion), minorVersion(minorVersion), microVersion(microVersion), qualifier(""),
     undefined(false)
 {
 
 }
 
 ModuleVersion::ModuleVersion(unsigned int majorVersion, unsigned int minorVersion, unsigned int microVersion, const std::string& qualifier)
    : majorVersion(majorVersion), minorVersion(minorVersion), microVersion(microVersion), qualifier(qualifier),
      undefined(true)
 {
   this->Validate();
 }
 
 ModuleVersion::ModuleVersion(const std::string& version)
   : majorVersion(0), minorVersion(0), microVersion(0), undefined(true)
 {
   unsigned int maj = 0;
   unsigned int min = 0;
   unsigned int mic = 0;
   std::string qual("");
 
   std::vector<std::string> st;
   std::stringstream ss(version);
   std::string token;
   while(std::getline(ss, token, SEPARATOR))
   {
     st.push_back(token);
   }
 
   if (st.empty()) return;
 
   bool ok = true;
   ss.clear();
   ss.str(st[0]);
   ss >> maj;
   ok = !ss.fail();
 
   if (st.size() > 1)
   {
     ss.clear();
     ss.str(st[1]);
     ss >> min;
     ok = !ss.fail();
     if (st.size() > 2)
     {
       ss.clear();
       ss.str(st[2]);
       ss >> mic;
       ok = !ss.fail();
       if (st.size() > 3)
       {
         qual = st[3];
         if (st.size() > 4)
         {
            ok = false;
         }
       }
     }
   }
 
   if (!ok) throw std::invalid_argument("invalid format");
 
   majorVersion = maj;
   minorVersion = min;
   microVersion = mic;
   qualifier = qual;
   this->Validate();
 }
 
 ModuleVersion::ModuleVersion(const ModuleVersion& version)
 : majorVersion(version.majorVersion), minorVersion(version.minorVersion),
   microVersion(version.microVersion), qualifier(version.qualifier),
   undefined(version.undefined)
 {
 
 }
 
 ModuleVersion ModuleVersion::ParseVersion(const std::string& version)
 {
   if (version.empty())
   {
     return EmptyVersion();
   }
 
   std::string version2(version);
   version2.erase(0, version2.find_first_not_of(' '));
   version2.erase(version2.find_last_not_of(' ')+1);
   if (version2.empty())
   {
     return EmptyVersion();
   }
 
   return ModuleVersion(version2);
 }
 
 bool ModuleVersion::IsUndefined() const
 {
   return undefined;
 }
 
 unsigned int ModuleVersion::GetMajor() const
 {
   if (undefined) throw std::logic_error("Version undefined");
   return majorVersion;
 }
 
 unsigned int ModuleVersion::GetMinor() const
 {
   if (undefined) throw std::logic_error("Version undefined");
   return minorVersion;
 }
 
 unsigned int ModuleVersion::GetMicro() const
 {
   if (undefined) throw std::logic_error("Version undefined");
   return microVersion;
 }
 
 std::string ModuleVersion::GetQualifier() const
 {
   if (undefined) throw std::logic_error("Version undefined");
   return qualifier;
 }
 
 std::string ModuleVersion::ToString() const
 {
   if (undefined) return "undefined";
 
   std::stringstream ss;
   ss << majorVersion << SEPARATOR << minorVersion << SEPARATOR << microVersion;
   if (!qualifier.empty())
   {
     ss << SEPARATOR << qualifier;
   }
   return ss.str();
 }
 
 bool ModuleVersion::operator==(const ModuleVersion& other) const
 {
   if (&other == this)
   { // quicktest
     return true;
   }
 
   if (other.undefined && this->undefined) return true;
   if (this->undefined) throw std::logic_error("Version undefined");
   if (other.undefined) return false;
 
   return (majorVersion == other.majorVersion) && (minorVersion == other.minorVersion) && (microVersion
       == other.microVersion) && qualifier == other.qualifier;
 }
 
 int ModuleVersion::Compare(const ModuleVersion& other) const
 {
   if (&other == this)
   { // quicktest
     return 0;
   }
 
   if (this->undefined || other.undefined)
     throw std::logic_error("Cannot compare undefined version");
 
   if (majorVersion < other.majorVersion)
   {
     return -1;
   }
 
   if (majorVersion == other.majorVersion)
   {
 
     if (minorVersion < other.minorVersion)
     {
       return -1;
     }
 
     if (minorVersion == other.minorVersion)
     {
 
       if (microVersion < other.microVersion)
       {
         return -1;
       }
 
       if (microVersion == other.microVersion)
       {
         return qualifier.compare(other.qualifier);
       }
     }
   }
   return 1;
 }
 
 US_END_NAMESPACE
 
 US_USE_NAMESPACE
 
 std::ostream& operator<<(std::ostream& os, const ModuleVersion& v)
 {
   return os << v.ToString();
 }
diff --git a/Modules/CppMicroServices/core/src/service/usLDAPExpr.cpp b/Modules/CppMicroServices/core/src/service/usLDAPExpr.cpp
index 0d7a3ecd78..7c93465f78 100644
--- a/Modules/CppMicroServices/core/src/service/usLDAPExpr.cpp
+++ b/Modules/CppMicroServices/core/src/service/usLDAPExpr.cpp
@@ -1,809 +1,809 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usLDAPExpr_p.h"
 
 #include "usAny.h"
 #include "usServicePropertiesImpl_p.h"
 
 #include <limits>
 #include <iterator>
 #include <cctype>
 #include <stdexcept>
 
 #include <cerrno>
 #include <cstdlib>
 #include <cmath>
 
 US_BEGIN_NAMESPACE
 
 namespace LDAPExprConstants {
 
 static LDAPExpr::Byte WILDCARD()
 {
   static LDAPExpr::Byte b = std::numeric_limits<LDAPExpr::Byte>::max();
   return b;
 }
 
 static const std::string& WILDCARD_STRING()
 {
   static std::string s(1, WILDCARD());
   return s;
 }
 
 static const std::string& nullptrQ()
 {
   static std::string s = "Null query";
   return s;
 }
 
 static const std::string& GARBAGE()
 {
   static std::string s = "Trailing garbage";
   return s;
 }
 
 static const std::string& EOS()
 {
   static std::string s = "Unexpected end of query";
   return s;
 }
 
 static const std::string& MALFORMED()
 {
   static std::string s = "Malformed query";
   return s;
 }
 
 static const std::string& OPERATOR()
 {
   static std::string s = "Undefined operator";
   return s;
 }
 
 }
 
 bool stricomp(const std::string::value_type& v1, const std::string::value_type& v2)
 {
   return ::tolower(v1) == ::tolower(v2);
 }
 
 class LDAPExprData : public SharedData
 {
 public:
 
   LDAPExprData( int op, const std::vector<LDAPExpr>& args )
     : m_operator(op), m_args(args), m_attrName(), m_attrValue()
   {
   }
 
   LDAPExprData( int op, std::string attrName, const std::string& attrValue )
     : m_operator(op), m_args(), m_attrName(attrName), m_attrValue(attrValue)
   {
   }
 
   LDAPExprData( const LDAPExprData& other )
     : SharedData(other), m_operator(other.m_operator),
     m_args(other.m_args), m_attrName(other.m_attrName),
     m_attrValue(other.m_attrValue)
   {
   }
 
   int m_operator;
   std::vector<LDAPExpr> m_args;
   std::string m_attrName;
   std::string m_attrValue;
 };
 
 LDAPExpr::LDAPExpr() : d()
 {
 }
 
 LDAPExpr::LDAPExpr( const std::string &filter ) : d()
 {
   ParseState ps(filter);
   try
   {
     LDAPExpr expr = ParseExpr(ps);
 
     if (!Trim(ps.rest()).empty())
     {
       ps.error(LDAPExprConstants::GARBAGE() + " '" + ps.rest() + "'");
     }
 
     d = expr.d;
   }
   catch (const std::out_of_range&)
   {
     ps.error(LDAPExprConstants::EOS());
   }
 }
 
 LDAPExpr::LDAPExpr( int op, const std::vector<LDAPExpr>& args )
   : d(new LDAPExprData(op, args))
 {
 }
 
 LDAPExpr::LDAPExpr( int op, const std::string &attrName, const std::string &attrValue )
   : d(new LDAPExprData(op, attrName, attrValue))
 {
 }
 
 LDAPExpr::LDAPExpr( const LDAPExpr& other )
   : d(other.d)
 {
 }
 
 LDAPExpr& LDAPExpr::operator=(const LDAPExpr& other)
 {
   d = other.d;
   return *this;
 }
 
 LDAPExpr::~LDAPExpr()
 {
 }
 
 std::string LDAPExpr::Trim(std::string str)
 {
   str.erase(0, str.find_first_not_of(' '));
   str.erase(str.find_last_not_of(' ')+1);
   return str;
 }
 
 bool LDAPExpr::GetMatchedObjectClasses(ObjectClassSet& objClasses) const
 {
   if (d->m_operator == EQ)
   {
     if (d->m_attrName.length() == ServiceConstants::OBJECTCLASS().length() &&
         std::equal(d->m_attrName.begin(), d->m_attrName.end(), ServiceConstants::OBJECTCLASS().begin(), stricomp) &&
         d->m_attrValue.find(LDAPExprConstants::WILDCARD()) == std::string::npos)
     {
       objClasses.insert( d->m_attrValue );
       return true;
     }
     return false;
   }
   else if (d->m_operator == AND)
   {
     bool result = false;
     for (std::size_t i = 0; i < d->m_args.size( ); i++)
     {
       LDAPExpr::ObjectClassSet r;
       if (d->m_args[i].GetMatchedObjectClasses(r))
       {
         result = true;
         if (objClasses.empty())
         {
           objClasses = r;
         }
         else
         {
           // if AND op and classes in several operands,
           // then only the intersection is possible.
           LDAPExpr::ObjectClassSet::iterator it1 = objClasses.begin();
           LDAPExpr::ObjectClassSet::iterator it2 = r.begin();
           while ( (it1 != objClasses.end()) && (it2 != r.end()) )
           {
             if (*it1 < *it2)
             {
               objClasses.erase(it1++);
             }
             else if (*it2 < *it1)
             {
               ++it2;
             }
             else
             { // *it1 == *it2
               ++it1;
               ++it2;
             }
           }
           // Anything left in set_1 from here on did not appear in set_2,
           // so we remove it.
           objClasses.erase(it1, objClasses.end());
         }
       }
     }
     return result;
   }
   else if (d->m_operator == OR)
   {
     for (std::size_t i = 0; i < d->m_args.size( ); i++)
     {
       LDAPExpr::ObjectClassSet r;
       if (d->m_args[i].GetMatchedObjectClasses(r))
       {
         std::copy(r.begin(), r.end(), std::inserter(objClasses, objClasses.begin()));
       }
       else
       {
         objClasses.clear();
         return false;
       }
     }
     return true;
   }
   return false;
 }
 
 std::string LDAPExpr::ToLower(const std::string& str)
 {
   std::string lowerStr(str);
   std::transform(str.begin(), str.end(), lowerStr.begin(), ::tolower);
   return lowerStr;
 }
 
 bool LDAPExpr::IsSimple(const StringList& keywords, LocalCache& cache,
                         bool matchCase ) const
 {
   if (cache.empty())
   {
     cache.resize(keywords.size());
   }
 
   if (d->m_operator == EQ)
   {
     StringList::const_iterator index;
     if ((index = std::find(keywords.begin(), keywords.end(), matchCase ? d->m_attrName : ToLower(d->m_attrName))) != keywords.end() &&
         d->m_attrValue.find_first_of(LDAPExprConstants::WILDCARD()) == std::string::npos)
     {
       cache[index - keywords.begin()] = StringList(1, d->m_attrValue);
       return true;
     }
   }
   else if (d->m_operator == OR)
   {
     for (std::size_t i = 0; i < d->m_args.size( ); i++)
     {
       if (!d->m_args[i].IsSimple(keywords, cache, matchCase))
         return false;
     }
     return true;
   }
   return false;
 }
 
 bool LDAPExpr::IsNull() const
 {
   return !d;
 }
 
 bool LDAPExpr::Query( const std::string& filter, const ServicePropertiesImpl& pd)
 {
   return LDAPExpr(filter).Evaluate(pd, false);
 }
 
 bool LDAPExpr::Evaluate( const ServicePropertiesImpl& p, bool matchCase ) const
 {
   if ((d->m_operator & SIMPLE) != 0)
   {
     // try case sensitive match first
     int index = p.FindCaseSensitive(d->m_attrName);
     if (index < 0 && !matchCase) index = p.Find(d->m_attrName);
     return index < 0 ? false : Compare(p.Value(index), d->m_operator, d->m_attrValue);
   }
   else
   { // (d->m_operator & COMPLEX) != 0
     switch (d->m_operator)
     {
     case AND:
       for (std::size_t i = 0; i < d->m_args.size(); i++)
       {
         if (!d->m_args[i].Evaluate(p, matchCase))
           return false;
       }
       return true;
     case OR:
       for (std::size_t i = 0; i < d->m_args.size(); i++)
       {
         if (d->m_args[i].Evaluate(p, matchCase))
           return true;
       }
       return false;
     case NOT:
       return !d->m_args[0].Evaluate(p, matchCase);
     default:
       return false; // Cannot happen
     }
   }
 }
 
 bool LDAPExpr::Compare( const Any& obj, int op, const std::string& s ) const
 {
   if (obj.Empty())
     return false;
   if (op == EQ && s == LDAPExprConstants::WILDCARD_STRING())
     return true;
 
   try
   {
     const std::type_info& objType = obj.Type();
     if (objType == typeid(std::string))
     {
       return CompareString(ref_any_cast<std::string>(obj), op, s);
     }
     else if (objType == typeid(std::vector<std::string>))
     {
       const std::vector<std::string>& list = ref_any_cast<std::vector<std::string> >(obj);
       for (std::size_t it = 0; it != list.size(); it++)
       {
          if (CompareString(list[it], op, s))
            return true;
       }
     }
     else if (objType == typeid(std::list<std::string>))
     {
       const std::list<std::string>& list = ref_any_cast<std::list<std::string> >(obj);
       for (std::list<std::string>::const_iterator it = list.begin();
            it != list.end(); ++it)
       {
          if (CompareString(*it, op, s))
            return true;
       }
     }
     else if (objType == typeid(char))
     {
       return CompareString(std::string(1, ref_any_cast<char>(obj)), op, s);
     }
     else if (objType == typeid(bool))
     {
       if (op==LE || op==GE)
         return false;
 
       std::string boolVal = any_cast<bool>(obj) ? "true" : "false";
       return std::equal(s.begin(), s.end(), boolVal.begin(), stricomp);
     }
     else if (objType == typeid(short))
     {
       return CompareIntegralType<short>(obj, op, s);
     }
     else if (objType == typeid(int))
     {
       return CompareIntegralType<int>(obj, op, s);
     }
     else if (objType == typeid(long int))
     {
       return CompareIntegralType<long int>(obj, op, s);
     }
     else if (objType == typeid(long long int))
     {
       return CompareIntegralType<long long int>(obj, op, s);
     }
     else if (objType == typeid(unsigned char))
     {
       return CompareIntegralType<unsigned char>(obj, op, s);
     }
     else if (objType == typeid(unsigned short))
     {
       return CompareIntegralType<unsigned short>(obj, op, s);
     }
     else if (objType == typeid(unsigned int))
     {
       return CompareIntegralType<unsigned int>(obj, op, s);
     }
     else if (objType == typeid(unsigned long int))
     {
       return CompareIntegralType<unsigned long int>(obj, op, s);
     }
     else if (objType == typeid(unsigned long long int))
     {
       return CompareIntegralType<unsigned long long int>(obj, op, s);
     }
     else if (objType == typeid(float))
     {
       errno = 0;
       char* endptr = nullptr;
       double sFloat = strtod(s.c_str(), &endptr);
       if ((errno == ERANGE && (sFloat == 0 || sFloat == HUGE_VAL || sFloat == -HUGE_VAL)) ||
           (errno != 0 && sFloat == 0) || endptr == s.c_str())
       {
         return false;
       }
 
       double floatVal = static_cast<double>(any_cast<float>(obj));
 
       switch(op)
       {
       case LE:
         return floatVal <= sFloat;
       case GE:
         return floatVal >= sFloat;
       default: /*APPROX and EQ*/
         double diff = floatVal - sFloat;
         return (diff < std::numeric_limits<float>::epsilon()) && (diff > -std::numeric_limits<float>::epsilon());
       }
     }
     else if (objType == typeid(double))
     {
       errno = 0;
       char* endptr = nullptr;
       double sDouble = strtod(s.c_str(), &endptr);
       if ((errno == ERANGE && (sDouble == 0 || sDouble == HUGE_VAL || sDouble == -HUGE_VAL)) ||
           (errno != 0 && sDouble == 0) || endptr == s.c_str())
       {
         return false;
       }
 
       double doubleVal = any_cast<double>(obj);
 
       switch(op)
       {
       case LE:
         return doubleVal <= sDouble;
       case GE:
         return doubleVal >= sDouble;
       default: /*APPROX and EQ*/
         double diff = doubleVal - sDouble;
         return (diff < std::numeric_limits<double>::epsilon()) && (diff > -std::numeric_limits<double>::epsilon());
       }
     }
     else if (objType == typeid(std::vector<Any>))
     {
       const std::vector<Any>& list = ref_any_cast<std::vector<Any> >(obj);
       for (std::size_t it = 0; it != list.size(); it++)
       {
          if (Compare(list[it], op, s))
            return true;
       }
     }
   }
   catch (...)
   {
     // This might happen if a std::string-to-datatype conversion fails
     // Just consider it a false match and ignore the exception
   }
   return false;
 }
 
 template<typename T>
 bool LDAPExpr::CompareIntegralType(const Any& obj, const int op, const std::string& s) const
 {
   errno = 0;
   char* endptr = nullptr;
   long longInt = strtol(s.c_str(), &endptr, 10);
   if ((errno == ERANGE && (longInt == std::numeric_limits<long>::max() || longInt == std::numeric_limits<long>::min())) ||
        (errno != 0 && longInt == 0) || endptr == s.c_str())
   {
     return false;
   }
 
   T sInt = static_cast<T>(longInt);
   T intVal = any_cast<T>(obj);
 
   switch(op)
   {
   case LE:
     return intVal <= sInt;
   case GE:
     return intVal >= sInt;
   default: /*APPROX and EQ*/
     return intVal == sInt;
   }
 }
 
 bool LDAPExpr::CompareString( const std::string& s1, int op, const std::string& s2 )
 {
   switch(op)
   {
   case LE:
     return s1.compare(s2) <= 0;
   case GE:
     return s1.compare(s2) >= 0;
   case EQ:
     return PatSubstr(s1,s2);
   case APPROX:
     return FixupString(s2) == FixupString(s1);
   default:
     return false;
   }
 }
 
 std::string LDAPExpr::FixupString( const std::string& s )
 {
   std::string sb;
   sb.reserve(s.size());
   std::size_t len = s.length();
   for(std::size_t i=0; i<len; i++)
   {
     char c = s.at(i);
     if (!std::isspace(c))
     {
       if (std::isupper(c))
         c = std::tolower(c);
       sb.append(1, c);
     }
   }
   return sb;
 }
 
 bool LDAPExpr::PatSubstr( const std::string& s, int si, const std::string& pat, int pi )
 {
   if (pat.size()-pi == 0)
     return s.size()-si == 0;
   if (pat[pi] == LDAPExprConstants::WILDCARD())
   {
     pi++;
     for (;;)
     {
       if (PatSubstr(s, si, pat, pi))
         return true;
       if (s.size()-si == 0)
         return false;
       si++;
     }
   }
   else
   {
     if (s.size()-si == 0)
     {
       return false;
     }
     if(s[si] != pat[pi])
     {
       return false;
     }
     return PatSubstr(s, ++si, pat, ++pi);
   }
 }
 
 bool LDAPExpr::PatSubstr( const std::string& s, const std::string& pat )
 {
   return PatSubstr(s, 0, pat, 0);
 }
 
 LDAPExpr LDAPExpr::ParseExpr( ParseState& ps )
 {
   ps.skipWhite();
   if (!ps.prefix("("))
     ps.error(LDAPExprConstants::MALFORMED());
 
   int op;
   ps.skipWhite();
   Byte c = ps.peek();
   if ( c == '&')
   {
     op = AND;
   }
   else if ( c == '|' )
   {
     op = OR;
   }
   else if ( c == '!' )
   {
     op = NOT;
   }
   else
   {
     return ParseSimple(ps);
   }
   ps.skip(1); // Ignore the d->m_operator
 
   std::vector<LDAPExpr> v;
   do
   {
     v.push_back(ParseExpr(ps));
     ps.skipWhite();
   } while (ps.peek() == '(');
 
   std::size_t n = v.size();
   if (!ps.prefix(")") || n == 0 || (op == NOT && n > 1))
     ps.error(LDAPExprConstants::MALFORMED());
 
   return LDAPExpr(op, v);
 }
 
 LDAPExpr LDAPExpr::ParseSimple( ParseState &ps )
 {
   std::string attrName = ps.getAttributeName();
   if (attrName.empty())
     ps.error(LDAPExprConstants::MALFORMED());
   int op = 0;
   if (ps.prefix("="))
     op = EQ;
   else if (ps.prefix("<="))
     op = LE;
   else if(ps.prefix(">="))
     op = GE;
   else if(ps.prefix("~="))
     op = APPROX;
   else
   {
     //      System.out.println("undef op='" + ps.peek() + "'");
     ps.error(LDAPExprConstants::OPERATOR()); // Does not return
   }
   std::string attrValue = ps.getAttributeValue();
   if (!ps.prefix(")"))
     ps.error(LDAPExprConstants::MALFORMED());
   return LDAPExpr(op, attrName, attrValue);
 }
 
 const std::string LDAPExpr::ToString() const
 {
   std::string res;
   res.append("(");
   if ((d->m_operator & SIMPLE) != 0)
   {
     res.append(d->m_attrName);
     switch (d->m_operator)
     {
     case EQ:
       res.append("=");
       break;
     case LE:
       res.append("<=");
       break;
     case GE:
       res.append(">=");
       break;
     case APPROX:
       res.append("~=");
       break;
     }
 
     for (std::size_t i = 0; i < d->m_attrValue.length(); i++)
     {
       Byte c = d->m_attrValue.at(i);
       if (c ==  '(' || c == ')' || c == '*' || c == '\\')
       {
         res.append(1, '\\');
       }
       else if (c == LDAPExprConstants::WILDCARD())
       {
         c = '*';
       }
       res.append(1, c);
     }
   }
   else
   {
     switch (d->m_operator)
     {
     case AND:
       res.append("&");
       break;
     case OR:
       res.append("|");
       break;
     case NOT:
       res.append("!");
       break;
     }
     for (std::size_t i = 0; i < d->m_args.size(); i++)
     {
       res.append(d->m_args[i].ToString());
     }
   }
   res.append(")");
   return res;
 }
 
 LDAPExpr::ParseState::ParseState( const std::string& str )
   : m_pos(0), m_str()
 {
   if (str.empty())
   {
     error(LDAPExprConstants::nullptrQ());
   }
 
   m_str = str;
 }
 
 bool LDAPExpr::ParseState::prefix( const std::string& pre )
 {
   std::string::iterator startIter = m_str.begin() + m_pos;
   if (!std::equal(pre.begin(), pre.end(), startIter))
     return false;
   m_pos += pre.size();
   return true;
 }
 
 char LDAPExpr::ParseState::peek()
 {
   if ( m_pos >= m_str.size() )
   {
     throw std::out_of_range( "LDAPExpr" );
   }
   return m_str.at(m_pos);
 }
 
 void LDAPExpr::ParseState::skip( int n )
 {
   m_pos += n;
 }
 
 std::string LDAPExpr::ParseState::rest() const
 {
   return m_str.substr(m_pos);
 }
 
 void LDAPExpr::ParseState::skipWhite()
 {
   while (std::isspace(peek()))
   {
     m_pos++;
   }
 }
 
 std::string LDAPExpr::ParseState::getAttributeName()
 {
   std::size_t start = m_pos;
   std::size_t n = 0;
   bool nIsSet = false;
   for(;; m_pos++)
   {
     Byte c = peek();
     if (c == '(' || c == ')' ||
         c == '<' || c == '>' ||
         c == '=' || c == '~') {
       break;
     }
     else if (!std::isspace(c))
     {
       n = m_pos - start + 1;
       nIsSet = true;
     }
   }
   if (!nIsSet)
   {
     return std::string();
   }
   return m_str.substr(start, n);
 }
 
 std::string LDAPExpr::ParseState::getAttributeValue()
 {
   std::string sb;
   bool exit = false;
   while( !exit ) {
     Byte c = peek( );
     switch(c)
     {
     case '(':
     case ')':
       exit = true;
       break;
     case '*':
       sb.append(1, LDAPExprConstants::WILDCARD());
       break;
     case '\\':
       sb.append(1, m_str.at(++m_pos));
       break;
     default:
       sb.append(1, c);
       break;
     }
 
     if ( !exit )
     {
       m_pos++;
     }
   }
   return sb;
 }
 
 void LDAPExpr::ParseState::error( const std::string &m ) const
 {
   std::string errorStr = m + ": " + (m_str.empty() ? "" : m_str.substr(m_pos));
   throw std::invalid_argument(errorStr);
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usLDAPExpr_p.h b/Modules/CppMicroServices/core/src/service/usLDAPExpr_p.h
index 9264239350..3d709800da 100644
--- a/Modules/CppMicroServices/core/src/service/usLDAPExpr_p.h
+++ b/Modules/CppMicroServices/core/src/service/usLDAPExpr_p.h
@@ -1,217 +1,217 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USLDAPEXPR_H
 #define USLDAPEXPR_H
 
 #include <usCoreConfig.h>
 
 #include "usSharedData.h"
 
 #include <vector>
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 class Any;
 class LDAPExprData;
 class ServicePropertiesImpl;
 
 /**
  * This class is not part of the public API.
  */
 class LDAPExpr {
 
 public:
 
   const static int AND = 0;
   const static int OR = 1;
   const static int NOT = 2;
   const static int EQ = 4;
   const static int LE = 8;
   const static int GE = 16;
   const static int APPROX = 32;
   const static int COMPLEX = AND | OR | NOT;
   const static int SIMPLE = EQ | LE | GE | APPROX;
 
   typedef char Byte;
   typedef std::vector<std::string> StringList;
   typedef std::vector<StringList> LocalCache;
   typedef US_UNORDERED_SET_TYPE<std::string> ObjectClassSet;
 
 
   /**
    * Creates an invalid LDAPExpr object. Use with care.
    *
    * @see IsNull()
    */
   LDAPExpr();
 
   LDAPExpr(const std::string& filter);
 
   LDAPExpr(const LDAPExpr& other);
 
   LDAPExpr& operator=(const LDAPExpr& other);
 
   ~LDAPExpr();
 
   /**
    * Get object class set matched by this LDAP expression. This will not work
    * with wildcards and NOT expressions. If a set can not be determined return <code>false</code>.
    *
    * \param objClasses The set of matched classes will be added to objClasses.
    * \return If the set cannot be determined, <code>false</code> is returned, <code>true</code> otherwise.
    */
   bool GetMatchedObjectClasses(ObjectClassSet& objClasses) const;
 
   /**
    * Checks if this LDAP expression is "simple". The definition of
    * a simple filter is:
    * <ul>
    *  <li><code>(<it>name</it>=<it>value</it>)</code> is simple if
    *      <it>name</it> is a member of the provided <code>keywords</code>,
    *      and <it>value</it> does not contain a wildcard character;</li>
    *  <li><code>(| EXPR+ )</code> is simple if all <code>EXPR</code>
    *      expressions are simple;</li>
    *  <li>No other expressions are simple.</li>
    * </ul>
    * If the filter is found to be simple, the <code>cache</code> is
    * filled with mappings from the provided keywords to lists
    * of attribute values. The keyword-value-pairs are the ones that
    * satisfy this expression, for the given keywords.
    *
    * @param keywords The keywords to look for.
    * @param cache An array (indexed by the keyword indexes) of lists to
    * fill in with values saturating this expression.
    * @return <code>true</code> if this expression is simple,
    * <code>false</code> otherwise.
    */
   bool IsSimple(
     const StringList& keywords,
     LocalCache& cache,
     bool matchCase) const;
 
   /**
    * Returns <code>true</code> if this instance is invalid, i.e. it was
    * constructed using LDAPExpr().
    *
    * @return <code>true</code> if the expression is invalid,
    *         <code>false</code> otherwise.
    */
   bool IsNull() const;
 
   //!
   static bool Query(const std::string& filter, const ServicePropertiesImpl& pd);
 
   //! Evaluate this LDAP filter.
   bool Evaluate(const ServicePropertiesImpl& p, bool matchCase) const;
 
   //!
   const std::string ToString() const;
 
 
 private:
 
   //! Contains the current parser position and parsing utility methods.
   class ParseState
   {
 
   private:
 
     std::size_t m_pos;
     std::string m_str;
 
   public:
 
     ParseState(const std::string& str);
 
     //! Move m_pos to remove the prefix \a pre
     bool prefix(const std::string& pre);
 
     /** Peek a char at m_pos
     \note If index out of bounds, throw exception
     */
     LDAPExpr::Byte peek();
 
     //! Increment m_pos by n
     void skip(int n);
 
     //! return string from m_pos until the end
     std::string rest() const;
 
     //! Move m_pos until there's no spaces
     void skipWhite();
 
     //! Get string until special chars. Move m_pos
     std::string getAttributeName();
 
     //! Get string and convert * to WILDCARD
     std::string getAttributeValue();
 
     //! Throw InvalidSyntaxException exception
     void error(const std::string& m) const;
 
   };
 
   //!
   LDAPExpr(int op, const std::vector<LDAPExpr>& args);
 
   //!
   LDAPExpr(int op, const std::string& attrName, const std::string& attrValue);
 
   //!
   static LDAPExpr ParseExpr(ParseState& ps);
 
   //!
   static LDAPExpr ParseSimple(ParseState& ps);
 
   static std::string Trim(std::string str);
 
   static std::string ToLower(const std::string& str);
 
   //!
   bool Compare(const Any& obj, int op, const std::string& s) const;
 
   //!
   template<typename T>
   bool CompareIntegralType(const Any& obj, const int op, const std::string& s) const;
 
   //!
   static bool CompareString(const std::string& s1, int op, const std::string& s2);
 
   //!
   static std::string FixupString(const std::string &s);
 
   //!
   static bool PatSubstr(const std::string& s, const std::string& pat);
 
   //!
   static bool PatSubstr(const std::string& s, int si, const std::string& pat, int pi);
 
   //! Shared pointer
   SharedDataPointer<LDAPExprData> d;
 
 };
 
 US_END_NAMESPACE
 
 #endif // USLDAPEXPR_H
diff --git a/Modules/CppMicroServices/core/src/service/usLDAPFilter.cpp b/Modules/CppMicroServices/core/src/service/usLDAPFilter.cpp
index b755633f62..96b94699c3 100644
--- a/Modules/CppMicroServices/core/src/service/usLDAPFilter.cpp
+++ b/Modules/CppMicroServices/core/src/service/usLDAPFilter.cpp
@@ -1,121 +1,121 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usLDAPFilter.h"
 #include "usLDAPExpr_p.h"
 #include "usServicePropertiesImpl_p.h"
 #include "usServiceReference.h"
 #include "usServiceReferenceBasePrivate.h"
 
 #include <stdexcept>
 
 US_BEGIN_NAMESPACE
 
 class LDAPFilterData : public SharedData
 {
 public:
 
   LDAPFilterData() : ldapExpr()
   {}
 
   LDAPFilterData(const std::string& filter)
     : ldapExpr(filter)
   {}
 
   LDAPFilterData(const LDAPFilterData& other)
     : SharedData(other), ldapExpr(other.ldapExpr)
   {}
 
   LDAPExpr ldapExpr;
 };
 
 LDAPFilter::LDAPFilter()
   : d(nullptr)
 {
 }
 
 LDAPFilter::LDAPFilter(const std::string& filter)
   : d(nullptr)
 {
   try
   {
     d = new LDAPFilterData(filter);
   }
   catch (const std::exception& e)
   {
     throw std::invalid_argument(e.what());
   }
 }
 
 LDAPFilter::LDAPFilter(const LDAPFilter& other)
   : d(other.d)
 {
 }
 
 LDAPFilter::~LDAPFilter()
 {
 }
 
 LDAPFilter::operator bool_type() const
 {
   return d.ConstData() != nullptr ? &LDAPFilter::d : nullptr;
 }
 
 bool LDAPFilter::Match(const ServiceReferenceBase& reference) const
 {
   return d->ldapExpr.Evaluate(reference.d->GetProperties(), true);
 }
 
 bool LDAPFilter::Match(const ServiceProperties& dictionary) const
 {
   return d->ldapExpr.Evaluate(ServicePropertiesImpl(dictionary), false);
 }
 
 bool LDAPFilter::MatchCase(const ServiceProperties& dictionary) const
 {
   return d->ldapExpr.Evaluate(ServicePropertiesImpl(dictionary), true);
 }
 
 std::string LDAPFilter::ToString() const
 {
   return d->ldapExpr.ToString();
 }
 
 bool LDAPFilter::operator==(const LDAPFilter& other) const
 {
   return d->ldapExpr.ToString() == other.d->ldapExpr.ToString();
 }
 
 LDAPFilter& LDAPFilter::operator=(const LDAPFilter& filter)
 {
   d = filter.d;
 
   return *this;
 }
 
 US_END_NAMESPACE
 
 US_USE_NAMESPACE
 
 std::ostream& operator<<(std::ostream& os, const LDAPFilter& filter)
 {
   return os << filter.ToString();
 }
diff --git a/Modules/CppMicroServices/core/src/service/usServiceEvent.cpp b/Modules/CppMicroServices/core/src/service/usServiceEvent.cpp
index 2c8521a416..4e36ba6c3e 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceEvent.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceEvent.cpp
@@ -1,130 +1,130 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceEvent.h"
 
 #include "usServiceProperties.h"
 
 US_BEGIN_NAMESPACE
 
 class ServiceEventData : public SharedData
 {
 public:
 
   ServiceEventData(const ServiceEvent::Type& type, const ServiceReferenceBase& reference)
     : type(type), reference(reference)
   {
 
   }
 
   ServiceEventData(const ServiceEventData& other)
     : SharedData(other), type(other.type), reference(other.reference)
   {
 
   }
 
   const ServiceEvent::Type type;
   const ServiceReferenceBase reference;
 
 private:
 
   // purposely not implemented
   ServiceEventData& operator=(const ServiceEventData&);
 };
 
 ServiceEvent::ServiceEvent()
   : d(nullptr)
 {
 
 }
 
 ServiceEvent::~ServiceEvent()
 {
 
 }
 
 bool ServiceEvent::IsNull() const
 {
   return !d;
 }
 
 ServiceEvent::ServiceEvent(Type type, const ServiceReferenceBase& reference)
   : d(new ServiceEventData(type, reference))
 {
 
 }
 
 ServiceEvent::ServiceEvent(const ServiceEvent& other)
   : d(other.d)
 {
 
 }
 
 ServiceEvent& ServiceEvent::operator=(const ServiceEvent& other)
 {
   d = other.d;
   return *this;
 }
 
 ServiceReferenceU ServiceEvent::GetServiceReference() const
 {
   return d->reference;
 }
 
 ServiceEvent::Type ServiceEvent::GetType() const
 {
   return d->type;
 }
 
 std::ostream& operator<<(std::ostream& os, const ServiceEvent::Type& type)
 {
   switch(type)
   {
   case ServiceEvent::MODIFIED:          return os << "MODIFIED";
   case ServiceEvent::MODIFIED_ENDMATCH: return os << "MODIFIED_ENDMATCH";
   case ServiceEvent::REGISTERED:        return os << "REGISTERED";
   case ServiceEvent::UNREGISTERING:     return os << "UNREGISTERING";
 
   default: return os << "unknown service event type (" << static_cast<int>(type) << ")";
   }
 }
 
 std::ostream& operator<<(std::ostream& os, const ServiceEvent& event)
 {
   if (event.IsNull()) return os << "NONE";
 
   os << event.GetType();
 
   ServiceReferenceU sr = event.GetServiceReference();
   if (sr)
   {
     // Some events will not have a service reference
     long int sid = any_cast<long int>(sr.GetProperty(ServiceConstants::SERVICE_ID()));
     os << " " << sid;
 
     Any classes = sr.GetProperty(ServiceConstants::OBJECTCLASS());
     os << " objectClass=" << classes.ToString() << ")";
   }
 
   return os;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceEventListenerHook.cpp b/Modules/CppMicroServices/core/src/service/usServiceEventListenerHook.cpp
index 484fa27042..0ecfd2cde6 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceEventListenerHook.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceEventListenerHook.cpp
@@ -1,30 +1,30 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceEventListenerHook.h"
 
 US_BEGIN_NAMESPACE
 
 ServiceEventListenerHook::~ServiceEventListenerHook()
 {
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceException.cpp b/Modules/CppMicroServices/core/src/service/usServiceException.cpp
index 20beb9ad22..d3fb1fd96a 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceException.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceException.cpp
@@ -1,59 +1,59 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceException.h"
 
 #include <ostream>
 
 US_BEGIN_NAMESPACE
 
 ServiceException::ServiceException(const std::string& msg, const Type& type)
   : std::runtime_error(msg), type(type)
 {
 
 }
 
 ServiceException::ServiceException(const ServiceException& o)
   : std::runtime_error(o), type(o.type)
 {
 
 }
 
 ServiceException& ServiceException::operator=(const ServiceException& o)
 {
   std::runtime_error::operator=(o);
   this->type = o.type;
   return *this;
 }
 
 ServiceException::Type ServiceException::GetType() const
 {
   return type;
 }
 
 US_END_NAMESPACE
 
 US_USE_NAMESPACE
 
 std::ostream& operator<<(std::ostream& os, const ServiceException& exc)
 {
   return os << "ServiceException: " << exc.what();
 }
diff --git a/Modules/CppMicroServices/core/src/service/usServiceFindHook.cpp b/Modules/CppMicroServices/core/src/service/usServiceFindHook.cpp
index f2307a9a7d..812e14070f 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceFindHook.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceFindHook.cpp
@@ -1,30 +1,30 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceFindHook.h"
 
 US_BEGIN_NAMESPACE
 
 ServiceFindHook::~ServiceFindHook()
 {
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceHooks.cpp b/Modules/CppMicroServices/core/src/service/usServiceHooks.cpp
index 29f35310b6..3c43813f15 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceHooks.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceHooks.cpp
@@ -1,286 +1,286 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceHooks_p.h"
 
 #include "usGetModuleContext.h"
 #include "usCoreModuleContext_p.h"
 #include "usServiceEventListenerHook.h"
 #include "usServiceFindHook.h"
 #include "usServiceListenerHook.h"
 #include "usServiceReferenceBasePrivate.h"
 
 US_BEGIN_NAMESPACE
 
 ServiceHooks::ServiceHooks(CoreModuleContext* coreCtx)
   : coreCtx(coreCtx)
   , listenerHookTracker(nullptr)
   , bOpen(false)
 {
 }
 
 ServiceHooks::~ServiceHooks()
 {
   this->Close();
 }
 
 ServiceHooks::TrackedType ServiceHooks::AddingService(const ServiceReferenceType& reference)
 {
   ServiceListenerHook* lh = GetModuleContext()->GetService(reference);
   try
   {
     lh->Added(coreCtx->listeners.GetListenerInfoCollection());
   }
   catch (const std::exception& e)
   {
     US_WARN << "Failed to call listener hook  #" << reference.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                << ": " << e.what();
   }
   catch (...)
   {
     US_WARN << "Failed to call listener hook  #" << reference.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                << ": unknown exception type";
   }
   return lh;
 }
 
 void ServiceHooks::ModifiedService(const ServiceReferenceType& /*reference*/, TrackedType /*service*/)
 {
   // noop
 }
 
 void ServiceHooks::RemovedService(const ServiceReferenceType& reference, TrackedType /*service*/)
 {
   GetModuleContext()->UngetService(reference);
 }
 
 void ServiceHooks::Open()
 {
   US_UNUSED(Lock(this));
 
   listenerHookTracker = new ServiceTracker<ServiceListenerHook>(GetModuleContext(), this);
   listenerHookTracker->Open();
 
   bOpen = true;
 }
 
 void ServiceHooks::Close()
 {
   US_UNUSED(Lock(this));
   if (listenerHookTracker)
   {
     listenerHookTracker->Close();
     delete listenerHookTracker;
     listenerHookTracker = nullptr;
   }
 
   bOpen = false;
 }
 
 bool ServiceHooks::IsOpen() const
 {
   US_UNUSED(Lock(this));
   return bOpen;
 }
 
 void ServiceHooks::FilterServiceReferences(ModuleContext* mc, const std::string& service,
                                            const std::string& filter, std::vector<ServiceReferenceBase>& refs)
 {
   std::vector<ServiceRegistrationBase> srl;
   coreCtx->services.Get_unlocked(us_service_interface_iid<ServiceFindHook>(), srl);
   if (!srl.empty())
   {
     ShrinkableVector<ServiceReferenceBase> filtered(refs);
 
     std::sort(srl.begin(), srl.end());
     for (std::vector<ServiceRegistrationBase>::reverse_iterator fhrIter = srl.rbegin(), fhrEnd = srl.rend();
          fhrIter != fhrEnd; ++fhrIter)
     {
       ServiceReference<ServiceFindHook> sr = fhrIter->GetReference();
       ServiceFindHook* const fh = reinterpret_cast<ServiceFindHook*>(sr.d->GetService(GetModuleContext()->GetModule()));
       if (fh != nullptr)
       {
         try
         {
           fh->Find(mc, service, filter, filtered);
         }
         catch (const std::exception& e)
         {
           US_WARN << "Failed to call find hook  #" << sr.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                   << ": " << e.what();
         }
         catch (...)
         {
           US_WARN << "Failed to call find hook  #" << sr.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                   << ": unknown exception type";
         }
       }
     }
   }
 }
 
 void ServiceHooks::FilterServiceEventReceivers(const ServiceEvent& evt,
                                                ServiceListeners::ServiceListenerEntries& receivers)
 {
   std::vector<ServiceRegistrationBase> eventListenerHooks;
   coreCtx->services.Get_unlocked(us_service_interface_iid<ServiceEventListenerHook>(), eventListenerHooks);
   if (!eventListenerHooks.empty())
   {
     std::sort(eventListenerHooks.begin(), eventListenerHooks.end());
     std::map<ModuleContext*, std::vector<ServiceListenerHook::ListenerInfo> > listeners;
     for (ServiceListeners::ServiceListenerEntries::iterator sleIter = receivers.begin(),
          sleEnd = receivers.end(); sleIter != sleEnd; ++sleIter)
     {
       listeners[sleIter->GetModuleContext()].push_back(*sleIter);
     }
 
     std::map<ModuleContext*, ShrinkableVector<ServiceListenerHook::ListenerInfo> > shrinkableListeners;
     for (std::map<ModuleContext*, std::vector<ServiceListenerHook::ListenerInfo> >::iterator iter = listeners.begin(),
          iterEnd = listeners.end(); iter != iterEnd; ++iter)
     {
       shrinkableListeners.insert(std::make_pair(iter->first, ShrinkableVector<ServiceListenerHook::ListenerInfo>(iter->second)));
     }
 
     ShrinkableMap<ModuleContext*, ShrinkableVector<ServiceListenerHook::ListenerInfo> > filtered(shrinkableListeners);
 
     for(std::vector<ServiceRegistrationBase>::reverse_iterator sriIter = eventListenerHooks.rbegin(),
         sriEnd = eventListenerHooks.rend(); sriIter != sriEnd; ++sriIter)
     {
       ServiceReference<ServiceEventListenerHook> sr = sriIter->GetReference();
       ServiceEventListenerHook* elh = reinterpret_cast<ServiceEventListenerHook*>(sr.d->GetService(GetModuleContext()->GetModule()));
       if(elh != nullptr)
       {
         try
         {
           elh->Event(evt, filtered);
         }
         catch(const std::exception& e)
         {
           US_WARN << "Failed to call event hook  #" << sr.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                   << ": " << e.what();
         }
         catch(...)
         {
           US_WARN << "Failed to call event hook  #" << sr.GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                   << ": unknown exception type";
         }
       }
     }
     receivers.clear();
     for(std::map<ModuleContext*, std::vector<ServiceListenerHook::ListenerInfo> >::iterator iter = listeners.begin(),
         iterEnd = listeners.end(); iter != iterEnd; ++iter)
     {
       receivers.insert(iter->second.begin(), iter->second.end());
     }
   }
 }
 
 void ServiceHooks::HandleServiceListenerReg(const ServiceListenerEntry& sle)
 {
   if(!IsOpen() || listenerHookTracker->Size() == 0)
   {
     return;
   }
 
   std::vector<ServiceReference<ServiceListenerHook> > srl
       = listenerHookTracker->GetServiceReferences();
 
   if (!srl.empty())
   {
     std::sort(srl.begin(), srl.end());
 
     std::vector<ServiceListenerHook::ListenerInfo> set;
     set.push_back(sle);
     for (std::vector<ServiceReference<ServiceListenerHook> >::reverse_iterator srIter = srl.rbegin(),
          srEnd = srl.rend(); srIter != srEnd; ++srIter)
     {
       ServiceListenerHook* lh = listenerHookTracker->GetService(*srIter);
       try
       {
         lh->Added(set);
       }
       catch (const std::exception& e)
       {
         US_WARN << "Failed to call listener hook #" << srIter->GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                 << ": " << e.what();
       }
       catch (...)
       {
         US_WARN << "Failed to call listener hook #" << srIter->GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                 << ": unknown exception";
       }
     }
   }
 }
 
 void ServiceHooks::HandleServiceListenerUnreg(const ServiceListenerEntry& sle)
 {
   if(IsOpen())
   {
     std::vector<ServiceListenerEntry> set;
     set.push_back(sle);
     HandleServiceListenerUnreg(set);
   }
 }
 
 void ServiceHooks::HandleServiceListenerUnreg(const std::vector<ServiceListenerEntry>& set)
 {
   if(!IsOpen() || listenerHookTracker->Size() == 0)
   {
     return;
   }
 
   std::vector<ServiceReference<ServiceListenerHook> > srl
       = listenerHookTracker->GetServiceReferences();
 
   if (!srl.empty())
   {
     std::vector<ServiceListenerHook::ListenerInfo> lis;
     for (std::vector<ServiceListenerEntry>::const_iterator sleIter = set.begin(),
          sleEnd = set.end(); sleIter != sleEnd; ++sleIter)
     {
       lis.push_back(*sleIter);
     }
 
     std::sort(srl.begin(), srl.end());
     for (std::vector<ServiceReference<ServiceListenerHook> >::reverse_iterator srIter = srl.rbegin(),
          srEnd = srl.rend(); srIter != srEnd; ++srIter)
     {
       ServiceListenerHook* const lh = listenerHookTracker->GetService(*srIter);
       try
       {
         lh->Removed(lis);
       }
       catch (const std::exception& e)
       {
         US_WARN << "Failed to call listener hook #" << srIter->GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                 << ": " << e.what();
       }
       catch (...)
       {
         US_WARN << "Failed to call listener hook #" << srIter->GetProperty(ServiceConstants::SERVICE_ID()).ToString()
                 << ": unknown exception type";
       }
     }
   }
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceHooks_p.h b/Modules/CppMicroServices/core/src/service/usServiceHooks_p.h
index a7f0546edb..28753febe0 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceHooks_p.h
+++ b/Modules/CppMicroServices/core/src/service/usServiceHooks_p.h
@@ -1,73 +1,73 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEHOOKS_P_H
 #define USSERVICEHOOKS_P_H
 
 #include "usServiceTracker.h"
 #include "usServiceListeners_p.h"
 
 US_BEGIN_NAMESPACE
 
 struct ServiceListenerHook;
 
 class ServiceHooks : private MultiThreaded<>, private ServiceTrackerCustomizer<ServiceListenerHook>
 {
 
 private:
 
   CoreModuleContext* coreCtx;
   ServiceTracker<ServiceListenerHook>* listenerHookTracker;
 
   bool bOpen;
 
   TrackedType AddingService(const ServiceReferenceType& reference) override;
   void ModifiedService(const ServiceReferenceType& reference, TrackedType service) override;
   void RemovedService(const ServiceReferenceType& reference, TrackedType service) override;
 
 public:
 
   ServiceHooks(CoreModuleContext* coreCtx);
   ~ServiceHooks() override;
 
   void Open();
 
   void Close();
 
   bool IsOpen() const;
 
   void FilterServiceReferences(ModuleContext* mc, const std::string& service,
                                const std::string& filter, std::vector<ServiceReferenceBase>& refs);
 
   void FilterServiceEventReceivers(const ServiceEvent& evt,
                                    ServiceListeners::ServiceListenerEntries& receivers);
 
   void HandleServiceListenerReg(const ServiceListenerEntry& sle);
 
   void HandleServiceListenerUnreg(const ServiceListenerEntry& sle);
 
   void HandleServiceListenerUnreg(const std::vector<ServiceListenerEntry>& set);
 
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICEHOOKS_P_H
diff --git a/Modules/CppMicroServices/core/src/service/usServiceListenerEntry.cpp b/Modules/CppMicroServices/core/src/service/usServiceListenerEntry.cpp
index f281c846fb..bf886845cd 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceListenerEntry.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceListenerEntry.cpp
@@ -1,148 +1,148 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceListenerEntry_p.h"
 #include "usServiceListenerHook_p.h"
 
 #include <cassert>
 
 US_BEGIN_NAMESPACE
 
 class ServiceListenerEntryData : public ServiceListenerHook::ListenerInfoData
 {
 public:
 
   ServiceListenerEntryData(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& l,
                            void* data, const std::string& filter)
     : ServiceListenerHook::ListenerInfoData(mc, l, data, filter)
     , ldap()
     , hashValue(0)
   {
     if (!filter.empty())
     {
       ldap = LDAPExpr(filter);
     }
   }
 
   ~ServiceListenerEntryData() override
   {
   }
 
   LDAPExpr ldap;
 
   /**
    * The elements of "simple" filters are cached, for easy lookup.
    *
    * The grammar for simple filters is as follows:
    *
    * <pre>
    * Simple = '(' attr '=' value ')'
    *        | '(' '|' Simple+ ')'
    * </pre>
    * where <code>attr</code> is one of Constants#OBJECTCLASS,
    * Constants#SERVICE_ID or Constants#SERVICE_PID, and
    * <code>value</code> must not contain a wildcard character.
    * <p>
    * The index of the vector determines which key the cache is for
    * (see ServiceListenerState#hashedKeys). For each key, there is
    * a vector pointing out the values which are accepted by this
    * ServiceListenerEntry's filter. This cache is maintained to make
    * it easy to remove this service listener.
    */
   LDAPExpr::LocalCache local_cache;
 
   std::size_t hashValue;
 
 private:
 
   // purposely not implemented
   ServiceListenerEntryData(const ServiceListenerEntryData&);
   ServiceListenerEntryData& operator=(const ServiceListenerEntryData&);
 };
 
 ServiceListenerEntry::ServiceListenerEntry(const ServiceListenerEntry& other)
   : ServiceListenerHook::ListenerInfo(other)
 {
 }
 
 ServiceListenerEntry::ServiceListenerEntry(const ServiceListenerHook::ListenerInfo& info)
   : ServiceListenerHook::ListenerInfo(info)
 {
   assert(info.d);
 }
 
 ServiceListenerEntry::~ServiceListenerEntry()
 {
 }
 
 ServiceListenerEntry& ServiceListenerEntry::operator=(const ServiceListenerEntry& other)
 {
   d = other.d;
   return *this;
 }
 
 void ServiceListenerEntry::SetRemoved(bool removed) const
 {
   d->bRemoved = removed;
 }
 
 ServiceListenerEntry::ServiceListenerEntry(ModuleContext* mc, const ServiceListener& l,
                                            void* data, const std::string& filter)
   : ServiceListenerHook::ListenerInfo(new ServiceListenerEntryData(mc, l, data, filter))
 {
 }
 
 const LDAPExpr& ServiceListenerEntry::GetLDAPExpr() const
 {
   return static_cast<ServiceListenerEntryData*>(d.Data())->ldap;
 }
 
 LDAPExpr::LocalCache& ServiceListenerEntry::GetLocalCache() const
 {
   return static_cast<ServiceListenerEntryData*>(d.Data())->local_cache;
 }
 
 void ServiceListenerEntry::CallDelegate(const ServiceEvent& event) const
 {
   d->listener(event);
 }
 
 bool ServiceListenerEntry::operator==(const ServiceListenerEntry& other) const
 {
   return ((d->mc == nullptr || other.d->mc == nullptr) || d->mc == other.d->mc) &&
       (d->data == other.d->data) && ServiceListenerCompare()(d->listener, other.d->listener);
 }
 
 std::size_t ServiceListenerEntry::Hash() const
 {
   using namespace US_HASH_FUNCTION_NAMESPACE;
 
   if (static_cast<ServiceListenerEntryData*>(d.Data())->hashValue == 0)
   {
     static_cast<ServiceListenerEntryData*>(d.Data())->hashValue =
         ((US_HASH_FUNCTION(ModuleContext*, d->mc) ^ (US_HASH_FUNCTION(void*, d->data) << 1)) >> 1) ^
         (US_HASH_FUNCTION(US_SERVICE_LISTENER_FUNCTOR, d->listener) << 1);
   }
   return static_cast<ServiceListenerEntryData*>(d.Data())->hashValue;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceListenerEntry_p.h b/Modules/CppMicroServices/core/src/service/usServiceListenerEntry_p.h
index 1fa9d11dc1..27e4943e32 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceListenerEntry_p.h
+++ b/Modules/CppMicroServices/core/src/service/usServiceListenerEntry_p.h
@@ -1,79 +1,79 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICELISTENERENTRY_H
 #define USSERVICELISTENERENTRY_H
 
 #include <usUtils_p.h>
 #include <usServiceListenerHook.h>
 #include <usListenerFunctors_p.h>
 
 #include "usLDAPExpr_p.h"
 
 US_BEGIN_NAMESPACE
 
 class Module;
 class ServiceListenerEntryData;
 
 /**
  * Data structure for saving service listener info. Contains
  * the optional service listener filter, in addition to the info
  * in ListenerEntry.
  */
 class ServiceListenerEntry : public ServiceListenerHook::ListenerInfo
 {
 
 public:
 
   typedef US_SERVICE_LISTENER_FUNCTOR ServiceListener;
 
   ServiceListenerEntry(const ServiceListenerEntry& other);
   ServiceListenerEntry(const ServiceListenerHook::ListenerInfo& info);
 
   ~ServiceListenerEntry();
   ServiceListenerEntry& operator=(const ServiceListenerEntry& other);
 
   void SetRemoved(bool removed) const;
 
   ServiceListenerEntry(ModuleContext* mc, const ServiceListener& l, void* data, const std::string& filter = "");
 
   const LDAPExpr& GetLDAPExpr() const;
 
   LDAPExpr::LocalCache& GetLocalCache() const;
 
   void CallDelegate(const ServiceEvent& event) const;
 
   bool operator==(const ServiceListenerEntry& other) const;
 
   std::size_t Hash() const;
 
 };
 
 US_END_NAMESPACE
 
 US_HASH_FUNCTION_NAMESPACE_BEGIN
 US_HASH_FUNCTION_BEGIN(US_PREPEND_NAMESPACE(ServiceListenerEntry))
   return arg.Hash();
 US_HASH_FUNCTION_END
 US_HASH_FUNCTION_NAMESPACE_END
 
 #endif // USSERVICELISTENERENTRY_H
diff --git a/Modules/CppMicroServices/core/src/service/usServiceListenerHook.cpp b/Modules/CppMicroServices/core/src/service/usServiceListenerHook.cpp
index 90615efba0..c82b006313 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceListenerHook.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceListenerHook.cpp
@@ -1,96 +1,96 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceListenerHook.h"
 #include "usServiceListenerHook_p.h"
 
 US_BEGIN_NAMESPACE
 
 ServiceListenerHook::~ServiceListenerHook()
 {
 }
 
 ServiceListenerHook::ListenerInfoData::ListenerInfoData(
     ModuleContext* mc, const ServiceListenerEntry::ServiceListener& l,
     void* data, const std::string& filter)
   : mc(mc)
   , listener(l)
   , data(data)
   , filter(filter)
   , bRemoved(false)
 {
 }
 
 ServiceListenerHook::ListenerInfoData::~ListenerInfoData()
 {
 }
 
 ServiceListenerHook::ListenerInfo::ListenerInfo(ListenerInfoData* data)
   : d(data)
 {
 }
 
 ServiceListenerHook::ListenerInfo::ListenerInfo()
   : d(nullptr)
 {
 }
 
 ServiceListenerHook::ListenerInfo::ListenerInfo(const ListenerInfo& other)
   : d(other.d)
 {
 }
 
 ServiceListenerHook::ListenerInfo::~ListenerInfo()
 {
 }
 
 ServiceListenerHook::ListenerInfo& ServiceListenerHook::ListenerInfo::operator=(const ListenerInfo& other)
 {
   d = other.d;
   return *this;
 }
 
 bool ServiceListenerHook::ListenerInfo::IsNull() const
 {
   return !d;
 }
 
 ModuleContext* ServiceListenerHook::ListenerInfo::GetModuleContext() const
 {
   return d->mc;
 }
 
 std::string ServiceListenerHook::ListenerInfo::GetFilter() const
 {
   return d->filter;
 }
 
 bool ServiceListenerHook::ListenerInfo::IsRemoved() const
 {
   return d->bRemoved;
 }
 
 bool ServiceListenerHook::ListenerInfo::operator==(const ListenerInfo& other) const
 {
   return d == other.d;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceListenerHook_p.h b/Modules/CppMicroServices/core/src/service/usServiceListenerHook_p.h
index 22050a3c78..21929bd411 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceListenerHook_p.h
+++ b/Modules/CppMicroServices/core/src/service/usServiceListenerHook_p.h
@@ -1,48 +1,48 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICELISTENERHOOK_P_H
 #define USSERVICELISTENERHOOK_P_H
 
 #include "usServiceListenerHook.h"
 #include "usServiceListenerEntry_p.h"
 #include "usSharedData.h"
 
 US_BEGIN_NAMESPACE
 
 class ServiceListenerHook::ListenerInfoData : public SharedData
 {
 public:
   ListenerInfoData(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& l,
                    void* data, const std::string& filter);
 
   virtual ~ListenerInfoData();
 
   ModuleContext* const mc;
   ServiceListenerEntry::ServiceListener listener;
   void* data;
   std::string filter;
   bool bRemoved;
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICELISTENERHOOK_P_H
diff --git a/Modules/CppMicroServices/core/src/service/usServiceListeners.cpp b/Modules/CppMicroServices/core/src/service/usServiceListeners.cpp
index e134fe8e27..b4f4bf51bd 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceListeners.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceListeners.cpp
@@ -1,334 +1,334 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usUtils_p.h"
 
 #include "usServiceListeners_p.h"
 #include "usServiceReferenceBasePrivate.h"
 
 #include "usCoreModuleContext_p.h"
 #include "usModule.h"
 #include "usModuleContext.h"
 
 
 US_BEGIN_NAMESPACE
 
 const int ServiceListeners::OBJECTCLASS_IX = 0;
 const int ServiceListeners::SERVICE_ID_IX = 1;
 
 ServiceListeners::ServiceListeners(CoreModuleContext* coreCtx)
   : coreCtx(coreCtx)
 {
   hashedServiceKeys.push_back(ServiceConstants::OBJECTCLASS());
   hashedServiceKeys.push_back(ServiceConstants::SERVICE_ID());
 }
 
 void ServiceListeners::AddServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener,
                                           void* data, const std::string& filter)
 {
   US_UNUSED(Lock(this));
 
   ServiceListenerEntry sle(mc, listener, data, filter);
   RemoveServiceListener_unlocked(sle);
 
   serviceSet.insert(sle);
   coreCtx->serviceHooks.HandleServiceListenerReg(sle);
   CheckSimple(sle);
 }
 
 void ServiceListeners::RemoveServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener,
                                              void* data)
 {
   ServiceListenerEntry entryToRemove(mc, listener, data);
 
   US_UNUSED(Lock(this));
   RemoveServiceListener_unlocked(entryToRemove);
 }
 
 void ServiceListeners::RemoveServiceListener_unlocked(const ServiceListenerEntry& entryToRemove)
 {
   ServiceListenerEntries::const_iterator it = serviceSet.find(entryToRemove);
   if (it != serviceSet.end())
   {
     it->SetRemoved(true);
     coreCtx->serviceHooks.HandleServiceListenerUnreg(*it);
     RemoveFromCache(*it);
     serviceSet.erase(it);
   }
 }
 
 void ServiceListeners::AddModuleListener(ModuleContext* mc, const ModuleListener& listener, void* data)
 {
   MutexLock lock(moduleListenerMapMutex);
   ModuleListenerMap::value_type::second_type& listeners = moduleListenerMap[mc];
   if (std::find_if(listeners.begin(), listeners.end(), std::bind(ModuleListenerCompare(), std::make_pair(listener, data), std::placeholders::_1)) == listeners.end())
   {
     listeners.push_back(std::make_pair(listener, data));
   }
 }
 
 void ServiceListeners::RemoveModuleListener(ModuleContext* mc, const ModuleListener& listener, void* data)
 {
   MutexLock lock(moduleListenerMapMutex);
   moduleListenerMap[mc].remove_if(std::bind(ModuleListenerCompare(), std::make_pair(listener, data), std::placeholders::_1));
 }
 
 void ServiceListeners::ModuleChanged(const ModuleEvent& evt)
 {
   ModuleListenerMap filteredModuleListeners;
   coreCtx->moduleHooks.FilterModuleEventReceivers(evt, filteredModuleListeners);
 
   for(ModuleListenerMap::iterator iter = filteredModuleListeners.begin(), end = filteredModuleListeners.end();
       iter != end; ++iter)
   {
     for (ModuleListenerMap::mapped_type::iterator iter2 = iter->second.begin(), end2 = iter->second.end();
          iter2 != end2; ++iter2)
     {
       try
       {
         (iter2->first)(evt);
       }
       catch (const std::exception& e)
       {
         US_WARN << "Module listener threw an exception: " << e.what();
       }
     }
   }
 }
 
 void ServiceListeners::RemoveAllListeners(ModuleContext* mc)
 {
   {
     US_UNUSED(Lock(this));
     for (ServiceListenerEntries::iterator it = serviceSet.begin();
          it != serviceSet.end(); )
     {
 
       if (it->GetModuleContext() == mc)
       {
         RemoveFromCache(*it);
         serviceSet.erase(it++);
       }
       else
       {
         ++it;
       }
     }
   }
 
   {
     MutexLock lock(moduleListenerMapMutex);
     moduleListenerMap.erase(mc);
   }
 }
 
 void ServiceListeners::HooksModuleStopped(ModuleContext* mc)
 {
   US_UNUSED(Lock(this));
   std::vector<ServiceListenerEntry> entries;
   for (ServiceListenerEntries::iterator it = serviceSet.begin();
        it != serviceSet.end(); )
   {
     if (it->GetModuleContext() == mc)
     {
       entries.push_back(*it);
     }
   }
   coreCtx->serviceHooks.HandleServiceListenerUnreg(entries);
 }
 
 void ServiceListeners::ServiceChanged(ServiceListenerEntries& receivers,
                                       const ServiceEvent& evt)
 {
   ServiceListenerEntries matchBefore;
   ServiceChanged(receivers, evt, matchBefore);
 }
 
 void ServiceListeners::ServiceChanged(ServiceListenerEntries& receivers,
                                       const ServiceEvent& evt,
                                       ServiceListenerEntries& matchBefore)
 {
   int n = 0;
 
   if (!matchBefore.empty())
   {
     for (ServiceListenerEntries::const_iterator l = receivers.begin();
          l != receivers.end(); ++l)
     {
       matchBefore.erase(*l);
     }
   }
 
   for (ServiceListenerEntries::const_iterator l = receivers.begin();
        l != receivers.end(); ++l)
   {
     if (!l->IsRemoved())
     {
       try
       {
         ++n;
         l->CallDelegate(evt);
       }
       catch (...)
       {
         US_WARN << "Service listener"
                 << " in " << l->GetModuleContext()->GetModule()->GetName()
                 << " threw an exception!";
       }
     }
   }
 
   //US_DEBUG << "Notified " << n << " listeners";
 }
 
 void ServiceListeners::GetMatchingServiceListeners(const ServiceEvent& evt, ServiceListenerEntries& set,
                                                    bool lockProps)
 {
   US_UNUSED(Lock(this));
 
   // Filter the original set of listeners
   ServiceListenerEntries receivers = serviceSet;
   coreCtx->serviceHooks.FilterServiceEventReceivers(evt, receivers);
 
   // Check complicated or empty listener filters
   for (std::list<ServiceListenerEntry>::const_iterator sse = complicatedListeners.begin();
        sse != complicatedListeners.end(); ++sse)
   {
     if (receivers.count(*sse) == 0) continue;
     const LDAPExpr& ldapExpr = sse->GetLDAPExpr();
     if (ldapExpr.IsNull() ||
         ldapExpr.Evaluate(evt.GetServiceReference().d->GetProperties(), false))
     {
       set.insert(*sse);
     }
   }
 
   //US_DEBUG << "Added " << set.size() << " out of " << n
   //         << " listeners with complicated filters";
 
   // Check the cache
   const std::vector<std::string> c(any_cast<std::vector<std::string> >
                                  (evt.GetServiceReference().d->GetProperty(ServiceConstants::OBJECTCLASS(), lockProps)));
   for (std::vector<std::string>::const_iterator objClass = c.begin();
        objClass != c.end(); ++objClass)
   {
     AddToSet(set, receivers, OBJECTCLASS_IX, *objClass);
   }
 
   long service_id = any_cast<long>(evt.GetServiceReference().d->GetProperty(ServiceConstants::SERVICE_ID(), lockProps));
   std::stringstream ss;
   ss << service_id;
   AddToSet(set, receivers, SERVICE_ID_IX, ss.str());
 }
 
 std::vector<ServiceListenerHook::ListenerInfo> ServiceListeners::GetListenerInfoCollection() const
 {
   US_UNUSED(Lock(this));
   std::vector<ServiceListenerHook::ListenerInfo> result;
   result.reserve(serviceSet.size());
   for (ServiceListenerEntries::const_iterator iter = serviceSet.begin(),
        iterEnd = serviceSet.end(); iter != iterEnd; ++iter)
   {
     result.push_back(*iter);
   }
   return result;
 }
 
 void ServiceListeners::RemoveFromCache(const ServiceListenerEntry& sle)
 {
   if (!sle.GetLocalCache().empty())
   {
     for (std::size_t i = 0; i < hashedServiceKeys.size(); ++i)
     {
       CacheType& keymap = cache[i];
       std::vector<std::string>& l = sle.GetLocalCache()[i];
       for (std::vector<std::string>::const_iterator it = l.begin();
            it != l.end(); ++it)
       {
         std::list<ServiceListenerEntry>& sles = keymap[*it];
         sles.remove(sle);
         if (sles.empty())
         {
           keymap.erase(*it);
         }
       }
     }
   }
   else
   {
     complicatedListeners.remove(sle);
   }
 }
 
  void ServiceListeners::CheckSimple(const ServiceListenerEntry& sle) {
    if (sle.GetLDAPExpr().IsNull())
    {
      complicatedListeners.push_back(sle);
    }
    else
    {
      LDAPExpr::LocalCache local_cache;
      if (sle.GetLDAPExpr().IsSimple(hashedServiceKeys, local_cache, false))
      {
        sle.GetLocalCache() = local_cache;
        for (std::size_t i = 0; i < hashedServiceKeys.size(); ++i)
        {
          for (std::vector<std::string>::const_iterator it = local_cache[i].begin();
               it != local_cache[i].end(); ++it)
          {
            std::list<ServiceListenerEntry>& sles = cache[i][*it];
            sles.push_back(sle);
          }
        }
      }
      else
      {
        //US_DEBUG << "Too complicated filter: " << sle.GetFilter();
        complicatedListeners.push_back(sle);
      }
    }
  }
 
 void ServiceListeners::AddToSet(ServiceListenerEntries& set,
                                 const ServiceListenerEntries& receivers,
                                 int cache_ix, const std::string& val)
 {
   std::list<ServiceListenerEntry>& l = cache[cache_ix][val];
   if (!l.empty())
   {
     //US_DEBUG << hashedServiceKeys[cache_ix] << " matches " << l.size();
 
     for (std::list<ServiceListenerEntry>::const_iterator entry = l.begin();
          entry != l.end(); ++entry)
     {
       if (receivers.count(*entry))
       {
         set.insert(*entry);
       }
     }
   }
   else
   {
     //US_DEBUG << hashedServiceKeys[cache_ix] << " matches none";
   }
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceListeners_p.h b/Modules/CppMicroServices/core/src/service/usServiceListeners_p.h
index 34e2280f67..f1b11e091b 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceListeners_p.h
+++ b/Modules/CppMicroServices/core/src/service/usServiceListeners_p.h
@@ -1,181 +1,181 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICELISTENERS_H
 #define USSERVICELISTENERS_H
 
 #include <list>
 #include <string>
 #include <set>
 
 #include <usGlobalConfig.h>
 
 #include "usServiceListenerEntry_p.h"
 
 US_BEGIN_NAMESPACE
 
 class CoreModuleContext;
 class ModuleContext;
 
 /**
  * Here we handle all listeners that modules have registered.
  *
  */
 class ServiceListeners : private MultiThreaded<>
 {
 
 public:
 
   typedef US_MODULE_LISTENER_FUNCTOR ModuleListener;
   typedef US_UNORDERED_MAP_TYPE<ModuleContext*, std::list<std::pair<ModuleListener,void*> > > ModuleListenerMap;
   ModuleListenerMap moduleListenerMap;
   Mutex moduleListenerMapMutex;
 
   typedef US_UNORDERED_MAP_TYPE<std::string, std::list<ServiceListenerEntry> > CacheType;
   typedef US_UNORDERED_SET_TYPE<ServiceListenerEntry> ServiceListenerEntries;
 
 private:
 
   std::vector<std::string> hashedServiceKeys;
   static const int OBJECTCLASS_IX; // = 0;
   static const int SERVICE_ID_IX; // = 1;
 
   /* Service listeners with complicated or empty filters */
   std::list<ServiceListenerEntry> complicatedListeners;
 
   /* Service listeners with "simple" filters are cached. */
   CacheType cache[2];
 
   ServiceListenerEntries serviceSet;
 
   CoreModuleContext* coreCtx;
 
 public:
 
   ServiceListeners(CoreModuleContext* coreCtx);
 
   /**
    * Add a new service listener. If an old one exists, and it has the
    * same owning module, the old listener is removed first.
    *
    * @param mc The module context adding this listener.
    * @param listener The service listener to add.
    * @param data Additional data to distinguish ServiceListener objects.
    * @param filter An LDAP filter string to check when a service is modified.
    * @exception org.osgi.framework.InvalidSyntaxException
    * If the filter is not a correct LDAP expression.
    */
   void AddServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener,
                           void* data, const std::string& filter);
 
   /**
    * Remove service listener from current framework. Silently ignore
    * if listener doesn't exist. If listener is registered more than
    * once remove all instances.
    *
    * @param mc The module context who wants to remove listener.
    * @param listener Object to remove.
    * @param data Additional data to distinguish ServiceListener objects.
    */
   void RemoveServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener,
                              void* data);
 
   /**
    * Add a new module listener.
    *
    * @param mc The module context adding this listener.
    * @param listener The module listener to add.
    * @param data Additional data to distinguish ModuleListener objects.
    */
   void AddModuleListener(ModuleContext* mc, const ModuleListener& listener, void* data);
 
   /**
    * Remove module listener from current framework. Silently ignore
    * if listener doesn't exist.
    *
    * @param mc The module context who wants to remove listener.
    * @param listener Object to remove.
    * @param data Additional data to distinguish ModuleListener objects.
    */
   void RemoveModuleListener(ModuleContext* mc, const ModuleListener& listener, void* data);
 
   void ModuleChanged(const ModuleEvent& evt);
 
   /**
    * Remove all listener registered by a module in the current framework.
    *
    * @param mc Module context which listeners we want to remove.
    */
   void RemoveAllListeners(ModuleContext* mc);
 
   /**
    * Notify hooks that a module is about to be stopped
    *
    * @param mc Module context which listeners are about to be removed.
    */
   void HooksModuleStopped(ModuleContext* mc);
 
   /**
    * Receive notification that a service has had a change occur in its lifecycle.
    *
    * @see org.osgi.framework.ServiceListener#serviceChanged
    */
   void ServiceChanged(ServiceListenerEntries& receivers,
                       const ServiceEvent& evt,
                       ServiceListenerEntries& matchBefore);
 
   void ServiceChanged(ServiceListenerEntries& receivers,
                       const ServiceEvent& evt);
 
   /**
    *
    *
    */
   void GetMatchingServiceListeners(const ServiceEvent& evt, ServiceListenerEntries& listeners,
                                    bool lockProps = true);
 
 
   std::vector<ServiceListenerHook::ListenerInfo> GetListenerInfoCollection() const;
 
 private:
 
   void RemoveServiceListener_unlocked(const ServiceListenerEntry& entryToRemove);
 
   /**
    * Remove all references to a service listener from the service listener
    * cache.
    */
   void RemoveFromCache(const ServiceListenerEntry& sle);
 
   /**
    * Checks if the specified service listener's filter is simple enough
    * to cache.
    */
   void CheckSimple(const ServiceListenerEntry& sle);
 
   void AddToSet(ServiceListenerEntries& set, const ServiceListenerEntries& receivers, int cache_ix, const std::string& val);
 
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICELISTENERS_H
diff --git a/Modules/CppMicroServices/core/src/service/usServiceObjects.cpp b/Modules/CppMicroServices/core/src/service/usServiceObjects.cpp
index 797c4b6ba2..eccea0a4e5 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceObjects.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceObjects.cpp
@@ -1,210 +1,210 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceObjects.h"
 
 #include "usServiceReferenceBasePrivate.h"
 
 #include <set>
 
 US_BEGIN_NAMESPACE
 
 class ServiceObjectsBasePrivate
 {
 public:
 
   AtomicInt ref;
 
   ModuleContext* m_context;
   ServiceReferenceBase m_reference;
 
   // This is used by all ServiceObjects<S> instances with S != void
   std::map<void*, InterfaceMap> m_serviceInstances;
   // This is used by ServiceObjects<void>
   std::set<InterfaceMap> m_serviceInterfaceMaps;
 
   ServiceObjectsBasePrivate(ModuleContext* context, const ServiceReferenceBase& reference)
     : m_context(context)
     , m_reference(reference)
   {}
 
   InterfaceMap GetServiceInterfaceMap()
   {
     InterfaceMap result;
 
     bool isPrototypeScope = m_reference.GetProperty(ServiceConstants::SERVICE_SCOPE()).ToString() ==
                             ServiceConstants::SCOPE_PROTOTYPE();
 
     if (isPrototypeScope)
     {
       result = m_reference.d->GetPrototypeService(m_context->GetModule());
     }
     else
     {
       result = m_reference.d->GetServiceInterfaceMap(m_context->GetModule());
     }
 
     return result;
   }
 };
 
 ServiceObjectsBase::ServiceObjectsBase(ModuleContext* context, const ServiceReferenceBase& reference)
   : d(new ServiceObjectsBasePrivate(context, reference))
 {
   if (!reference)
   {
     delete d;
     throw std::invalid_argument("The service reference is invalid");
   }
   d->ref.Ref();
 }
 
 void* ServiceObjectsBase::GetService() const
 {
   if (!d->m_reference)
   {
     return nullptr;
   }
 
   InterfaceMap im = d->GetServiceInterfaceMap();
   void* result = im.find(d->m_reference.GetInterfaceId())->second;
 
   if (result)
   {
     d->m_serviceInstances.insert(std::make_pair(result, im));
   }
   return result;
 }
 
 InterfaceMap ServiceObjectsBase::GetServiceInterfaceMap() const
 {
   InterfaceMap result;
   if (!d->m_reference)
   {
     return result;
   }
 
   result = d->GetServiceInterfaceMap();
 
   if (!result.empty())
   {
     d->m_serviceInterfaceMaps.insert(result);
   }
   return result;
 }
 
 void ServiceObjectsBase::UngetService(void* service)
 {
   if (service == nullptr)
   {
     return;
   }
 
   std::map<void*,InterfaceMap>::iterator serviceIter = d->m_serviceInstances.find(service);
   if (serviceIter == d->m_serviceInstances.end())
   {
     throw std::invalid_argument("The provided service has not been retrieved via this ServiceObjects instance");
   }
 
   if (!d->m_reference.d->UngetPrototypeService(d->m_context->GetModule(), serviceIter->second))
   {
     US_WARN << "Ungetting service unsuccessful";
   }
   else
   {
     d->m_serviceInstances.erase(serviceIter);
   }
 }
 
 void ServiceObjectsBase::UngetService(const InterfaceMap& interfaceMap)
 {
   if (interfaceMap.empty())
   {
     return;
   }
 
   std::set<InterfaceMap>::iterator serviceIter = d->m_serviceInterfaceMaps.find(interfaceMap);
   if (serviceIter == d->m_serviceInterfaceMaps.end())
   {
     throw std::invalid_argument("The provided service has not been retrieved via this ServiceObjects instance");
   }
 
   if (!d->m_reference.d->UngetPrototypeService(d->m_context->GetModule(), interfaceMap))
   {
     US_WARN << "Ungetting service unsuccessful";
   }
   else
   {
     d->m_serviceInterfaceMaps.erase(serviceIter);
   }
 }
 
 ServiceReferenceBase ServiceObjectsBase::GetReference() const
 {
   return d->m_reference;
 }
 
 ServiceObjectsBase::ServiceObjectsBase(const ServiceObjectsBase& other)
   : d(other.d)
 {
   d->ref.Ref();
 }
 
 ServiceObjectsBase::~ServiceObjectsBase()
 {
   if (!d->ref.Deref())
   {
     delete d;
   }
 }
 
 ServiceObjectsBase& ServiceObjectsBase::operator =(const ServiceObjectsBase& other)
 {
   ServiceObjectsBasePrivate* curr_d = d;
   d = other.d;
   d->ref.Ref();
 
   if (!curr_d->ref.Deref())
     delete curr_d;
 
   return *this;
 }
 
 InterfaceMap ServiceObjects<void>::GetService() const
 {
   return this->ServiceObjectsBase::GetServiceInterfaceMap();
 }
 
 void ServiceObjects<void>::UngetService(const InterfaceMap& service)
 {
   this->ServiceObjectsBase::UngetService(service);
 }
 
 ServiceReferenceU ServiceObjects<void>::GetServiceReference() const
 {
   return this->ServiceObjectsBase::GetReference();
 }
 
 ServiceObjects<void>::ServiceObjects(ModuleContext* context, const ServiceReferenceU& reference)
   : ServiceObjectsBase(context, reference)
 {}
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceProperties.cpp b/Modules/CppMicroServices/core/src/service/usServiceProperties.cpp
index 699d8ff4bd..1266bf16fb 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceProperties.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceProperties.cpp
@@ -1,82 +1,82 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceProperties.h"
 
 #include <algorithm>
 
 US_BEGIN_NAMESPACE
 
 const std::string& ServiceConstants::OBJECTCLASS()
 {
   static const std::string s("objectclass");
   return s;
 }
 
 const std::string& ServiceConstants::SERVICE_ID()
 {
   static const std::string s("service.id");
   return s;
 }
 
 const std::string& ServiceConstants::SERVICE_RANKING()
 {
   static const std::string s("service.ranking");
   return s;
 }
 
 const std::string& ServiceConstants::SERVICE_SCOPE()
 {
   static const std::string s("service.scope");
   return s;
 }
 
 const std::string& ServiceConstants::SCOPE_SINGLETON()
 {
   static const std::string s("singleton");
   return s;
 }
 
 const std::string& ServiceConstants::SCOPE_MODULE()
 {
   static const std::string s("module");
   return s;
 }
 
 const std::string& ServiceConstants::SCOPE_PROTOTYPE()
 {
   static const std::string s("prototype");
   return s;
 }
 
 US_END_NAMESPACE
 
 US_USE_NAMESPACE
 
 // make sure all static locals get constructed, so that they
 // can be used in destructors of global statics.
 std::string tmp1 = ServiceConstants::OBJECTCLASS();
 std::string tmp2 = ServiceConstants::SERVICE_ID();
 std::string tmp3 = ServiceConstants::SERVICE_RANKING();
 std::string tmp4 = ServiceConstants::SERVICE_SCOPE();
 std::string tmp5 = ServiceConstants::SCOPE_SINGLETON();
 std::string tmp6 = ServiceConstants::SCOPE_MODULE();
 std::string tmp7 = ServiceConstants::SCOPE_PROTOTYPE();
diff --git a/Modules/CppMicroServices/core/src/service/usServicePropertiesImpl.cpp b/Modules/CppMicroServices/core/src/service/usServicePropertiesImpl.cpp
index 05d9976192..bdc2380da5 100644
--- a/Modules/CppMicroServices/core/src/service/usServicePropertiesImpl.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServicePropertiesImpl.cpp
@@ -1,105 +1,105 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServicePropertiesImpl_p.h"
 
 #include <limits>
 #include <stdexcept>
 #ifdef US_PLATFORM_WINDOWS
 #include <string.h>
 #define ci_compare strnicmp
 #else
 #include <strings.h>
 #define ci_compare strncasecmp
 #endif
 
 US_BEGIN_NAMESPACE
 
 Any ServicePropertiesImpl::emptyAny;
 
 ServicePropertiesImpl::ServicePropertiesImpl(const ServiceProperties& p)
 {
   if (p.size() > static_cast<std::size_t>(std::numeric_limits<int>::max()))
   {
     throw std::runtime_error("ServiceProperties object contains too many keys");
   }
 
   keys.reserve(p.size());
   values.reserve(p.size());
 
   for (ServiceProperties::const_iterator iter = p.begin();
        iter != p.end(); ++iter)
   {
     if (Find(iter->first) > -1)
     {
       std::string msg = "ServiceProperties object contains case variants of the key: ";
       msg += iter->first;
       throw std::runtime_error(msg.c_str());
     }
     keys.push_back(iter->first);
     values.push_back(iter->second);
   }
 }
 
 const Any& ServicePropertiesImpl::Value(const std::string& key) const
 {
   int i = Find(key);
   if (i < 0) return emptyAny;
   return values[i];
 }
 
 const Any& ServicePropertiesImpl::Value(int index) const
 {
   if (index < 0 || static_cast<std::size_t>(index) >= values.size())
     return emptyAny;
   return values[static_cast<std::size_t>(index)];
 }
 
 int ServicePropertiesImpl::Find(const std::string& key) const
 {
   for (std::size_t i = 0; i < keys.size(); ++i)
   {
     if (ci_compare(key.c_str(), keys[i].c_str(), key.size()) == 0)
     {
       return static_cast<int>(i);
     }
   }
   return -1;
 }
 
 int ServicePropertiesImpl::FindCaseSensitive(const std::string& key) const
 {
   for (std::size_t i = 0; i < keys.size(); ++i)
   {
     if (key == keys[i])
     {
       return static_cast<int>(i);
     }
   }
   return -1;
 }
 
 const std::vector<std::string>& ServicePropertiesImpl::Keys() const
 {
   return keys;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServicePropertiesImpl_p.h b/Modules/CppMicroServices/core/src/service/usServicePropertiesImpl_p.h
index de4bf3de17..1f1ca8b90e 100644
--- a/Modules/CppMicroServices/core/src/service/usServicePropertiesImpl_p.h
+++ b/Modules/CppMicroServices/core/src/service/usServicePropertiesImpl_p.h
@@ -1,55 +1,55 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSERVICEPROPERTIESIMPL_P_H
 #define USSERVICEPROPERTIESIMPL_P_H
 
 #include "usServiceProperties.h"
 
 US_BEGIN_NAMESPACE
 
 class ServicePropertiesImpl
 {
 
 public:
 
   explicit ServicePropertiesImpl(const ServiceProperties& props);
 
   const Any& Value(const std::string& key) const;
   const Any& Value(int index) const;
 
   int Find(const std::string& key) const;
   int FindCaseSensitive(const std::string& key) const;
 
   const std::vector<std::string>& Keys() const;
 
 private:
 
   std::vector<std::string> keys;
   std::vector<Any> values;
 
   static Any emptyAny;
 
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICEPROPERTIESIMPL_P_H
diff --git a/Modules/CppMicroServices/core/src/service/usServiceReferenceBase.cpp b/Modules/CppMicroServices/core/src/service/usServiceReferenceBase.cpp
index 9c67052051..a36fff34ef 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceReferenceBase.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceReferenceBase.cpp
@@ -1,221 +1,221 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceReferenceBase.h"
 #include "usServiceReferenceBasePrivate.h"
 #include "usServiceRegistrationBasePrivate.h"
 
 #include "usModule.h"
 #include "usModulePrivate.h"
 
 #include <cassert>
 
 US_BEGIN_NAMESPACE
 
 ServiceReferenceBase::ServiceReferenceBase()
   : d(new ServiceReferenceBasePrivate(nullptr))
 {
 
 }
 
 ServiceReferenceBase::ServiceReferenceBase(const ServiceReferenceBase& ref)
   : d(ref.d)
 {
   d->ref.Ref();
 }
 
 ServiceReferenceBase::ServiceReferenceBase(ServiceRegistrationBasePrivate* reg)
   : d(new ServiceReferenceBasePrivate(reg))
 {
 }
 
 void ServiceReferenceBase::SetInterfaceId(const std::string& interfaceId)
 {
   if (d->ref > 1)
   {
     // detach
     d->ref.Deref();
     d = new ServiceReferenceBasePrivate(d->registration);
   }
   d->interfaceId = interfaceId;
 }
 
 ServiceReferenceBase::operator bool_type() const
 {
   return GetModule() != nullptr ? &ServiceReferenceBase::d : nullptr;
 }
 
 ServiceReferenceBase& ServiceReferenceBase::operator=(int null)
 {
   if (null == 0)
   {
     if (!d->ref.Deref())
       delete d;
     d = new ServiceReferenceBasePrivate(nullptr);
   }
   return *this;
 }
 
 ServiceReferenceBase::~ServiceReferenceBase()
 {
   if (!d->ref.Deref())
     delete d;
 }
 
 Any ServiceReferenceBase::GetProperty(const std::string& key) const
 {
   MutexLock lock(d->registration->propsLock);
 
   return d->registration->properties.Value(key);
 }
 
 void ServiceReferenceBase::GetPropertyKeys(std::vector<std::string>& keys) const
 {
   MutexLock lock(d->registration->propsLock);
 
   const std::vector<std::string>& ks = d->registration->properties.Keys();
   keys.assign(ks.begin(), ks.end());
 }
 
 Module* ServiceReferenceBase::GetModule() const
 {
   if (d->registration == nullptr || d->registration->module == nullptr)
   {
     return nullptr;
   }
 
   return d->registration->module->q;
 }
 
 void ServiceReferenceBase::GetUsingModules(std::vector<Module*>& modules) const
 {
   MutexLock lock(d->registration->propsLock);
 
   ServiceRegistrationBasePrivate::ModuleToRefsMap::const_iterator end = d->registration->dependents.end();
   for (ServiceRegistrationBasePrivate::ModuleToRefsMap::const_iterator iter = d->registration->dependents.begin();
        iter != end; ++iter)
   {
     modules.push_back(iter->first);
   }
 }
 
 bool ServiceReferenceBase::operator<(const ServiceReferenceBase& reference) const
 {
   if (!(*this))
   {
     return true;
   }
 
   if (!reference)
   {
     return false;
   }
 
   const Any anyR1 = GetProperty(ServiceConstants::SERVICE_RANKING());
   const Any anyR2 = reference.GetProperty(ServiceConstants::SERVICE_RANKING());
   assert(anyR1.Empty() || anyR1.Type() == typeid(int));
   assert(anyR2.Empty() || anyR2.Type() == typeid(int));
   const int r1 = anyR1.Empty() ? 0 : *any_cast<int>(&anyR1);
   const int r2 = anyR2.Empty() ? 0 : *any_cast<int>(&anyR2);
 
   if (r1 != r2)
   {
     // use ranking if ranking differs
     return r1 < r2;
   }
   else
   {
     const Any anyId1 = GetProperty(ServiceConstants::SERVICE_ID());
     const Any anyId2 = reference.GetProperty(ServiceConstants::SERVICE_ID());
     assert(anyId1.Type() == typeid(long int));
     assert(anyId2.Type() == typeid(long int));
     const long int id1 = *any_cast<long int>(&anyId1);
     const long int id2 = *any_cast<long int>(&anyId2);
 
     // otherwise compare using IDs,
     // is less than if it has a higher ID.
     return id2 < id1;
   }
 }
 
 bool ServiceReferenceBase::operator==(const ServiceReferenceBase& reference) const
 {
   return d->registration == reference.d->registration;
 }
 
 ServiceReferenceBase& ServiceReferenceBase::operator=(const ServiceReferenceBase& reference)
 {
   ServiceReferenceBasePrivate* curr_d = d;
   d = reference.d;
   d->ref.Ref();
 
   if (!curr_d->ref.Deref())
     delete curr_d;
 
   return *this;
 }
 
 bool ServiceReferenceBase::IsConvertibleTo(const std::string& interfaceId) const
 {
   return d->IsConvertibleTo(interfaceId);
 }
 
 std::string ServiceReferenceBase::GetInterfaceId() const
 {
   return d->interfaceId;
 }
 
 std::size_t ServiceReferenceBase::Hash() const
 {
   using namespace US_HASH_FUNCTION_NAMESPACE;
   return US_HASH_FUNCTION(ServiceRegistrationBasePrivate*, this->d->registration);
 }
 
 US_END_NAMESPACE
 
 US_USE_NAMESPACE
 
 std::ostream& operator<<(std::ostream& os, const ServiceReferenceBase& serviceRef)
 {
   if (serviceRef)
   {
     assert(serviceRef.GetModule() != nullptr);
 
     os << "Reference for service object registered from "
        << serviceRef.GetModule()->GetName() << " " << serviceRef.GetModule()->GetVersion()
        << " (";
     std::vector<std::string> keys;
     serviceRef.GetPropertyKeys(keys);
     size_t keySize = keys.size();
     for(size_t i = 0; i < keySize; ++i)
     {
       os << keys[i] << "=" << serviceRef.GetProperty(keys[i]).ToString();
       if (i < keySize-1) os << ",";
     }
     os << ")";
   }
   else
   {
     os << "Invalid service reference";
   }
 
   return os;
 }
diff --git a/Modules/CppMicroServices/core/src/service/usServiceReferenceBasePrivate.cpp b/Modules/CppMicroServices/core/src/service/usServiceReferenceBasePrivate.cpp
index 0a560ef5c7..be676e82e9 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceReferenceBasePrivate.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceReferenceBasePrivate.cpp
@@ -1,320 +1,320 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceReferenceBasePrivate.h"
 
 #include "usServiceFactory.h"
 #include "usServiceException.h"
 #include "usServiceRegistry_p.h"
 #include "usServiceRegistrationBasePrivate.h"
 
 #include "usModule.h"
 #include "usModulePrivate.h"
 
 #include <usCoreModuleContext_p.h>
 
 #include <cassert>
 
 #ifdef _MSC_VER
 #pragma warning(disable:4503) // decorated name length exceeded, name was truncated
 #endif
 
 US_BEGIN_NAMESPACE
 
 ServiceReferenceBasePrivate::ServiceReferenceBasePrivate(ServiceRegistrationBasePrivate* reg)
   : ref(1), registration(reg)
 {
   if(registration) registration->ref.Ref();
 }
 
 ServiceReferenceBasePrivate::~ServiceReferenceBasePrivate()
 {
   if (registration && !registration->ref.Deref())
     delete registration;
 }
 
 InterfaceMap ServiceReferenceBasePrivate::GetServiceFromFactory(Module* module,
                                                                 ServiceFactory* factory,
                                                                 bool isModuleScope)
 {
   assert(factory && "Factory service pointer is nullptr");
   InterfaceMap s;
   try
   {
     InterfaceMap smap = factory->GetService(module,
                                             ServiceRegistrationBase(registration));
     if (smap.empty())
     {
       US_WARN << "ServiceFactory produced null";
       return smap;
     }
     const std::vector<std::string>& classes =
         ref_any_cast<std::vector<std::string> >(registration->properties.Value(ServiceConstants::OBJECTCLASS()));
     for (std::vector<std::string>::const_iterator i = classes.begin();
          i != classes.end(); ++i)
     {
       if (smap.find(*i) == smap.end() && *i != "org.cppmicroservices.factory")
       {
         US_WARN << "ServiceFactory produced an object "
                    "that did not implement: " << (*i);
         smap.clear();
         return smap;
       }
     }
     s = smap;
 
     if (isModuleScope)
     {
       registration->moduleServiceInstance.insert(std::make_pair(module, smap));
     }
     else
     {
       registration->prototypeServiceInstances[module].push_back(smap);
     }
   }
   catch (...)
   {
     US_WARN << "ServiceFactory threw an exception";
     s.clear();
   }
   return s;
 }
 
 InterfaceMap ServiceReferenceBasePrivate::GetPrototypeService(Module* module)
 {
   InterfaceMap s;
   {
     MutexLock lock(registration->propsLock);
     if (registration->available)
     {
       ServiceFactory* factory = reinterpret_cast<ServiceFactory*>(
             registration->GetService("org.cppmicroservices.factory"));
       s = GetServiceFromFactory(module, factory, false);
     }
   }
   return s;
 }
 
 void* ServiceReferenceBasePrivate::GetService(Module* module)
 {
   void* s = nullptr;
   {
     MutexLock lock(registration->propsLock);
     if (registration->available)
     {
       ServiceFactory* serviceFactory = reinterpret_cast<ServiceFactory*>(
             registration->GetService("org.cppmicroservices.factory"));
 
       const int count = registration->dependents[module];
       if (count == 0)
       {
         if (serviceFactory)
         {
           const InterfaceMap im = GetServiceFromFactory(module, serviceFactory, true);
           s = im.find(interfaceId)->second;
         }
         else
         {
           s = registration->GetService(interfaceId);
         }
       }
       else
       {
         if (serviceFactory)
         {
           // return the already produced instance
           s = registration->moduleServiceInstance[module][interfaceId];
         }
         else
         {
           s = registration->GetService(interfaceId);
         }
       }
 
       if (s)
       {
         registration->dependents[module] = count + 1;
       }
     }
   }
   return s;
 }
 
 InterfaceMap ServiceReferenceBasePrivate::GetServiceInterfaceMap(Module* module)
 {
   InterfaceMap s;
   {
     MutexLock lock(registration->propsLock);
     if (registration->available)
     {
       ServiceFactory* serviceFactory = reinterpret_cast<ServiceFactory*>(
             registration->GetService("org.cppmicroservices.factory"));
 
       const int count = registration->dependents[module];
       if (count == 0)
       {
         if (serviceFactory)
         {
           s = GetServiceFromFactory(module, serviceFactory, true);
         }
         else
         {
           s = registration->service;
         }
       }
       else
       {
         if (serviceFactory)
         {
           // return the already produced instance
           s = registration->moduleServiceInstance[module];
         }
         else
         {
           s = registration->service;
         }
       }
 
       if (!s.empty())
       {
         registration->dependents[module] = count + 1;
       }
     }
   }
   return s;
 }
 
 bool ServiceReferenceBasePrivate::UngetPrototypeService(Module* module, const InterfaceMap& service)
 {
   MutexLock lock(registration->propsLock);
 
   ServiceRegistrationBasePrivate::ModuleToServicesMap::iterator iter =
       registration->prototypeServiceInstances.find(module);
   if (iter == registration->prototypeServiceInstances.end())
   {
     return false;
   }
 
   std::list<InterfaceMap>& prototypeServiceMaps = iter->second;
 
   for (std::list<InterfaceMap>::iterator imIter = prototypeServiceMaps.begin();
        imIter != prototypeServiceMaps.end(); ++imIter)
   {
     if (service == *imIter)
     {
       try
       {
         ServiceFactory* sf = reinterpret_cast<ServiceFactory*>(
                                registration->GetService("org.cppmicroservices.factory"));
         sf->UngetService(module, ServiceRegistrationBase(registration), service);
       }
       catch (const std::exception& /*e*/)
       {
         US_WARN << "ServiceFactory threw an exception";
       }
       prototypeServiceMaps.erase(imIter);
       if (prototypeServiceMaps.empty())
       {
         registration->prototypeServiceInstances.erase(iter);
       }
       return true;
     }
   }
 
   return false;
 }
 
 bool ServiceReferenceBasePrivate::UngetService(Module* module, bool checkRefCounter)
 {
   MutexLock lock(registration->propsLock);
   bool hadReferences = false;
   bool removeService = false;
 
   int count= registration->dependents[module];
   if (count > 0)
   {
     hadReferences = true;
   }
 
   if(checkRefCounter)
   {
     if (count > 1)
     {
       registration->dependents[module] = count - 1;
     }
     else if(count == 1)
     {
       removeService = true;
     }
   }
   else
   {
     removeService = true;
   }
 
   if (removeService)
   {
     InterfaceMap sfi = registration->moduleServiceInstance[module];
     registration->moduleServiceInstance.erase(module);
     if (!sfi.empty())
     {
       try
       {
         ServiceFactory* sf = reinterpret_cast<ServiceFactory*>(
                                registration->GetService("org.cppmicroservices.factory"));
         sf->UngetService(module, ServiceRegistrationBase(registration), sfi);
       }
       catch (const std::exception& /*e*/)
       {
         US_WARN << "ServiceFactory threw an exception";
       }
     }
     registration->dependents.erase(module);
   }
 
   return hadReferences && removeService;
 }
 
 const ServicePropertiesImpl& ServiceReferenceBasePrivate::GetProperties() const
 {
   return registration->properties;
 }
 
 Any ServiceReferenceBasePrivate::GetProperty(const std::string& key, bool lock) const
 {
   if (lock)
   {
     MutexLock lock(registration->propsLock);
     return registration->properties.Value(key);
   }
   else
   {
     return registration->properties.Value(key);
   }
 }
 
 bool ServiceReferenceBasePrivate::IsConvertibleTo(const std::string& interfaceId) const
 {
   return registration ? registration->service.find(interfaceId) != registration->service.end() : false;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceReferenceBasePrivate.h b/Modules/CppMicroServices/core/src/service/usServiceReferenceBasePrivate.h
index 77804c7b46..f3a0be1ca9 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceReferenceBasePrivate.h
+++ b/Modules/CppMicroServices/core/src/service/usServiceReferenceBasePrivate.h
@@ -1,152 +1,152 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICEREFERENCEBASEPRIVATE_H
 #define USSERVICEREFERENCEBASEPRIVATE_H
 
 #include "usAtomicInt_p.h"
 
 #include "usServiceInterface.h"
 
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 class Any;
 class Module;
 class ServicePropertiesImpl;
 class ServiceRegistrationBasePrivate;
 class ServiceReferenceBasePrivate;
 
 
 /**
  * \ingroup MicroServices
  */
 class ServiceReferenceBasePrivate
 {
 public:
 
   ServiceReferenceBasePrivate(ServiceRegistrationBasePrivate* reg);
 
   ~ServiceReferenceBasePrivate();
 
   /**
     * Get the service object.
     *
     * @param module requester of service.
     * @return Service requested or null in case of failure.
     */
   void* GetService(Module* module);
 
   InterfaceMap GetServiceInterfaceMap(Module* module);
 
   /**
     * Get new service instance.
     *
     * @param module requester of service.
     * @return Service requested or null in case of failure.
     */
   InterfaceMap GetPrototypeService(Module* module);
 
   /**
    * Unget the service object.
    *
    * @param module Module who wants remove service.
    * @param checkRefCounter If true decrement refence counter and remove service
    *                        if we reach zero. If false remove service without
    *                        checking refence counter.
    * @return True if service was removed or false if only reference counter was
    *         decremented.
    */
   bool UngetService(Module* module, bool checkRefCounter);
 
   /**
    * Unget prototype scope service objects.
    *
    * @param module Module who wants to remove a prototype scope service.
    * @param service The prototype scope service pointer.
    * @return \c true if the service was removed, \c false otherwise.
    */
   bool UngetPrototypeService(Module* module, void* service);
 
   bool UngetPrototypeService(Module* module, const InterfaceMap& service);
 
   /**
    * Get all properties registered with this service.
    *
    * @return A ServiceProperties object containing properties or being empty
    *         if service has been removed.
    */
   const ServicePropertiesImpl& GetProperties() const;
 
   /**
    * Returns the property value to which the specified property key is mapped
    * in the properties <code>ServiceProperties</code> object of the service
    * referenced by this <code>ServiceReference</code> object.
    *
    * <p>
    * Property keys are case-insensitive.
    *
    * <p>
    * This method must continue to return property values after the service has
    * been unregistered. This is so references to unregistered services can
    * still be interrogated.
    *
    * @param key The property key.
    * @param lock If <code>true</code>, access of the properties of the service
    * referenced by this <code>ServiceReference</code> object will be
    * synchronized.
    * @return The property value to which the key is mapped; an invalid Any
    * if there is no property named after the key.
    */
   Any GetProperty(const std::string& key, bool lock) const;
 
   bool IsConvertibleTo(const std::string& interfaceId) const;
 
   /**
    * Reference count for implicitly shared private implementation.
    */
   AtomicInt ref;
 
   /**
    * Link to registration object for this reference.
    */
   ServiceRegistrationBasePrivate* const registration;
 
   /**
    * The service interface id for this reference.
    */
   std::string interfaceId;
 
 private:
 
   InterfaceMap GetServiceFromFactory(Module* module, ServiceFactory* factory,
                                      bool isModuleScope);
 
   // purposely not implemented
   ServiceReferenceBasePrivate(const ServiceReferenceBasePrivate&);
   ServiceReferenceBasePrivate& operator=(const ServiceReferenceBasePrivate&);
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICEREFERENCEBASEPRIVATE_H
diff --git a/Modules/CppMicroServices/core/src/service/usServiceRegistrationBase.cpp b/Modules/CppMicroServices/core/src/service/usServiceRegistrationBase.cpp
index 033457ed0a..c4ff4f1f30 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceRegistrationBase.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceRegistrationBase.cpp
@@ -1,271 +1,271 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceRegistrationBase.h"
 #include "usServiceRegistrationBasePrivate.h"
 #include "usServiceListenerEntry_p.h"
 #include "usServiceRegistry_p.h"
 #include "usServiceFactory.h"
 
 #include "usModulePrivate.h"
 #include "usCoreModuleContext_p.h"
 
 #include <stdexcept>
 
 US_BEGIN_NAMESPACE
 
 ServiceRegistrationBase::ServiceRegistrationBase()
   : d(nullptr)
 {
 
 }
 
 ServiceRegistrationBase::ServiceRegistrationBase(const ServiceRegistrationBase& reg)
   : d(reg.d)
 {
   if (d) d->ref.Ref();
 }
 
 ServiceRegistrationBase::ServiceRegistrationBase(ServiceRegistrationBasePrivate* registrationPrivate)
   : d(registrationPrivate)
 {
   if (d) d->ref.Ref();
 }
 
 ServiceRegistrationBase::ServiceRegistrationBase(ModulePrivate* module, const InterfaceMap& service,
                                                  const ServicePropertiesImpl& props)
   : d(new ServiceRegistrationBasePrivate(module, service, props))
 {
 
 }
 
 ServiceRegistrationBase::operator bool_type() const
 {
   return d != nullptr ? &ServiceRegistrationBase::d : nullptr;
 }
 
 ServiceRegistrationBase& ServiceRegistrationBase::operator=(int null)
 {
   if (null == 0)
   {
     if (d && !d->ref.Deref())
     {
       delete d;
     }
     d = nullptr;
   }
   return *this;
 }
 
 ServiceRegistrationBase::~ServiceRegistrationBase()
 {
   if (d && !d->ref.Deref())
     delete d;
 }
 
 ServiceReferenceBase ServiceRegistrationBase::GetReference(const std::string& interfaceId) const
 {
   if (!d) throw std::logic_error("ServiceRegistrationBase object invalid");
   if (!d->available) throw std::logic_error("Service is unregistered");
 
   ServiceReferenceBase ref = d->reference;
   ref.SetInterfaceId(interfaceId);
   return ref;
 }
 
 void ServiceRegistrationBase::SetProperties(const ServiceProperties& props)
 {
   if (!d) throw std::logic_error("ServiceRegistrationBase object invalid");
 
   MutexLock lock(d->eventLock);
 
   ServiceEvent modifiedEndMatchEvent(ServiceEvent::MODIFIED_ENDMATCH, d->reference);
   ServiceListeners::ServiceListenerEntries before;
   // TBD, optimize the locking of services
   {
     //MutexLock lock2(d->module->coreCtx->globalFwLock);
 
     if (d->available)
     {
       // NYI! Optimize the MODIFIED_ENDMATCH code
       int old_rank = 0;
       int new_rank = 0;
 
       std::vector<std::string> classes;
       {
         MutexLock lock3(d->propsLock);
 
         {
           const Any& any = d->properties.Value(ServiceConstants::SERVICE_RANKING());
           if (any.Type() == typeid(int)) old_rank = any_cast<int>(any);
         }
 
         d->module->coreCtx->listeners.GetMatchingServiceListeners(modifiedEndMatchEvent, before, false);
         classes = ref_any_cast<std::vector<std::string> >(d->properties.Value(ServiceConstants::OBJECTCLASS()));
         long int sid = any_cast<long int>(d->properties.Value(ServiceConstants::SERVICE_ID()));
         d->properties = ServiceRegistry::CreateServiceProperties(props, classes, false, false, sid);
 
         {
           const Any& any = d->properties.Value(ServiceConstants::SERVICE_RANKING());
           if (any.Type() == typeid(int)) new_rank = any_cast<int>(any);
         }
       }
 
       if (old_rank != new_rank)
       {
         d->module->coreCtx->services.UpdateServiceRegistrationOrder(*this, classes);
       }
     }
     else
     {
       throw std::logic_error("Service is unregistered");
     }
   }
   ServiceEvent modifiedEvent(ServiceEvent::MODIFIED, d->reference);
   ServiceListeners::ServiceListenerEntries matchingListeners;
   d->module->coreCtx->listeners.GetMatchingServiceListeners(modifiedEvent, matchingListeners);
   d->module->coreCtx->listeners.ServiceChanged(matchingListeners,
                                                modifiedEvent,
                                                before);
 
   d->module->coreCtx->listeners.ServiceChanged(before,
                                                modifiedEndMatchEvent);
 }
 
 void ServiceRegistrationBase::Unregister()
 {
   if (!d) throw std::logic_error("ServiceRegistrationBase object invalid");
 
   if (d->unregistering) return; // Silently ignore redundant unregistration.
   {
     MutexLock lock(d->eventLock);
     if (d->unregistering) return;
     d->unregistering = true;
 
     if (d->available)
     {
       if (d->module)
       {
         d->module->coreCtx->services.RemoveServiceRegistration(*this);
       }
     }
     else
     {
       throw std::logic_error("Service is unregistered");
     }
   }
 
   if (d->module)
   {
     ServiceListeners::ServiceListenerEntries listeners;
     ServiceEvent unregisteringEvent(ServiceEvent::UNREGISTERING, d->reference);
     d->module->coreCtx->listeners.GetMatchingServiceListeners(unregisteringEvent, listeners);
     d->module->coreCtx->listeners.ServiceChanged(
           listeners,
           unregisteringEvent);
   }
 
   {
     MutexLock lock(d->eventLock);
     {
       MutexLock lock2(d->propsLock);
       d->available = false;
       InterfaceMap::const_iterator factoryIter = d->service.find("org.cppmicroservices.factory");
       if (d->module && factoryIter != d->service.end())
       {
         ServiceFactory* serviceFactory = reinterpret_cast<ServiceFactory*>(factoryIter->second);
         ServiceRegistrationBasePrivate::ModuleToServicesMap::const_iterator end = d->prototypeServiceInstances.end();
 
         // unget all prototype services
         for (ServiceRegistrationBasePrivate::ModuleToServicesMap::const_iterator i = d->prototypeServiceInstances.begin();
              i != end; ++i)
         {
           for (std::list<InterfaceMap>::const_iterator listIter = i->second.begin();
                listIter != i->second.end(); ++listIter)
           {
             const InterfaceMap& service = *listIter;
             try
             {
               // NYI, don't call inside lock
               serviceFactory->UngetService(i->first, *this, service);
             }
             catch (const std::exception& /*ue*/)
             {
               US_WARN << "ServiceFactory UngetService implementation threw an exception";
             }
           }
         }
 
         // unget module scope services
         ServiceRegistrationBasePrivate::ModuleToServiceMap::const_iterator moduleEnd = d->moduleServiceInstance.end();
         for (ServiceRegistrationBasePrivate::ModuleToServiceMap::const_iterator i = d->moduleServiceInstance.begin();
              i != moduleEnd; ++i)
         {
           try
           {
             // NYI, don't call inside lock
             serviceFactory->UngetService(i->first, *this, i->second);
           }
           catch (const std::exception& /*ue*/)
           {
             US_WARN << "ServiceFactory UngetService implementation threw an exception";
           }
         }
       }
       d->module = nullptr;
       d->dependents.clear();
       d->service.clear();
       d->prototypeServiceInstances.clear();
       d->moduleServiceInstance.clear();
       // increment the reference count, since "d->reference" was used originally
       // to keep d alive.
       d->ref.Ref();
       d->reference = 0;
       d->unregistering = false;
     }
   }
 }
 
 bool ServiceRegistrationBase::operator<(const ServiceRegistrationBase& o) const
 {
   if ((!d && !o.d) || !o.d) return false;
   if (!d) return true;
   return d->reference <(o.d->reference);
 }
 
 bool ServiceRegistrationBase::operator==(const ServiceRegistrationBase& registration) const
 {
   return d == registration.d;
 }
 
 ServiceRegistrationBase& ServiceRegistrationBase::operator=(const ServiceRegistrationBase& registration)
 {
   ServiceRegistrationBasePrivate* curr_d = d;
   d = registration.d;
   if (d) d->ref.Ref();
 
   if (curr_d && !curr_d->ref.Deref())
     delete curr_d;
 
   return *this;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceRegistrationBasePrivate.cpp b/Modules/CppMicroServices/core/src/service/usServiceRegistrationBasePrivate.cpp
index 8e89eb9ede..0e300c0552 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceRegistrationBasePrivate.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceRegistrationBasePrivate.cpp
@@ -1,76 +1,76 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceRegistrationBasePrivate.h"
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable:4355)
 #endif
 
 US_BEGIN_NAMESPACE
 
 ServiceRegistrationBasePrivate::ServiceRegistrationBasePrivate(
   ModulePrivate* module, const InterfaceMap& service,
   const ServicePropertiesImpl& props)
   : ref(0), service(service), module(module), reference(this),
     properties(props), available(true), unregistering(false)
 {
   // The reference counter is initialized to 0 because it will be
   // incremented by the "reference" member.
 }
 
 ServiceRegistrationBasePrivate::~ServiceRegistrationBasePrivate()
 {
 
 }
 
 bool ServiceRegistrationBasePrivate::IsUsedByModule(Module* p) const
 {
   return (dependents.find(p) != dependents.end()) ||
       (prototypeServiceInstances.find(p) != prototypeServiceInstances.end());
 }
 
 const InterfaceMap& ServiceRegistrationBasePrivate::GetInterfaces() const
 {
   return service;
 }
 
 void* ServiceRegistrationBasePrivate::GetService(const std::string& interfaceId) const
 {
   if (interfaceId.empty() && service.size() > 0)
   {
     return service.begin()->second;
   }
 
   InterfaceMap::const_iterator iter = service.find(interfaceId);
   if (iter != service.end())
   {
     return iter->second;
   }
   return nullptr;
 }
 
 US_END_NAMESPACE
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
diff --git a/Modules/CppMicroServices/core/src/service/usServiceRegistrationBasePrivate.h b/Modules/CppMicroServices/core/src/service/usServiceRegistrationBasePrivate.h
index 5ac69b9545..c683900d49 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceRegistrationBasePrivate.h
+++ b/Modules/CppMicroServices/core/src/service/usServiceRegistrationBasePrivate.h
@@ -1,149 +1,149 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICEREGISTRATIONBASEPRIVATE_H
 #define USSERVICEREGISTRATIONBASEPRIVATE_H
 
 #include "usServiceInterface.h"
 #include "usServiceReference.h"
 #include "usServicePropertiesImpl_p.h"
 #include "usAtomicInt_p.h"
 
 US_BEGIN_NAMESPACE
 
 class ModulePrivate;
 class ServiceRegistrationBase;
 
 /**
  * \ingroup MicroServices
  */
 class ServiceRegistrationBasePrivate
 {
 
 protected:
 
   friend class ServiceRegistrationBase;
 
   // The ServiceReferenceBasePrivate class holds a pointer to a
   // ServiceRegistrationBasePrivate instance and needs to manipulate
   // its reference count. This way it can keep the ServiceRegistrationBasePrivate
   // instance alive and keep returning service properties for
   // unregistered service instances.
   friend class ServiceReferenceBasePrivate;
 
   /**
    * Reference count for implicitly shared private implementation.
    */
   AtomicInt ref;
 
   /**
    * Service or ServiceFactory object.
    */
   InterfaceMap service;
 
 public:
 
   typedef US_UNORDERED_MAP_TYPE<Module*,int> ModuleToRefsMap;
   typedef US_UNORDERED_MAP_TYPE<Module*, InterfaceMap> ModuleToServiceMap;
   typedef US_UNORDERED_MAP_TYPE<Module*, std::list<InterfaceMap> > ModuleToServicesMap;
 
   /**
    * Modules dependent on this service. Integer is used as
    * reference counter, counting number of unbalanced getService().
    */
   ModuleToRefsMap dependents;
 
   /**
    * Object instances that a prototype factory has produced.
    */
   ModuleToServicesMap prototypeServiceInstances;
 
   /**
    * Object instance with module scope that a factory may have produced.
    */
   ModuleToServiceMap moduleServiceInstance;
 
   /**
    * Module registering this service.
    */
   ModulePrivate* module;
 
   /**
    * Reference object to this service registration.
    */
   ServiceReferenceBase reference;
 
   /**
    * Service properties.
    */
   ServicePropertiesImpl properties;
 
   /**
    * Is service available. I.e., if <code>true</code> then holders
    * of a ServiceReference for the service are allowed to get it.
    */
   volatile bool available;
 
   /**
    * Avoid recursive unregistrations. I.e., if <code>true</code> then
    * unregistration of this service has started but is not yet
    * finished.
    */
   volatile bool unregistering;
 
   /**
    * Lock object for synchronous event delivery.
    */
   Mutex eventLock;
 
   // needs to be recursive
   Mutex propsLock;
 
   ServiceRegistrationBasePrivate(ModulePrivate* module, const InterfaceMap& service,
                                  const ServicePropertiesImpl& props);
 
   ~ServiceRegistrationBasePrivate();
 
   /**
    * Check if a module uses this service
    *
    * @param p Module to check
    * @return true if module uses this service
    */
   bool IsUsedByModule(Module* m) const;
 
   const InterfaceMap& GetInterfaces() const;
 
   void* GetService(const std::string& interfaceId) const;
 
 private:
 
   // purposely not implemented
   ServiceRegistrationBasePrivate(const ServiceRegistrationBasePrivate&);
   ServiceRegistrationBasePrivate& operator=(const ServiceRegistrationBasePrivate&);
 
 };
 
 US_END_NAMESPACE
 
 
 #endif // USSERVICEREGISTRATIONBASEPRIVATE_H
diff --git a/Modules/CppMicroServices/core/src/service/usServiceRegistry.cpp b/Modules/CppMicroServices/core/src/service/usServiceRegistry.cpp
index 023e7e574d..2131432c47 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceRegistry.cpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceRegistry.cpp
@@ -1,338 +1,338 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <iterator>
 #include <stdexcept>
 #include <cassert>
 
 #include "usServiceRegistry_p.h"
 #include "usServiceFactory.h"
 #include "usPrototypeServiceFactory.h"
 #include "usServiceRegistry_p.h"
 #include "usServiceRegistrationBasePrivate.h"
 #include "usModulePrivate.h"
 #include "usCoreModuleContext_p.h"
 
 
 US_BEGIN_NAMESPACE
 
 ServicePropertiesImpl ServiceRegistry::CreateServiceProperties(const ServiceProperties& in,
                                                                const std::vector<std::string>& classes,
                                                                bool isFactory, bool isPrototypeFactory,
                                                                long sid)
 {
   static long nextServiceID = 1;
   ServiceProperties props(in);
 
   if (!classes.empty())
   {
     props.insert(std::make_pair(ServiceConstants::OBJECTCLASS(), classes));
   }
 
   props.insert(std::make_pair(ServiceConstants::SERVICE_ID(), sid != -1 ? sid : nextServiceID++));
 
   if (isPrototypeFactory)
   {
     props.insert(std::make_pair(ServiceConstants::SERVICE_SCOPE(), ServiceConstants::SCOPE_PROTOTYPE()));
   }
   else if (isFactory)
   {
     props.insert(std::make_pair(ServiceConstants::SERVICE_SCOPE(), ServiceConstants::SCOPE_MODULE()));
   }
   else
   {
     props.insert(std::make_pair(ServiceConstants::SERVICE_SCOPE(), ServiceConstants::SCOPE_SINGLETON()));
   }
 
   return ServicePropertiesImpl(props);
 }
 
 ServiceRegistry::ServiceRegistry(CoreModuleContext* coreCtx)
   : core(coreCtx)
 {
 
 }
 
 ServiceRegistry::~ServiceRegistry()
 {
   Clear();
 }
 
 void ServiceRegistry::Clear()
 {
   services.clear();
   serviceRegistrations.clear();
   classServices.clear();
   core = nullptr;
 }
 
 ServiceRegistrationBase ServiceRegistry::RegisterService(ModulePrivate* module,
                                                      const InterfaceMap& service,
                                                      const ServiceProperties& properties)
 {
   if (service.empty())
   {
     throw std::invalid_argument("Can't register empty InterfaceMap as a service");
   }
 
   // Check if we got a service factory
   bool isFactory = service.count("org.cppmicroservices.factory") > 0;
   bool isPrototypeFactory = (isFactory ? dynamic_cast<PrototypeServiceFactory*>(reinterpret_cast<ServiceFactory*>(service.find("org.cppmicroservices.factory")->second)) != nullptr : false);
 
   std::vector<std::string> classes;
   // Check if service implements claimed classes and that they exist.
   for (InterfaceMap::const_iterator i = service.begin();
        i != service.end(); ++i)
   {
     if (i->first.empty() || (!isFactory && i->second == nullptr))
     {
       throw std::invalid_argument("Can't register as null class");
     }
     classes.push_back(i->first);
   }
 
   ServiceRegistrationBase res(module, service,
                               CreateServiceProperties(properties, classes, isFactory, isPrototypeFactory));
   {
     MutexLock lock(mutex);
     services.insert(std::make_pair(res, classes));
     serviceRegistrations.push_back(res);
     for (std::vector<std::string>::const_iterator i = classes.begin();
          i != classes.end(); ++i)
     {
       std::vector<ServiceRegistrationBase>& s = classServices[*i];
       std::vector<ServiceRegistrationBase>::iterator ip =
           std::lower_bound(s.begin(), s.end(), res);
       s.insert(ip, res);
     }
   }
 
   ServiceReferenceBase r = res.GetReference(std::string());
   ServiceListeners::ServiceListenerEntries listeners;
   ServiceEvent registeredEvent(ServiceEvent::REGISTERED, r);
   module->coreCtx->listeners.GetMatchingServiceListeners(registeredEvent, listeners);
   module->coreCtx->listeners.ServiceChanged(listeners,
                                             registeredEvent);
   return res;
 }
 
 void ServiceRegistry::UpdateServiceRegistrationOrder(const ServiceRegistrationBase& sr,
                                                      const std::vector<std::string>& classes)
 {
   MutexLock lock(mutex);
   for (std::vector<std::string>::const_iterator i = classes.begin();
        i != classes.end(); ++i)
   {
     std::vector<ServiceRegistrationBase>& s = classServices[*i];
     s.erase(std::remove(s.begin(), s.end(), sr), s.end());
     s.insert(std::lower_bound(s.begin(), s.end(), sr), sr);
   }
 }
 
 void ServiceRegistry::Get(const std::string& clazz,
                           std::vector<ServiceRegistrationBase>& serviceRegs) const
 {
   MutexLock lock(mutex);
   Get_unlocked(clazz, serviceRegs);
 }
 
 void ServiceRegistry::Get_unlocked(const std::string& clazz,
                                    std::vector<ServiceRegistrationBase>& serviceRegs) const
 {
   MapClassServices::const_iterator i = classServices.find(clazz);
   if (i != classServices.end())
   {
     serviceRegs = i->second;
   }
 }
 
 ServiceReferenceBase ServiceRegistry::Get(ModulePrivate* module, const std::string& clazz) const
 {
   MutexLock lock(mutex);
   try
   {
     std::vector<ServiceReferenceBase> srs;
     Get_unlocked(clazz, "", module, srs);
     US_DEBUG << "get service ref " << clazz << " for module "
              << module->info.name << " = " << srs.size() << " refs";
 
     if (!srs.empty())
     {
       return srs.back();
     }
   }
   catch (const std::invalid_argument& )
   { }
 
   return ServiceReferenceBase();
 }
 
 void ServiceRegistry::Get(const std::string& clazz, const std::string& filter,
                           ModulePrivate* module, std::vector<ServiceReferenceBase>& res) const
 {
   MutexLock lock(mutex);
   Get_unlocked(clazz, filter, module, res);
 }
 
 void ServiceRegistry::Get_unlocked(const std::string& clazz, const std::string& filter,
                           ModulePrivate* module, std::vector<ServiceReferenceBase>& res) const
 {
   std::vector<ServiceRegistrationBase>::const_iterator s;
   std::vector<ServiceRegistrationBase>::const_iterator send;
   std::vector<ServiceRegistrationBase> v;
   LDAPExpr ldap;
   if (clazz.empty())
   {
     if (!filter.empty())
     {
       ldap = LDAPExpr(filter);
       LDAPExpr::ObjectClassSet matched;
       if (ldap.GetMatchedObjectClasses(matched))
       {
         v.clear();
         for(LDAPExpr::ObjectClassSet::const_iterator className = matched.begin();
             className != matched.end(); ++className)
         {
           MapClassServices::const_iterator i = classServices.find(*className);
           if (i != classServices.end())
           {
             std::copy(i->second.begin(), i->second.end(), std::back_inserter(v));
           }
         }
         if (!v.empty())
         {
           s = v.begin();
           send = v.end();
         }
         else
         {
           return;
         }
       }
       else
       {
         s = serviceRegistrations.begin();
         send = serviceRegistrations.end();
       }
     }
     else
     {
       s = serviceRegistrations.begin();
       send = serviceRegistrations.end();
     }
   }
   else
   {
     MapClassServices::const_iterator it = classServices.find(clazz);
     if (it != classServices.end())
     {
       s = it->second.begin();
       send = it->second.end();
     }
     else
     {
       return;
     }
     if (!filter.empty())
     {
       ldap = LDAPExpr(filter);
     }
   }
 
   for (; s != send; ++s)
   {
     ServiceReferenceBase sri = s->GetReference(clazz);
 
     if (filter.empty() || ldap.Evaluate(s->d->properties, false))
     {
       res.push_back(sri);
     }
   }
 
   if (!res.empty())
   {
     if (module != nullptr)
     {
       core->serviceHooks.FilterServiceReferences(module->moduleContext, clazz, filter, res);
     }
     else
     {
       core->serviceHooks.FilterServiceReferences(nullptr, clazz, filter, res);
     }
   }
 }
 
 void ServiceRegistry::RemoveServiceRegistration(const ServiceRegistrationBase& sr)
 {
   MutexLock lock(mutex);
 
   assert(sr.d->properties.Value(ServiceConstants::OBJECTCLASS()).Type() == typeid(std::vector<std::string>));
   const std::vector<std::string>& classes = ref_any_cast<std::vector<std::string> >(
         sr.d->properties.Value(ServiceConstants::OBJECTCLASS()));
   services.erase(sr);
   serviceRegistrations.erase(std::remove(serviceRegistrations.begin(), serviceRegistrations.end(), sr),
                              serviceRegistrations.end());
   for (std::vector<std::string>::const_iterator i = classes.begin();
        i != classes.end(); ++i)
   {
     std::vector<ServiceRegistrationBase>& s = classServices[*i];
     if (s.size() > 1)
     {
       s.erase(std::remove(s.begin(), s.end(), sr), s.end());
     }
     else
     {
       classServices.erase(*i);
     }
   }
 }
 
 void ServiceRegistry::GetRegisteredByModule(ModulePrivate* p,
                                             std::vector<ServiceRegistrationBase>& res) const
 {
   MutexLock lock(mutex);
 
   for (std::vector<ServiceRegistrationBase>::const_iterator i = serviceRegistrations.begin();
        i != serviceRegistrations.end(); ++i)
   {
     if (i->d->module == p)
     {
       res.push_back(*i);
     }
   }
 }
 
 void ServiceRegistry::GetUsedByModule(Module* p,
                                       std::vector<ServiceRegistrationBase>& res) const
 {
   MutexLock lock(mutex);
 
   for (std::vector<ServiceRegistrationBase>::const_iterator i = serviceRegistrations.begin();
        i != serviceRegistrations.end(); ++i)
   {
     if (i->d->IsUsedByModule(p))
     {
       res.push_back(*i);
     }
   }
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceRegistry_p.h b/Modules/CppMicroServices/core/src/service/usServiceRegistry_p.h
index e91aaabf9a..7f0d74e277 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceRegistry_p.h
+++ b/Modules/CppMicroServices/core/src/service/usServiceRegistry_p.h
@@ -1,189 +1,189 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICEREGISTRY_H
 #define USSERVICEREGISTRY_H
 
 #include "usServiceInterface.h"
 #include "usServiceRegistration.h"
 
 #include "usThreads_p.h"
 
 US_BEGIN_NAMESPACE
 
 class CoreModuleContext;
 class ModulePrivate;
 class ServicePropertiesImpl;
 
 
 /**
  * Here we handle all the CppMicroServices services that are registered.
  */
 class ServiceRegistry
 {
 
 public:
 
   typedef Mutex MutexType;
 
   mutable MutexType mutex;
 
   /**
    * Creates a new ServiceProperties object containing <code>in</code>
    * with the keys converted to lower case.
    *
    * @param classes A list of class names which will be added to the
    *        created ServiceProperties object under the key
    *        ModuleConstants::OBJECTCLASS.
    * @param sid A service id which will be used instead of a default one.
    */
   static ServicePropertiesImpl CreateServiceProperties(const ServiceProperties& in,
                                                        const std::vector<std::string>& classes = std::vector<std::string>(),
                                                        bool isFactory = false, bool isPrototypeFactory = false, long sid = -1);
 
   typedef US_UNORDERED_MAP_TYPE<ServiceRegistrationBase, std::vector<std::string> > MapServiceClasses;
   typedef US_UNORDERED_MAP_TYPE<std::string, std::vector<ServiceRegistrationBase> > MapClassServices;
 
   /**
    * All registered services in the current framework.
    * Mapping of registered service to class names under which
    * the service is registerd.
    */
   MapServiceClasses services;
 
   std::vector<ServiceRegistrationBase> serviceRegistrations;
 
   /**
    * Mapping of classname to registered service.
    * The List of registered services are ordered with the highest
    * ranked service first.
    */
   MapClassServices classServices;
 
   CoreModuleContext* core;
 
   ServiceRegistry(CoreModuleContext* coreCtx);
 
   ~ServiceRegistry();
 
   void Clear();
 
   /**
    * Register a service in the framework wide register.
    *
    * @param module The module registering the service.
    * @param classes The class names under which the service can be located.
    * @param service The service object.
    * @param properties The properties for this service.
    * @return A ServiceRegistration object.
    * @exception std::invalid_argument If one of the following is true:
    * <ul>
    * <li>The service object is 0.</li>
    * <li>The service parameter is not a ServiceFactory or an
    * instance of all the named classes in the classes parameter.</li>
    * </ul>
    */
   ServiceRegistrationBase RegisterService(ModulePrivate* module,
                                           const InterfaceMap& service,
                                           const ServiceProperties& properties);
 
   /**
    * Service ranking changed, reorder registered services
    * according to ranking.
    *
    * @param serviceRegistration The ServiceRegistrationPrivate object.
    * @param rank New rank of object.
    */
   void UpdateServiceRegistrationOrder(const ServiceRegistrationBase& sr,
                                       const std::vector<std::string>& classes);
 
   /**
    * Get all services implementing a certain class.
    * Only used internally by the framework.
    *
    * @param clazz The class name of the requested service.
    * @return A sorted list of {@link ServiceRegistrationPrivate} objects.
    */
   void Get(const std::string& clazz, std::vector<ServiceRegistrationBase>& serviceRegs) const;
 
   /**
    * Get a service implementing a certain class.
    *
    * @param module The module requesting reference
    * @param clazz The class name of the requested service.
    * @return A {@link ServiceReference} object.
    */
   ServiceReferenceBase Get(ModulePrivate* module, const std::string& clazz) const;
 
   /**
    * Get all services implementing a certain class and then
    * filter these with a property filter.
    *
    * @param clazz The class name of requested service.
    * @param filter The property filter.
    * @param module The module requesting reference.
    * @return A list of {@link ServiceReference} object.
    */
   void Get(const std::string& clazz, const std::string& filter,
            ModulePrivate* module, std::vector<ServiceReferenceBase>& serviceRefs) const;
 
   /**
    * Remove a registered service.
    *
    * @param sr The ServiceRegistration object that is registered.
    */
   void RemoveServiceRegistration(const ServiceRegistrationBase& sr) ;
 
   /**
    * Get all services that a module has registered.
    *
    * @param p The module
    * @return A set of {@link ServiceRegistration} objects
    */
   void GetRegisteredByModule(ModulePrivate* m, std::vector<ServiceRegistrationBase>& serviceRegs) const;
 
   /**
    * Get all services that a module uses.
    *
    * @param p The module
    * @return A set of {@link ServiceRegistration} objects
    */
   void GetUsedByModule(Module* m, std::vector<ServiceRegistrationBase>& serviceRegs) const;
 
 private:
 
   friend class ServiceHooks;
 
   void Get_unlocked(const std::string& clazz, std::vector<ServiceRegistrationBase>& serviceRegs) const;
 
   void Get_unlocked(const std::string& clazz, const std::string& filter,
                     ModulePrivate* module, std::vector<ServiceReferenceBase>& serviceRefs) const;
 
   // purposely not implemented
   ServiceRegistry(const ServiceRegistry&);
   ServiceRegistry& operator=(const ServiceRegistry&);
 
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICEREGISTRY_H
diff --git a/Modules/CppMicroServices/core/src/service/usServiceTracker.tpp b/Modules/CppMicroServices/core/src/service/usServiceTracker.tpp
index 04f12e7454..6db7508887 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceTracker.tpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceTracker.tpp
@@ -1,464 +1,464 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usServiceTrackerPrivate.h"
 #include "usTrackedService_p.h"
 #include "usServiceException.h"
 #include "usModuleContext.h"
 
 #include <string>
 #include <stdexcept>
 #include <limits>
 
 US_BEGIN_NAMESPACE
 
 template<class S, class TTT>
 ServiceTracker<S,TTT>::~ServiceTracker()
 {
   Close();
   delete d;
 }
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable:4355)
 #endif
 
 template<class S, class TTT>
 ServiceTracker<S,TTT>::ServiceTracker(ModuleContext* context,
                                       const ServiceReferenceType& reference,
                                       _ServiceTrackerCustomizer* customizer)
   : d(new _ServiceTrackerPrivate(this, context, reference, customizer))
 {
 }
 
 template<class S, class TTT>
 ServiceTracker<S,TTT>::ServiceTracker(ModuleContext* context, const std::string& clazz,
                                       _ServiceTrackerCustomizer* customizer)
   : d(new _ServiceTrackerPrivate(this, context, clazz, customizer))
 {
 }
 
 template<class S, class TTT>
 ServiceTracker<S,TTT>::ServiceTracker(ModuleContext* context, const LDAPFilter& filter,
                                       _ServiceTrackerCustomizer* customizer)
   : d(new _ServiceTrackerPrivate(this, context, filter, customizer))
 {
 }
 
 template<class S, class TTT>
 ServiceTracker<S,TTT>::ServiceTracker(ModuleContext *context, _ServiceTrackerCustomizer* customizer)
   : d(new _ServiceTrackerPrivate(this, context, us_service_interface_iid<S>(), customizer))
 {
   std::string clazz = us_service_interface_iid<S>();
   if (clazz.empty()) throw ServiceException("The service interface class has no US_DECLARE_SERVICE_INTERFACE macro");
 }
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
 template<class S, class TTT>
 void ServiceTracker<S,TTT>::Open()
 {
   _TrackedService* t;
   {
     US_UNUSED(typename _ServiceTrackerPrivate::Lock(d));
     if (d->trackedService)
     {
       return;
     }
 
     US_DEBUG(d->DEBUG_OUTPUT) << "ServiceTracker<S,TTT>::Open: " << d->filter;
 
     t = new _TrackedService(this, d->customizer);
     {
       US_UNUSED(typename _TrackedService::Lock(*t));
       try {
         d->context->AddServiceListener(t, &_TrackedService::ServiceChanged, d->listenerFilter);
         std::vector<ServiceReferenceType> references;
         if (!d->trackClass.empty())
         {
           references = d->GetInitialReferences(d->trackClass, std::string());
         }
         else
         {
           if (d->trackReference.GetModule() != nullptr)
           {
             references.push_back(d->trackReference);
           }
           else
           { /* user supplied filter */
             references = d->GetInitialReferences(std::string(),
                                                  (d->listenerFilter.empty()) ? d->filter.ToString() : d->listenerFilter);
           }
         }
         /* set tracked with the initial references */
         t->SetInitial(references);
       }
       catch (const std::invalid_argument& e)
       {
         throw std::runtime_error(std::string("unexpected std::invalid_argument exception: ")
             + e.what());
       }
     }
     d->trackedService = t;
   }
   /* Call tracked outside of synchronized region */
   t->TrackInitial(); /* process the initial references */
 }
 
 template<class S, class TTT>
 void ServiceTracker<S,TTT>::Close()
 {
   _TrackedService* outgoing;
   std::vector<ServiceReferenceType> references;
   {
     US_UNUSED(typename _ServiceTrackerPrivate::Lock(d));
     outgoing = d->trackedService;
     if (outgoing == nullptr)
     {
       return;
     }
     US_DEBUG(d->DEBUG_OUTPUT) << "ServiceTracker<S,TTT>::close:" << d->filter;
     outgoing->Close();
     references = GetServiceReferences();
     d->trackedService = nullptr;
     try
     {
       d->context->RemoveServiceListener(outgoing, &_TrackedService::ServiceChanged);
     }
     catch (const std::logic_error& /*e*/)
     {
       /* In case the context was stopped. */
     }
   }
   d->Modified(); /* clear the cache */
   {
     US_UNUSED(typename _TrackedService::Lock(outgoing));
     outgoing->NotifyAll(); /* wake up any waiters */
   }
   for(typename std::vector<ServiceReferenceType>::const_iterator ref = references.begin();
       ref != references.end(); ++ref)
   {
     outgoing->Untrack(*ref, ServiceEvent());
   }
 
   if (d->DEBUG_OUTPUT)
   {
     US_UNUSED(typename _ServiceTrackerPrivate::Lock(d));
     if ((d->cachedReference.GetModule() == nullptr) && !TTT::IsValid(d->cachedService))
     {
       US_DEBUG(true) << "ServiceTracker<S,TTT>::close[cached cleared]:"
                        << d->filter;
     }
   }
 
   delete outgoing;
   d->trackedService = nullptr;
 }
 
 template<class S, class TTT>
 typename ServiceTracker<S,TTT>::T
 ServiceTracker<S,TTT>::WaitForService(unsigned long timeoutMillis)
 {
   T object = GetService();
   while (!TTT::IsValid(object))
   {
     _TrackedService* t = d->Tracked();
     if (t == nullptr)
     { /* if ServiceTracker is not open */
       return TTT::DefaultValue();
     }
     {
       US_UNUSED(typename _TrackedService::Lock(t));
       if (t->Size() == 0)
       {
         t->Wait(timeoutMillis);
       }
     }
     object = GetService();
   }
   return object;
 }
 
 template<class S, class TTT>
 std::vector<typename ServiceTracker<S,TTT>::ServiceReferenceType>
 ServiceTracker<S,TTT>::GetServiceReferences() const
 {
   std::vector<ServiceReferenceType> refs;
   _TrackedService* t = d->Tracked();
   if (t == nullptr)
   { /* if ServiceTracker is not open */
     return refs;
   }
   {
     US_UNUSED(typename _TrackedService::Lock(t));
     d->GetServiceReferences_unlocked(refs, t);
   }
   return refs;
 }
 
 template<class S, class TTT>
 typename ServiceTracker<S,TTT>::ServiceReferenceType
 ServiceTracker<S,TTT>::GetServiceReference() const
 {
   ServiceReferenceType reference;
   {
     US_UNUSED(typename _ServiceTrackerPrivate::Lock(d));
     reference = d->cachedReference;
   }
   if (reference.GetModule() != nullptr)
   {
     US_DEBUG(d->DEBUG_OUTPUT) << "ServiceTracker<S,TTT>::getServiceReference[cached]:"
                          << d->filter;
     return reference;
   }
   US_DEBUG(d->DEBUG_OUTPUT) << "ServiceTracker<S,TTT>::getServiceReference:" << d->filter;
   std::vector<ServiceReferenceType> references = GetServiceReferences();
   std::size_t length = references.size();
   if (length == 0)
   { /* if no service is being tracked */
     throw ServiceException("No service is being tracked");
   }
   typename std::vector<ServiceReferenceType>::const_iterator selectedRef = references.begin();
   if (length > 1)
   { /* if more than one service, select highest ranking */
     std::vector<int> rankings(length);
     int count = 0;
     int maxRanking = std::numeric_limits<int>::min();
     typename std::vector<ServiceReferenceType>::const_iterator refIter = references.begin();
     for (std::size_t i = 0; i < length; i++)
     {
       Any rankingAny = refIter->GetProperty(ServiceConstants::SERVICE_RANKING());
       int ranking = 0;
       if (rankingAny.Type() == typeid(int))
       {
         ranking = any_cast<int>(rankingAny);
       }
 
       rankings[i] = ranking;
       if (ranking > maxRanking)
       {
         selectedRef = refIter;
         maxRanking = ranking;
         count = 1;
       }
       else
       {
         if (ranking == maxRanking)
         {
           count++;
         }
       }
       ++refIter;
     }
     if (count > 1)
     { /* if still more than one service, select lowest id */
       long int minId = std::numeric_limits<long int>::max();
       refIter = references.begin();
       for (std::size_t i = 0; i < length; i++)
       {
         if (rankings[i] == maxRanking)
         {
           Any idAny = refIter->GetProperty(ServiceConstants::SERVICE_ID());
           long int id = 0;
           if (idAny.Type() == typeid(long int))
           {
             id = any_cast<long int>(idAny);
           }
           if (id < minId)
           {
             selectedRef = refIter;
             minId = id;
           }
         }
         ++refIter;
       }
     }
   }
 
   {
     US_UNUSED(typename _ServiceTrackerPrivate::Lock(d));
     d->cachedReference = *selectedRef;
     return d->cachedReference;
   }
 }
 
 template<class S, class TTT>
 typename ServiceTracker<S,TTT>::T
 ServiceTracker<S,TTT>::GetService(const ServiceReferenceType& reference) const
 {
   _TrackedService* t = d->Tracked();
   if (t == nullptr)
   { /* if ServiceTracker is not open */
     return TTT::DefaultValue();
   }
   {
     US_UNUSED(typename _TrackedService::Lock(t));
     return t->GetCustomizedObject(reference);
   }
 }
 
 template<class S, class TTT>
 std::vector<typename ServiceTracker<S,TTT>::T> ServiceTracker<S,TTT>::GetServices() const
 {
   std::vector<T> services;
   _TrackedService* t = d->Tracked();
   if (t == nullptr)
   { /* if ServiceTracker is not open */
     return services;
   }
   {
     US_UNUSED(typename _TrackedService::Lock(t));
     std::vector<ServiceReferenceType> references;
     d->GetServiceReferences_unlocked(references, t);
     for(typename std::vector<ServiceReferenceType>::const_iterator ref = references.begin();
         ref != references.end(); ++ref)
     {
       services.push_back(t->GetCustomizedObject(*ref));
     }
   }
   return services;
 }
 
 template<class S, class TTT>
 typename ServiceTracker<S,TTT>::T
 ServiceTracker<S,TTT>::GetService() const
 {
   {
     US_UNUSED(typename _ServiceTrackerPrivate::Lock(d));
     const T& service = d->cachedService;
     if (TTT::IsValid(service))
     {
       US_DEBUG(d->DEBUG_OUTPUT) << "ServiceTracker<S,TTT>::getService[cached]:"
                                 << d->filter;
       return service;
     }
   }
   US_DEBUG(d->DEBUG_OUTPUT) << "ServiceTracker<S,TTT>::getService:" << d->filter;
 
   try
   {
     ServiceReferenceType reference = GetServiceReference();
     if (reference.GetModule() == nullptr)
     {
       return TTT::DefaultValue();
     }
     {
       US_UNUSED(typename _ServiceTrackerPrivate::Lock(d));
       return d->cachedService = GetService(reference);
     }
   }
   catch (const ServiceException&)
   {
     return TTT::DefaultValue();
   }
 }
 
 template<class S, class TTT>
 void ServiceTracker<S,TTT>::Remove(const ServiceReferenceType& reference)
 {
   _TrackedService* t = d->Tracked();
   if (t == nullptr)
   { /* if ServiceTracker is not open */
     return;
   }
   t->Untrack(reference, ServiceEvent());
 }
 
 template<class S, class TTT>
 int ServiceTracker<S,TTT>::Size() const
 {
   _TrackedService* t = d->Tracked();
   if (t == nullptr)
   { /* if ServiceTracker is not open */
     return 0;
   }
   {
     US_UNUSED(typename _TrackedService::Lock(t));
     return static_cast<int>(t->Size());
   }
 }
 
 template<class S, class TTT>
 int ServiceTracker<S,TTT>::GetTrackingCount() const
 {
   _TrackedService* t = d->Tracked();
   if (t == nullptr)
   { /* if ServiceTracker is not open */
     return -1;
   }
   {
     US_UNUSED(typename _TrackedService::Lock(t));
     return t->GetTrackingCount();
   }
 }
 
 template<class S, class TTT>
 void ServiceTracker<S,TTT>::GetTracked(TrackingMap& map) const
 {
   _TrackedService* t = d->Tracked();
   if (t == nullptr)
   { /* if ServiceTracker is not open */
     return;
   }
   {
     US_UNUSED(typename _TrackedService::Lock(t));
     t->CopyEntries(map);
   }
 }
 
 template<class S, class TTT>
 bool ServiceTracker<S,TTT>::IsEmpty() const
 {
   _TrackedService* t = d->Tracked();
   if (t == nullptr)
   { /* if ServiceTracker is not open */
     return true;
   }
   {
     US_UNUSED(typename _TrackedService::Lock(t));
     return t->IsEmpty();
   }
 }
 
 template<class S, class TTT>
 typename ServiceTracker<S,TTT>::T
 ServiceTracker<S,TTT>::AddingService(const ServiceReferenceType& reference)
 {
   return TTT::ConvertToTrackedType(d->context->GetService(reference));
 }
 
 template<class S, class TTT>
 void ServiceTracker<S,TTT>::ModifiedService(const ServiceReferenceType& /*reference*/, T /*service*/)
 {
   /* do nothing */
 }
 
 template<class S, class TTT>
 void ServiceTracker<S,TTT>::RemovedService(const ServiceReferenceType& reference, T /*service*/)
 {
   d->context->UngetService(reference);
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usServiceTrackerPrivate.h b/Modules/CppMicroServices/core/src/service/usServiceTrackerPrivate.h
index 282798710a..d03e6bb255 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceTrackerPrivate.h
+++ b/Modules/CppMicroServices/core/src/service/usServiceTrackerPrivate.h
@@ -1,172 +1,172 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICETRACKERPRIVATE_H
 #define USSERVICETRACKERPRIVATE_H
 
 #include "usServiceReference.h"
 #include "usLDAPFilter.h"
 
 
 US_BEGIN_NAMESPACE
 
 /**
  * \ingroup MicroServices
  */
 template<class S, class TTT>
 class ServiceTrackerPrivate : MultiThreaded<>
 {
 
 public:
 
   typedef typename TTT::TrackedType T;
 
   ServiceTrackerPrivate(ServiceTracker<S,TTT>* st,
                         ModuleContext* context,
                         const ServiceReference<S>& reference,
                         ServiceTrackerCustomizer<S,T>* customizer);
 
   ServiceTrackerPrivate(ServiceTracker<S,TTT>* st,
                         ModuleContext* context, const std::string& clazz,
                         ServiceTrackerCustomizer<S,T>* customizer);
 
   ServiceTrackerPrivate(ServiceTracker<S,TTT>* st,
                         ModuleContext* context, const LDAPFilter& filter,
                         ServiceTrackerCustomizer<S,T>* customizer);
 
   ~ServiceTrackerPrivate();
 
   /**
    * Returns the list of initial <code>ServiceReference</code>s that will be
    * tracked by this <code>ServiceTracker</code>.
    *
    * @param className The class name with which the service was registered, or
    *        <code>null</code> for all services.
    * @param filterString The filter criteria or <code>null</code> for all
    *        services.
    * @return The list of initial <code>ServiceReference</code>s.
    * @throws std::invalid_argument If the specified filterString has an
    *         invalid syntax.
    */
   std::vector<ServiceReference<S> > GetInitialReferences(const std::string& className,
                                                          const std::string& filterString);
 
   void GetServiceReferences_unlocked(std::vector<ServiceReference<S> >& refs, TrackedService<S,TTT>* t) const;
 
   /* set this to true to compile in debug messages */
   static const bool DEBUG_OUTPUT; // = false;
 
   /**
    * The Module Context used by this <code>ServiceTracker</code>.
    */
   ModuleContext* const context;
 
   /**
    * The filter used by this <code>ServiceTracker</code> which specifies the
    * search criteria for the services to track.
    */
   LDAPFilter filter;
 
   /**
    * The <code>ServiceTrackerCustomizer</code> for this tracker.
    */
   ServiceTrackerCustomizer<S,T>* customizer;
 
   /**
    * Filter string for use when adding the ServiceListener. If this field is
    * set, then certain optimizations can be taken since we don't have a user
    * supplied filter.
    */
   std::string listenerFilter;
 
   /**
    * Class name to be tracked. If this field is set, then we are tracking by
    * class name.
    */
   std::string trackClass;
 
   /**
    * Reference to be tracked. If this field is set, then we are tracking a
    * single ServiceReference.
    */
   ServiceReference<S> trackReference;
 
   /**
    * Tracked services: <code>ServiceReference</code> -> customized Object and
    * <code>ServiceListenerEntry</code> object
    */
   TrackedService<S,TTT>* trackedService;
 
   /**
    * Accessor method for the current TrackedService object. This method is only
    * intended to be used by the unsynchronized methods which do not modify the
    * trackedService field.
    *
    * @return The current Tracked object.
    */
   TrackedService<S,TTT>* Tracked() const;
 
   /**
    * Called by the TrackedService object whenever the set of tracked services is
    * modified. Clears the cache.
    */
   /*
    * This method must not be synchronized since it is called by TrackedService while
    * TrackedService is synchronized. We don't want synchronization interactions
    * between the listener thread and the user thread.
    */
   void Modified();
 
   /**
    * Cached ServiceReference for getServiceReference.
    */
   mutable ServiceReference<S> cachedReference;
 
   /**
    * Cached service object for GetService.
    */
   mutable T cachedService;
 
 
 private:
 
   inline ServiceTracker<S,TTT>* q_func()
   {
     return static_cast<ServiceTracker<S,TTT> *>(q_ptr);
   }
 
   inline const ServiceTracker<S,TTT>* q_func() const
   {
     return static_cast<const ServiceTracker<S,TTT> *>(q_ptr);
   }
 
   friend class ServiceTracker<S,TTT>;
 
   ServiceTracker<S,TTT> * const q_ptr;
 
 };
 
 US_END_NAMESPACE
 
 #include "usServiceTrackerPrivate.tpp"
 
 #endif // USSERVICETRACKERPRIVATE_H
diff --git a/Modules/CppMicroServices/core/src/service/usServiceTrackerPrivate.tpp b/Modules/CppMicroServices/core/src/service/usServiceTrackerPrivate.tpp
index 616eec9fe1..940c71f102 100644
--- a/Modules/CppMicroServices/core/src/service/usServiceTrackerPrivate.tpp
+++ b/Modules/CppMicroServices/core/src/service/usServiceTrackerPrivate.tpp
@@ -1,155 +1,155 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usTrackedService_p.h"
 
 #include "usModuleContext.h"
 #include "usLDAPFilter.h"
 
 #include <stdexcept>
 
 US_BEGIN_NAMESPACE
 
 template<class S, class TTT>
 const bool ServiceTrackerPrivate<S,TTT>::DEBUG_OUTPUT = true;
 
 template<class S, class TTT>
 ServiceTrackerPrivate<S,TTT>::ServiceTrackerPrivate(
     ServiceTracker<S,TTT>* st, ModuleContext* context,
     const ServiceReference<S>& reference,
     ServiceTrackerCustomizer<S,T>* customizer)
   : context(context), customizer(customizer), trackReference(reference),
     trackedService(nullptr), cachedReference(), cachedService(TTT::DefaultValue()), q_ptr(st)
 {
   this->customizer = customizer ? customizer : q_func();
   std::stringstream ss;
   ss << "(" << ServiceConstants::SERVICE_ID() << "="
      << any_cast<long>(reference.GetProperty(ServiceConstants::SERVICE_ID())) << ")";
   this->listenerFilter = ss.str();
   try
   {
     this->filter = LDAPFilter(listenerFilter);
   }
   catch (const std::invalid_argument& e)
   {
     /*
      * we could only get this exception if the ServiceReference was
      * invalid
      */
     std::invalid_argument ia(std::string("unexpected std::invalid_argument exception: ") + e.what());
     throw ia;
   }
 }
 
 template<class S, class TTT>
 ServiceTrackerPrivate<S,TTT>::ServiceTrackerPrivate(
     ServiceTracker<S,TTT>* st,
     ModuleContext* context, const std::string& clazz,
     ServiceTrackerCustomizer<S,T>* customizer)
       : context(context), customizer(customizer), trackClass(clazz),
         trackReference(), trackedService(nullptr), cachedReference(),
         cachedService(TTT::DefaultValue()), q_ptr(st)
 {
   this->customizer = customizer ? customizer : q_func();
   this->listenerFilter = std::string("(") + US_PREPEND_NAMESPACE(ServiceConstants)::OBJECTCLASS() + "="
                         + clazz + ")";
   try
   {
     this->filter = LDAPFilter(listenerFilter);
   }
   catch (const std::invalid_argument& e)
   {
     /*
      * we could only get this exception if the clazz argument was
      * malformed
      */
     std::invalid_argument ia(
         std::string("unexpected std::invalid_argument exception: ") + e.what());
     throw ia;
   }
 }
 
 template<class S, class TTT>
 ServiceTrackerPrivate<S,TTT>::ServiceTrackerPrivate(
     ServiceTracker<S,TTT>* st,
     ModuleContext* context, const LDAPFilter& filter,
     ServiceTrackerCustomizer<S,T>* customizer)
       : context(context), filter(filter), customizer(customizer),
         listenerFilter(filter.ToString()), trackReference(),
         trackedService(nullptr), cachedReference(), cachedService(TTT::DefaultValue()), q_ptr(st)
 {
   this->customizer = customizer ? customizer : q_func();
   if (context == nullptr)
   {
     throw std::invalid_argument("The module context cannot be null.");
   }
 }
 
 template<class S, class TTT>
 ServiceTrackerPrivate<S,TTT>::~ServiceTrackerPrivate()
 {
 
 }
 
 template<class S, class TTT>
 std::vector<ServiceReference<S> > ServiceTrackerPrivate<S,TTT>::GetInitialReferences(
   const std::string& className, const std::string& filterString)
 {
   std::vector<ServiceReference<S> > result;
   std::vector<ServiceReferenceU> refs = context->GetServiceReferences(className, filterString);
   for(std::vector<ServiceReferenceU>::const_iterator iter = refs.begin();
       iter != refs.end(); ++iter)
   {
     ServiceReference<S> ref(*iter);
     if (ref)
     {
       result.push_back(ref);
     }
   }
   return result;
 }
 
 template<class S, class TTT>
 void ServiceTrackerPrivate<S,TTT>::GetServiceReferences_unlocked(std::vector<ServiceReference<S> >& refs, TrackedService<S,TTT>* t) const
 {
   if (t->Size() == 0)
   {
     return;
   }
   t->GetTracked(refs);
 }
 
 template<class S, class TTT>
 TrackedService<S,TTT>* ServiceTrackerPrivate<S,TTT>::Tracked() const
 {
   return trackedService;
 }
 
 template<class S, class TTT>
 void ServiceTrackerPrivate<S,TTT>::Modified()
 {
   cachedReference = 0; /* clear cached value */
   TTT::Dispose(cachedService); /* clear cached value */
   US_DEBUG(DEBUG_OUTPUT) << "ServiceTracker::Modified(): " << filter;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usTrackedService.tpp b/Modules/CppMicroServices/core/src/service/usTrackedService.tpp
index 6cef9feec1..39293f9e5d 100644
--- a/Modules/CppMicroServices/core/src/service/usTrackedService.tpp
+++ b/Modules/CppMicroServices/core/src/service/usTrackedService.tpp
@@ -1,128 +1,128 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 US_BEGIN_NAMESPACE
 
 template<class S, class TTT>
 TrackedService<S,TTT>::TrackedService(ServiceTracker<S,TTT>* serviceTracker,
                   ServiceTrackerCustomizer<S,T>* customizer)
   : serviceTracker(serviceTracker), customizer(customizer)
 {
 
 }
 
 template<class S, class TTT>
 void TrackedService<S,TTT>::ServiceChanged(const ServiceEvent event)
 {
   /*
    * Check if we had a delayed call (which could happen when we
    * close).
    */
   if (this->closed)
   {
     return;
   }
 
   ServiceReference<S> reference = event.GetServiceReference(InterfaceType<S>());
   US_DEBUG(serviceTracker->d->DEBUG_OUTPUT) << "TrackedService::ServiceChanged["
                                             << event.GetType() << "]: " << reference;
   if (!reference)
   {
     return;
   }
 
   switch (event.GetType())
   {
   case ServiceEvent::REGISTERED :
   case ServiceEvent::MODIFIED :
     {
       if (!serviceTracker->d->listenerFilter.empty())
       { // service listener added with filter
         this->Track(reference, event);
         /*
        * If the customizer throws an unchecked exception, it
        * is safe to let it propagate
        */
       }
       else
       { // service listener added without filter
         if (serviceTracker->d->filter.Match(reference))
         {
           this->Track(reference, event);
           /*
          * If the customizer throws an unchecked exception,
          * it is safe to let it propagate
          */
         }
         else
         {
           this->Untrack(reference, event);
           /*
          * If the customizer throws an unchecked exception,
          * it is safe to let it propagate
          */
         }
       }
       break;
     }
   case ServiceEvent::MODIFIED_ENDMATCH :
   case ServiceEvent::UNREGISTERING :
     this->Untrack(reference, event);
     /*
      * If the customizer throws an unchecked exception, it is
      * safe to let it propagate
      */
     break;
   }
 }
 
 template<class S, class TTT>
 void TrackedService<S,TTT>::Modified()
 {
   Superclass::Modified(); /* increment the modification count */
   serviceTracker->d->Modified();
 }
 
 template<class S, class TTT>
 typename TrackedService<S,TTT>::T
 TrackedService<S,TTT>::CustomizerAdding(ServiceReference<S> item,
                                         const ServiceEvent& /*related*/)
 {
   return customizer->AddingService(item);
 }
 
 template<class S, class TTT>
 void TrackedService<S,TTT>::CustomizerModified(ServiceReference<S> item,
                                                const ServiceEvent& /*related*/,
                                                T object)
 {
   customizer->ModifiedService(item, object);
 }
 
 template<class S, class TTT>
 void TrackedService<S,TTT>::CustomizerRemoved(ServiceReference<S> item,
                                               const ServiceEvent& /*related*/,
                                               T object)
 {
   customizer->RemovedService(item, object);
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/service/usTrackedServiceListener_p.h b/Modules/CppMicroServices/core/src/service/usTrackedServiceListener_p.h
index 17847259a3..a147ada055 100644
--- a/Modules/CppMicroServices/core/src/service/usTrackedServiceListener_p.h
+++ b/Modules/CppMicroServices/core/src/service/usTrackedServiceListener_p.h
@@ -1,51 +1,51 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTRACKEDSERVICELISTENER_H
 #define USTRACKEDSERVICELISTENER_H
 
 #include "usServiceEvent.h"
 
 US_BEGIN_NAMESPACE
 
 /**
  * This class is not intended to be used directly. It is exported to support
  * the CppMicroServices module system.
  */
 struct TrackedServiceListener
 {
   virtual ~TrackedServiceListener() {}
 
   /**
    * Slot connected to service events for the
    * <code>ServiceTracker</code> class. This method must NOT be
    * synchronized to avoid deadlock potential.
    *
    * @param event <code>ServiceEvent</code> object from the framework.
    */
   virtual void ServiceChanged(const ServiceEvent event) = 0;
 
 };
 
 US_END_NAMESPACE
 
 #endif // USTRACKEDSERVICELISTENER_H
diff --git a/Modules/CppMicroServices/core/src/service/usTrackedService_p.h b/Modules/CppMicroServices/core/src/service/usTrackedService_p.h
index f589353944..6cd601a12e 100644
--- a/Modules/CppMicroServices/core/src/service/usTrackedService_p.h
+++ b/Modules/CppMicroServices/core/src/service/usTrackedService_p.h
@@ -1,110 +1,110 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTRACKEDSERVICE_H
 #define USTRACKEDSERVICE_H
 
 #include "usTrackedServiceListener_p.h"
 #include "usModuleAbstractTracked_p.h"
 #include "usServiceEvent.h"
 
 US_BEGIN_NAMESPACE
 
 /**
  * This class is not intended to be used directly. It is exported to support
  * the CppMicroServices module system.
  */
 template<class S, class TTT>
 class TrackedService : public TrackedServiceListener,
     public ModuleAbstractTracked<ServiceReference<S>, TTT, ServiceEvent>
 {
 
 public:
 
   typedef typename TTT::TrackedType T;
 
   TrackedService(ServiceTracker<S,TTT>* serviceTracker,
                  ServiceTrackerCustomizer<S,T>* customizer);
 
   /**
    * Method connected to service events for the
    * <code>ServiceTracker</code> class. This method must NOT be
    * synchronized to avoid deadlock potential.
    *
    * @param event <code>ServiceEvent</code> object from the framework.
    */
   void ServiceChanged(const ServiceEvent event) override;
 
 private:
 
   typedef ModuleAbstractTracked<ServiceReference<S>, TTT, ServiceEvent> Superclass;
 
   ServiceTracker<S,TTT>* serviceTracker;
   ServiceTrackerCustomizer<S,T>* customizer;
 
   /**
    * Increment the tracking count and tell the tracker there was a
    * modification.
    *
    * @GuardedBy this
    */
   void Modified() override;
 
   /**
    * Call the specific customizer adding method. This method must not be
    * called while synchronized on this object.
    *
    * @param item Item to be tracked.
    * @param related Action related object.
    * @return Customized object for the tracked item or <code>null</code>
    *         if the item is not to be tracked.
    */
   T CustomizerAdding(ServiceReference<S> item, const ServiceEvent& related) override;
 
   /**
    * Call the specific customizer modified method. This method must not be
    * called while synchronized on this object.
    *
    * @param item Tracked item.
    * @param related Action related object.
    * @param object Customized object for the tracked item.
    */
   void CustomizerModified(ServiceReference<S> item,
                           const ServiceEvent& related, T object) override ;
 
   /**
    * Call the specific customizer removed method. This method must not be
    * called while synchronized on this object.
    *
    * @param item Tracked item.
    * @param related Action related object.
    * @param object Customized object for the tracked item.
    */
   void CustomizerRemoved(ServiceReference<S> item,
                          const ServiceEvent& related, T object) override ;
 };
 
 US_END_NAMESPACE
 
 #include "usTrackedService.tpp"
 
 #endif // USTRACKEDSERVICE_H
diff --git a/Modules/CppMicroServices/core/src/util/usAny.cpp b/Modules/CppMicroServices/core/src/util/usAny.cpp
index e1ae1e5ce0..d93864bfd5 100644
--- a/Modules/CppMicroServices/core/src/util/usAny.cpp
+++ b/Modules/CppMicroServices/core/src/util/usAny.cpp
@@ -1,46 +1,46 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usAny.h"
 
 US_BEGIN_NAMESPACE
 
 std::string any_value_to_string(const Any& any)
 {
   return any.ToString();
 }
 
 std::string any_value_to_json(const Any& val)
 {
   return val.ToJSON();
 }
 
 std::string any_value_to_json(const std::string& val)
 {
   return '"' + val + '"';
 }
 
 std::string any_value_to_json(bool val)
 {
   return val ? "true" : "false";
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/util/usAtomicInt_p.h b/Modules/CppMicroServices/core/src/util/usAtomicInt_p.h
index 6cdf4ad46a..ad4c026708 100644
--- a/Modules/CppMicroServices/core/src/util/usAtomicInt_p.h
+++ b/Modules/CppMicroServices/core/src/util/usAtomicInt_p.h
@@ -1,79 +1,79 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USATOMICINT_H
 #define USATOMICINT_H
 
 #include <usCoreConfig.h>
 #include "usThreads_p.h"
 
 US_BEGIN_NAMESPACE
 
 /**
  * This class acts as an atomic integer.
  *
  * The integer value represented by this class can be incremented
  * and decremented atomically. This is often useful in reference
  * counting scenarios to minimize locking overhead in multi-threaded
  * environments.
  */
 class AtomicInt : private AtomicCounter
 {
 
 public:
 
   AtomicInt(int value = 0) : AtomicCounter(value) {}
 
   /**
    * Increase the reference count atomically by 1.
    *
    * \return <code>true</code> if the new value is unequal to zero, <code>false</code>
    *         otherwise.
    */
   inline bool Ref() const
   { return AtomicIncrement() != 0; }
 
   /**
    * Decrease the reference count atomically by 1.
    *
    * \return <code>true</code> if the new value is unequal to zero, <code>false</code>
    *         otherwise.
    */
   inline bool Deref() const
   { return AtomicDecrement() != 0; }
 
   /**
    * Returns the current value.
    *
    */
   inline operator int() const
   {
     IntType curr(0);
     AtomicAssign(curr);
     return curr;
   }
 
 };
 
 US_END_NAMESPACE
 
 #endif // USATOMICINT_H
diff --git a/Modules/CppMicroServices/core/src/util/usLDAPProp.cpp b/Modules/CppMicroServices/core/src/util/usLDAPProp.cpp
index a7e1c0c916..e7f8686457 100644
--- a/Modules/CppMicroServices/core/src/util/usLDAPProp.cpp
+++ b/Modules/CppMicroServices/core/src/util/usLDAPProp.cpp
@@ -1,136 +1,136 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usLDAPProp.h"
 
 #include <stdexcept>
 
 US_BEGIN_NAMESPACE
 
 LDAPPropExpr::LDAPPropExpr(const std::string& expr)
   : m_ldapExpr(expr)
 {}
 
 LDAPPropExpr& LDAPPropExpr::operator!()
 {
   if (m_ldapExpr.empty()) return *this;
 
   m_ldapExpr = "(!" + m_ldapExpr + ")";
   return *this;
 }
 
 LDAPPropExpr::operator std::string() const
 {
   return m_ldapExpr;
 }
 
 bool LDAPPropExpr::IsNull() const
 {
   return m_ldapExpr.empty();
 }
 
 
 LDAPProp::LDAPProp(const std::string& property)
   : m_property(property)
 {
   if (m_property.empty()) throw std::invalid_argument("property must not be empty");
 }
 
 LDAPPropExpr LDAPProp::operator==(const std::string& s) const
 {
   if (s.empty()) return LDAPPropExpr(s);
   return LDAPPropExpr("(" + m_property + "=" + s + ")");
 }
 
 LDAPPropExpr LDAPProp::operator==(const us::Any& any) const
 {
   return operator==(any.ToString());
 }
 
 LDAPProp::operator LDAPPropExpr () const
 {
   return LDAPPropExpr("(" + m_property + "=*)");
 }
 
 LDAPPropExpr LDAPProp::operator!() const
 {
   return LDAPPropExpr("(!(" + m_property + "=*))");
 }
 
 LDAPPropExpr LDAPProp::operator!=(const std::string& s) const
 {
   if (s.empty()) return LDAPPropExpr(s);
   return LDAPPropExpr("(!(" + m_property + "=" + s + "))");
 }
 
 LDAPPropExpr LDAPProp::operator!=(const us::Any& any) const
 {
   return operator!=(any.ToString());
 }
 
 LDAPPropExpr LDAPProp::operator>=(const std::string& s) const
 {
   if (s.empty()) return LDAPPropExpr(s);
   return LDAPPropExpr("(" + m_property + ">=" + s + ")");
 }
 
 LDAPPropExpr LDAPProp::operator>=(const us::Any& any) const
 {
   return operator>=(any.ToString());
 }
 
 LDAPPropExpr LDAPProp::operator<=(const std::string& s) const
 {
   if (s.empty()) return LDAPPropExpr(s);
   return LDAPPropExpr("(" + m_property + "<=" + s + ")");
 }
 
 LDAPPropExpr LDAPProp::operator<=(const us::Any& any) const
 {
   return operator<=(any.ToString());
 }
 
 LDAPPropExpr LDAPProp::Approx(const std::string& s) const
 {
   if (s.empty()) return LDAPPropExpr(s);
   return LDAPPropExpr("(" + m_property + "~=" + s + ")");
 }
 
 LDAPPropExpr LDAPProp::Approx(const us::Any& any) const
 {
   return Approx(any.ToString());
 }
 
 US_END_NAMESPACE
 
 us::LDAPPropExpr operator&&(const us::LDAPPropExpr& left, const us::LDAPPropExpr& right)
 {
   if (left.IsNull()) return right;
   if (right.IsNull()) return left;
   return us::LDAPPropExpr("(&" + static_cast<std::string>(left) + static_cast<std::string>(right) + ")");
 }
 
 us::LDAPPropExpr operator||(const us::LDAPPropExpr& left, const us::LDAPPropExpr& right)
 {
   if (left.IsNull()) return right;
   if (right.IsNull()) return left;
   return us::LDAPPropExpr("(|" + static_cast<std::string>(left) + static_cast<std::string>(right) + ")");
 }
diff --git a/Modules/CppMicroServices/core/src/util/usListenerFunctors_p.h b/Modules/CppMicroServices/core/src/util/usListenerFunctors_p.h
index 6578eb7ed4..d2ffe910b2 100644
--- a/Modules/CppMicroServices/core/src/util/usListenerFunctors_p.h
+++ b/Modules/CppMicroServices/core/src/util/usListenerFunctors_p.h
@@ -1,88 +1,88 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USLISTENERFUNCTORS_P_H
 #define USLISTENERFUNCTORS_P_H
 
 #include <usServiceEvent.h>
 #include <usModuleEvent.h>
 
 #include <algorithm>
 #include <cstring>
 
 #ifdef US_HAVE_STD_FUNCTION
   #ifdef US_HAVE_FUNCTIONAL_H
     #include <functional>
   #elif defined(US_HAVE_TR1_FUNCTIONAL_H)
     #include <tr1/functional>
   #endif
   #define US_FUNCTION_TYPE std::function
 #elif defined(US_HAVE_TR1_FUNCTION)
   #ifdef US_HAVE_TR1_FUNCTIONAL_H
     #include <tr1/functional>
   #elif defined(US_HAVE_FUNCTIONAL_H)
     #include <functional>
   #endif
   #define US_FUNCTION_TYPE std::tr1::function
 #endif
 
 #define US_MODULE_LISTENER_FUNCTOR US_FUNCTION_TYPE<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>
 #define US_SERVICE_LISTENER_FUNCTOR US_FUNCTION_TYPE<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>
 
 US_BEGIN_NAMESPACE
   template<class X>
   US_MODULE_LISTENER_FUNCTOR ModuleListenerMemberFunctor(X* x, void (X::*memFn)(const US_PREPEND_NAMESPACE(ModuleEvent)))
   { return std::bind(std::mem_fn(memFn), x, std::placeholders::_1); }
 
   struct ModuleListenerCompare
   {
     bool operator()(const std::pair<US_MODULE_LISTENER_FUNCTOR, void*>& p1,
                     const std::pair<US_MODULE_LISTENER_FUNCTOR, void*>& p2) const
     {
       return p1.second == p2.second &&
              p1.first.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>() == p2.first.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>();
     }
   };
 
   template<class X>
   US_SERVICE_LISTENER_FUNCTOR ServiceListenerMemberFunctor(X* x, void (X::*memFn)(const US_PREPEND_NAMESPACE(ServiceEvent)))
   { return std::bind(std::mem_fn(memFn), x, std::placeholders::_1); }
 
   struct ServiceListenerCompare
   {
     bool operator()(const US_SERVICE_LISTENER_FUNCTOR& f1,
                     const US_SERVICE_LISTENER_FUNCTOR& f2) const
     {
       return f1.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>() == f2.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>();
     }
   };
 US_END_NAMESPACE
 
 US_HASH_FUNCTION_NAMESPACE_BEGIN
 US_HASH_FUNCTION_BEGIN(US_SERVICE_LISTENER_FUNCTOR)
   void(*targetFunc)(const US_PREPEND_NAMESPACE(ServiceEvent)&) = arg.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>();
   void* targetPtr = nullptr;
   std::memcpy(&targetPtr, &targetFunc, sizeof(void*));
   return US_HASH_FUNCTION(void*, targetPtr);
 US_HASH_FUNCTION_END
 US_HASH_FUNCTION_NAMESPACE_END
 
 #endif // USLISTENERFUNCTORS_P_H
diff --git a/Modules/CppMicroServices/core/src/util/usLog_p.h b/Modules/CppMicroServices/core/src/util/usLog_p.h
index 533027b6a0..a31632709b 100644
--- a/Modules/CppMicroServices/core/src/util/usLog_p.h
+++ b/Modules/CppMicroServices/core/src/util/usLog_p.h
@@ -1,94 +1,94 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USLOG_P_H
 #define USLOG_P_H
 
 #include <usCoreConfig.h>
 #include <usModuleSettings.h>
 
 #include <iostream>
 #include <sstream>
 
 US_BEGIN_NAMESPACE
 
 US_Core_EXPORT void message_output(MsgType, const char* buf);
 
 struct LogMsg {
 
   LogMsg(MsgType t, const char* file, int ln, const char* func)
     : type(t), enabled(true), buffer()
   { buffer << "In " << func << " at " << file << ":" << ln << " : "; }
 
   LogMsg()
     : type(DebugMsg), enabled(false), buffer()
   {}
 
   LogMsg(const LogMsg& other)
     : type(other.type), enabled(other.enabled), buffer()
   {}
 
   ~LogMsg() { if(enabled) message_output(type, buffer.str().c_str()); }
 
   template<typename T>
   LogMsg& operator<<(T t)
   {
     if (enabled) buffer << t;
     return *this;
   }
 
   LogMsg& operator()(bool flag)
   {
     this->enabled = flag;
     return *this;
   }
 
 private:
 
   MsgType type;
   bool enabled;
   std::stringstream buffer;
 };
 
 
 US_END_NAMESPACE
 
 #if defined(US_ENABLE_DEBUG_OUTPUT)
   #define US_DEBUG (US_PREPEND_NAMESPACE(ModuleSettings)::GetLogLevel() > US_PREPEND_NAMESPACE(DebugMsg) ? US_PREPEND_NAMESPACE(LogMsg)() : US_PREPEND_NAMESPACE(LogMsg)(US_PREPEND_NAMESPACE(DebugMsg), __FILE__, __LINE__, __FUNCTION__))
 #else
   #define US_DEBUG true ? US_PREPEND_NAMESPACE(LogMsg)() : US_PREPEND_NAMESPACE(LogMsg)()
 #endif
 
 #if !defined(US_NO_INFO_OUTPUT)
   #define US_INFO (US_PREPEND_NAMESPACE(ModuleSettings)::GetLogLevel() > US_PREPEND_NAMESPACE(InfoMsg) ? US_PREPEND_NAMESPACE(LogMsg)() : US_PREPEND_NAMESPACE(LogMsg)(US_PREPEND_NAMESPACE(InfoMsg), __FILE__, __LINE__, __FUNCTION__))
 #else
   #define US_INFO  true ? US_PREPEND_NAMESPACE(LogMsg)() : US_PREPEND_NAMESPACE(LogMsg)()
 #endif
 
 #if !defined(US_NO_WARNING_OUTPUT)
   #define US_WARN (US_PREPEND_NAMESPACE(ModuleSettings)::GetLogLevel() > US_PREPEND_NAMESPACE(WarningMsg) ? US_PREPEND_NAMESPACE(LogMsg)() : US_PREPEND_NAMESPACE(LogMsg)(US_PREPEND_NAMESPACE(WarningMsg), __FILE__, __LINE__, __FUNCTION__))
 #else
   #define US_WARN true ? US_PREPEND_NAMESPACE(LogMsg)() : US_PREPEND_NAMESPACE(LogMsg)()
 #endif
 
 #define US_ERROR US_PREPEND_NAMESPACE(LogMsg)(US_PREPEND_NAMESPACE(ErrorMsg), __FILE__, __LINE__, __FUNCTION__)
 
 #endif // USLOG_P_H
diff --git a/Modules/CppMicroServices/core/src/util/usSharedLibrary.cpp b/Modules/CppMicroServices/core/src/util/usSharedLibrary.cpp
index 032946d706..6e8acb7447 100644
--- a/Modules/CppMicroServices/core/src/util/usSharedLibrary.cpp
+++ b/Modules/CppMicroServices/core/src/util/usSharedLibrary.cpp
@@ -1,273 +1,273 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usSharedLibrary.h"
 
 #include <stdexcept>
 
 #include <usUtils_p.h>
 #include <usModuleRegistry.h>
 #include <usModuleActivator.h>
 
 
 #if defined(US_PLATFORM_POSIX)
   #include <dlfcn.h>
 #elif defined(US_PLATFORM_WINDOWS)
   #ifndef WIN32_LEAN_AND_MEAN
     #define WIN32_LEAN_AND_MEAN
   #endif
   #include <windows.h>
   #include <strsafe.h>
 #else
   #error Unsupported platform
 #endif
 
 
 US_BEGIN_NAMESPACE
 
 #ifdef US_PLATFORM_POSIX
 static const char PATH_SEPARATOR = '/';
 #else
 static const char PATH_SEPARATOR = '\\';
 #endif
 
 class SharedLibraryPrivate : public SharedData
 {
 public:
 
   SharedLibraryPrivate()
     : m_Handle(nullptr)
   #ifdef US_PLATFORM_WINDOWS
     , m_Suffix(".dll")
   #elif defined(US_PLATFORM_APPLE)
     , m_Suffix(".dylib")
     , m_Prefix("lib")
   #else
     , m_Suffix(".so")
     , m_Prefix("lib")
   #endif
   {}
 
   void* m_Handle;
 
   std::string m_Name;
   std::string m_Path;
   std::string m_FilePath;
   std::string m_Suffix;
   std::string m_Prefix;
 
 };
 
 SharedLibrary::SharedLibrary()
   : d(new SharedLibraryPrivate)
 {
 }
 
 SharedLibrary::SharedLibrary(const SharedLibrary& other)
   : d(other.d)
 {
 }
 
 SharedLibrary::SharedLibrary(const std::string& libPath, const std::string& name)
   : d(new SharedLibraryPrivate)
 {
   d->m_Name = name;
   d->m_Path = libPath;
 }
 
 SharedLibrary::SharedLibrary(const std::string& absoluteFilePath)
   : d(new SharedLibraryPrivate)
 {
   d->m_FilePath = absoluteFilePath;
   SetFilePath(absoluteFilePath);
 }
 
 SharedLibrary::~SharedLibrary()
 {
 }
 
 SharedLibrary& SharedLibrary::operator =(const SharedLibrary& other)
 {
   d = other.d;
   return *this;
 }
 
 void SharedLibrary::Load(int flags)
 {
   if (d->m_Handle) throw std::logic_error(std::string("Library already loaded: ") + GetFilePath());
   std::string libPath = GetFilePath();
 #ifdef US_PLATFORM_POSIX
   d->m_Handle = dlopen(libPath.c_str(), flags);
   if (!d->m_Handle)
   {
     const char* err = dlerror();
     throw std::runtime_error(err ? std::string(err) : (std::string("Error loading ") + libPath));
   }
 #else
   d->m_Handle = LoadLibrary(libPath.c_str());
   if (!d->m_Handle)
   {
     std::string errMsg = "Loading ";
     errMsg.append(libPath).append("failed with error: ").append(GetLastErrorStr());
 
     throw std::runtime_error(errMsg);
   }
 #endif
 }
 
 void SharedLibrary::Load()
 {
 #ifdef US_PLATFORM_POSIX
 #ifdef US_GCC_RTTI_WORKAROUND_NEEDED
   Load(RTLD_LAZY | RTLD_GLOBAL);
 #else
   Load(RTLD_LAZY | RTLD_LOCAL);
 #endif
 #else
   Load(0);
 #endif
 }
 
 void SharedLibrary::Unload()
 {
   if (d->m_Handle)
   {
 #ifdef US_PLATFORM_POSIX
     if (dlclose(d->m_Handle))
     {
       const char* err = dlerror();
       throw std::runtime_error(err ? std::string(err) : (std::string("Error unloading ") + GetLibraryPath()));
     }
 #else
     if (!FreeLibrary((HMODULE)d->m_Handle))
     {
       std::string errMsg = "Unloading ";
       errMsg.append(GetLibraryPath()).append("failed with error: ").append(GetLastErrorStr());
 
       throw std::runtime_error(errMsg);
     }
 #endif
     d->m_Handle = nullptr;
   }
 }
 
 void SharedLibrary::SetName(const std::string& name)
 {
   if (IsLoaded() || !d->m_FilePath.empty()) return;
   d.Detach();
   d->m_Name = name;
 }
 
 std::string SharedLibrary::GetName() const
 {
   return d->m_Name;
 }
 
 std::string SharedLibrary::GetFilePath(const std::string& name) const
 {
   if (!d->m_FilePath.empty()) return d->m_FilePath;
   return GetLibraryPath() + PATH_SEPARATOR + GetPrefix() + name + GetSuffix();
 }
 
 void SharedLibrary::SetFilePath(const std::string& absoluteFilePath)
 {
   if (IsLoaded()) return;
 
   d.Detach();
   d->m_FilePath = absoluteFilePath;
 
   std::string name = d->m_FilePath;
   std::size_t pos = d->m_FilePath.find_last_of(PATH_SEPARATOR);
   if (pos != std::string::npos)
   {
     d->m_Path = d->m_FilePath.substr(0, pos);
     name = d->m_FilePath.substr(pos+1);
   }
   else
   {
     d->m_Path.clear();
   }
 
   if (name.size() >= d->m_Prefix.size() &&
       name.compare(0, d->m_Prefix.size(), d->m_Prefix) == 0)
   {
     name = name.substr(d->m_Prefix.size());
   }
   if (name.size() >= d->m_Suffix.size() &&
       name.compare(name.size()-d->m_Suffix.size(), d->m_Suffix.size(), d->m_Suffix) == 0)
   {
     name = name.substr(0, name.size()-d->m_Suffix.size());
   }
   d->m_Name = name;
 }
 
 std::string SharedLibrary::GetFilePath() const
 {
   return GetFilePath(d->m_Name);
 }
 
 void SharedLibrary::SetLibraryPath(const std::string& path)
 {
   if (IsLoaded() || !d->m_FilePath.empty()) return;
   d.Detach();
   d->m_Path = path;
 }
 
 std::string SharedLibrary::GetLibraryPath() const
 {
   return d->m_Path;
 }
 
 void SharedLibrary::SetSuffix(const std::string& suffix)
 {
   if (IsLoaded() || !d->m_FilePath.empty()) return;
   d.Detach();
   d->m_Suffix = suffix;
 }
 
 std::string SharedLibrary::GetSuffix() const
 {
   return d->m_Suffix;
 }
 
 void SharedLibrary::SetPrefix(const std::string& prefix)
 {
   if (IsLoaded() || !d->m_FilePath.empty()) return;
   d.Detach();
   d->m_Prefix = prefix;
 }
 
 std::string SharedLibrary::GetPrefix() const
 {
   return d->m_Prefix;
 }
 
 void* SharedLibrary::GetHandle() const
 {
   return d->m_Handle;
 }
 
 bool SharedLibrary::IsLoaded() const
 {
   return d->m_Handle != nullptr;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/util/usStaticInit_p.h b/Modules/CppMicroServices/core/src/util/usStaticInit_p.h
index 72011ff32b..c52a02c45e 100644
--- a/Modules/CppMicroServices/core/src/util/usStaticInit_p.h
+++ b/Modules/CppMicroServices/core/src/util/usStaticInit_p.h
@@ -1,171 +1,171 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 /*============================================================================
 
 Extracted from qglobal.h from Qt 4.7.3 and adapted for CppMicroServices.
 Original copyright (c) Nokia Corporation. Usage covered by the
 GNU Lesser General Public License version 2.1
-(http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html) and the Nokia Qt
+(https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html) and the Nokia Qt
 LGPL Exception version 1.1 (file LGPL_EXCEPTION.txt in Qt 4.7.3 package).
 
 ============================================================================*/
 
 #ifndef US_STATIC_INIT_H
 #define US_STATIC_INIT_H
 
 #include "usThreads_p.h"
 
 US_BEGIN_NAMESPACE
 
 // POD for US_GLOBAL_STATIC
 template <typename T>
 class GlobalStatic : public MultiThreaded<>
 {
 public:
 
   GlobalStatic(T* p = nullptr, bool destroyed = false) : pointer(p), destroyed(destroyed) {}
 
   T* pointer;
   bool destroyed;
 
 private:
 
   // purposely not implemented
   GlobalStatic(const GlobalStatic&);
   GlobalStatic& operator=(const GlobalStatic&);
 };
 
 template<typename T>
 struct DefaultGlobalStaticDeleter
 {
   void operator()(GlobalStatic<T>& globalStatic) const
   {
     delete globalStatic.pointer;
     globalStatic.pointer = nullptr;
     globalStatic.destroyed = true;
   }
 };
 
 // Created as a function-local static to delete a GlobalStatic<T>
 template <typename T, template<typename T_> class Deleter = DefaultGlobalStaticDeleter>
 class GlobalStaticDeleter
 {
 public:
   GlobalStatic<T> &globalStatic;
 
   GlobalStaticDeleter(GlobalStatic<T> &_globalStatic)
     : globalStatic(_globalStatic)
   { }
 
   inline ~GlobalStaticDeleter()
   {
     Deleter<T> deleter;
     deleter(globalStatic);
   }
 };
 
 US_END_NAMESPACE
 
 
 #define US_GLOBAL_STATIC_INIT(TYPE, NAME)                                \
   static US_PREPEND_NAMESPACE(GlobalStatic)<TYPE>& this_##NAME()         \
   {                                                                      \
     static US_PREPEND_NAMESPACE(GlobalStatic)<TYPE> l;                   \
     return l;                                                            \
   }
 
 #define US_GLOBAL_STATIC(TYPE, NAME)                                     \
   US_GLOBAL_STATIC_INIT(TYPE, NAME)                                      \
   static TYPE *NAME()                                                    \
   {                                                                      \
     if (!this_##NAME().pointer && !this_##NAME().destroyed)              \
     {                                                                    \
       TYPE *x = new TYPE;                                                \
       bool ok = false;                                                   \
       {                                                                  \
         US_PREPEND_NAMESPACE(GlobalStatic)<TYPE>::Lock lock(this_##NAME()); \
         US_UNUSED(lock);                                                 \
         if (!this_##NAME().pointer)                                      \
         {                                                                \
           this_##NAME().pointer = x;                                     \
           ok = true;                                                     \
         }                                                                \
       }                                                                  \
       if (!ok)                                                           \
         delete x;                                                        \
       else                                                               \
         static US_PREPEND_NAMESPACE(GlobalStaticDeleter)<TYPE> cleanup(this_##NAME()); \
     }                                                                    \
     return this_##NAME().pointer;                                        \
   }
 
 #define US_GLOBAL_STATIC_WITH_DELETER(TYPE, NAME, DELETER)               \
   US_GLOBAL_STATIC_INIT(TYPE, NAME)                                      \
   static TYPE *NAME()                                                    \
   {                                                                      \
     if (!this_##NAME().pointer && !this_##NAME().destroyed)              \
     {                                                                    \
       TYPE *x = new TYPE;                                                \
       bool ok = false;                                                   \
       {                                                                  \
         US_PREPEND_NAMESPACE(GlobalStatic)<TYPE>::Lock lock(this_##NAME()); \
         US_UNUSED(lock);                                                 \
         if (!this_##NAME().pointer)                                      \
         {                                                                \
           this_##NAME().pointer = x;                                     \
           ok = true;                                                     \
         }                                                                \
       }                                                                  \
       if (!ok)                                                           \
         delete x;                                                        \
       else                                                               \
         static US_PREPEND_NAMESPACE(GlobalStaticDeleter)<TYPE, DELETER > cleanup(this_##NAME()); \
     }                                                                    \
     return this_##NAME().pointer;                                        \
   }
 
 #define US_GLOBAL_STATIC_WITH_ARGS(TYPE, NAME, ARGS)                     \
   US_GLOBAL_STATIC_INIT(TYPE, NAME)                                      \
   static TYPE *NAME()                                                    \
   {                                                                      \
     if (!this_##NAME().pointer && !this_##NAME().destroyed)              \
     {                                                                    \
       TYPE *x = new TYPE ARGS;                                           \
       bool ok = false;                                                   \
       {                                                                  \
         US_PREPEND_NAMESPACE(GlobalStatic)<TYPE>::Lock lock(this_##NAME()); \
         US_UNUSED(lock);                                                 \
         if (!this_##NAME().pointer)                                      \
         {                                                                \
           this_##NAME().pointer = x;                                     \
           ok = true;                                                     \
         }                                                                \
       }                                                                  \
       if (!ok)                                                           \
         delete x;                                                        \
       else                                                               \
         static US_PREPEND_NAMESPACE(GlobalStaticDeleter)<TYPE> cleanup(this_##NAME()); \
     }                                                                    \
     return this_##NAME().pointer;                                        \
   }
 
 #endif // US_STATIC_INIT_H
diff --git a/Modules/CppMicroServices/core/src/util/usThreads_p.h b/Modules/CppMicroServices/core/src/util/usThreads_p.h
index 9eaeca1d4e..c6f1f5afc8 100644
--- a/Modules/CppMicroServices/core/src/util/usThreads_p.h
+++ b/Modules/CppMicroServices/core/src/util/usThreads_p.h
@@ -1,329 +1,329 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTHREADINGMODEL_H
 #define USTHREADINGMODEL_H
 
 #include <usCoreConfig.h>
 
 #ifdef US_ENABLE_THREADING_SUPPORT
 
   // Atomic compiler intrinsics
 
   #if defined(US_PLATFORM_APPLE)
     // OSAtomic.h optimizations only used in 10.5 and later, deprecated in 10.12
     #include <AvailabilityMacros.h>
     #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 && MAC_OS_X_VERSION_MAX_ALLOWED < 101200
       #include <libkern/OSAtomic.h>
       #define US_ATOMIC_OPTIMIZATION_APPLE
     #endif
 
   #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
 
     #if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2))
       # include <ext/atomicity.h>
     #else
       # include <bits/atomicity.h>
     #endif
     #define US_ATOMIC_OPTIMIZATION_GNUC
 
   #endif
 
   // Mutex support
 
   #ifdef US_PLATFORM_WINDOWS
     #ifndef WIN32_LEAN_AND_MEAN
       #define WIN32_LEAN_AND_MEAN
     #endif
     #ifndef NOMINMAX
       #define NOMINMAX
     #endif
     #include <windows.h>
 
     #define US_THREADS_MUTEX(x)           HANDLE (x);
     #define US_THREADS_MUTEX_INIT(x)
     #define US_THREADS_MUTEX_CTOR(x)      : x(::CreateMutex(nullptr, FALSE, nullptr))
     #define US_THREADS_MUTEX_DELETE(x)    ::CloseHandle (x)
     #define US_THREADS_MUTEX_LOCK(x)      ::WaitForSingleObject (x, INFINITE)
     #define US_THREADS_MUTEX_UNLOCK(x)    ::ReleaseMutex (x)
     #define US_THREADS_LONG               LONG
 
     #define US_ATOMIC_OPTIMIZATION
     #define US_ATOMIC_INCREMENT(x)        IntType n = InterlockedIncrement(x)
     #define US_ATOMIC_DECREMENT(x)        IntType n = InterlockedDecrement(x)
     #define US_ATOMIC_ASSIGN(l, r)        InterlockedExchange(l, r)
 
   #elif defined(US_PLATFORM_POSIX)
 
     #include <pthread.h>
 
     #define US_THREADS_MUTEX(x)           pthread_mutex_t x;
     #define US_THREADS_MUTEX_INIT(x)      ::pthread_mutex_init(&x, 0)
     #define US_THREADS_MUTEX_CTOR(x)      : x()
     #define US_THREADS_MUTEX_DELETE(x)    ::pthread_mutex_destroy (&x)
     #define US_THREADS_MUTEX_LOCK(x)      ::pthread_mutex_lock (&x)
     #define US_THREADS_MUTEX_UNLOCK(x)    ::pthread_mutex_unlock (&x)
 
     #define US_ATOMIC_OPTIMIZATION
     #if defined(US_ATOMIC_OPTIMIZATION_APPLE)
       #if defined (__LP64__) && __LP64__
         #define US_THREADS_LONG           volatile int64_t
         #define US_ATOMIC_INCREMENT(x)    IntType n = OSAtomicIncrement64Barrier(x)
         #define US_ATOMIC_DECREMENT(x)    IntType n = OSAtomicDecrement64Barrier(x)
         #define US_ATOMIC_ASSIGN(l, v)    OSAtomicCompareAndSwap64Barrier(*l, v, l)
       #else
         #define US_THREADS_LONG           volatile int32_t
         #define US_ATOMIC_INCREMENT(x)    IntType n = OSAtomicIncrement32Barrier(x)
         #define US_ATOMIC_DECREMENT(x)    IntType n = OSAtomicDecrement32Barrier(x)
         #define US_ATOMIC_ASSIGN(l, v)    OSAtomicCompareAndSwap32Barrier(*l, v, l)
       #endif
     #elif defined(US_ATOMIC_OPTIMIZATION_GNUC)
       #define US_THREADS_LONG             _Atomic_word
       #define US_ATOMIC_INCREMENT(x)      IntType n = __sync_add_and_fetch(x, 1)
       #define US_ATOMIC_DECREMENT(x)      IntType n = __sync_add_and_fetch(x, -1)
       #define US_ATOMIC_ASSIGN(l, v)      __sync_val_compare_and_swap(l, *l, v)
     #else
       #define US_THREADS_LONG             long
       #undef US_ATOMIC_OPTIMIZATION
       #define US_ATOMIC_INCREMENT(x)      m_AtomicMtx.Lock();  \
                                           IntType n = ++(*x);  \
                                           m_AtomicMtx.Unlock()
       #define US_ATOMIC_DECREMENT(x)      m_AtomicMtx.Lock();  \
                                           IntType n = --(*x);  \
                                           m_AtomicMtx.Unlock()
       #define US_ATOMIC_ASSIGN(l, v)      m_AtomicMtx.Lock();  \
                                           *l = v;              \
                                           m_AtomicMtx.Unlock()
     #endif
 
   #endif
 
 #else
 
   // single threaded
   #define US_THREADS_MUTEX(x)
   #define US_THREADS_MUTEX_INIT(x)
   #define US_THREADS_MUTEX_CTOR(x)
   #define US_THREADS_MUTEX_DELETE(x)
   #define US_THREADS_MUTEX_LOCK(x)
   #define US_THREADS_MUTEX_UNLOCK(x)
   #define US_THREADS_LONG int
 
   #define US_ATOMIC_INCREMENT(x)        IntType n = ++(*x);
   #define US_ATOMIC_DECREMENT(x)        IntType n = --(*x);
   #define US_ATOMIC_ASSIGN(l, r)        *l = r;
 
 #endif
 
 
 US_BEGIN_NAMESPACE
 
 class Mutex
 {
 public:
 
   Mutex() US_THREADS_MUTEX_CTOR(m_Mtx)
   {
     US_THREADS_MUTEX_INIT(m_Mtx);
   }
 
   ~Mutex()
   {
     US_THREADS_MUTEX_DELETE(m_Mtx);
   }
 
   void Lock()
   {
     US_THREADS_MUTEX_LOCK(m_Mtx);
   }
   void Unlock()
   {
     US_THREADS_MUTEX_UNLOCK(m_Mtx);
   }
 
 private:
 
   template<class Host> friend class WaitCondition;
 
   // Copy-constructor not implemented.
   Mutex(const Mutex &);
   // Copy-assignement operator not implemented.
   Mutex & operator = (const Mutex &);
 
   US_THREADS_MUTEX(m_Mtx)
 };
 
 class MutexLock
 {
 public:
   typedef Mutex MutexType;
 
   MutexLock(MutexType& mtx) : m_Mtx(&mtx) { m_Mtx->Lock(); }
   ~MutexLock() { m_Mtx->Unlock(); }
 
 private:
   MutexType* m_Mtx;
 
   // purposely not implemented
   MutexLock(const MutexLock&);
   MutexLock& operator=(const MutexLock&);
 };
 
 class AtomicCounter
 {
 public:
 
   typedef US_THREADS_LONG IntType;
 
   AtomicCounter(int value = 0)
     : m_Counter(value)
   {}
 
   IntType AtomicIncrement() const
   {
     US_ATOMIC_INCREMENT(&m_Counter);
     return n;
   }
 
   IntType AtomicIncrement(volatile IntType& lval) const
   {
     US_ATOMIC_INCREMENT(&lval);
     return n;
   }
 
   IntType AtomicDecrement() const
   {
     US_ATOMIC_DECREMENT(&m_Counter);
     return n;
   }
 
   IntType AtomicDecrement(volatile IntType& lval) const
   {
     US_ATOMIC_DECREMENT(&lval);
     return n;
   }
 
   void AtomicAssign(volatile IntType& lval) const
   {
     US_ATOMIC_ASSIGN(&lval, m_Counter);
   }
 
   void AtomicAssign(volatile IntType& lval, const IntType val) const
   {
     US_ATOMIC_ASSIGN(&lval, val);
   }
 
   mutable IntType m_Counter;
 
 private:
 
 #if !defined(US_ATOMIC_OPTIMIZATION)
   mutable Mutex m_AtomicMtx;
 #endif
 };
 
 class MutexLockingStrategy
 {
 public:
 
   MutexLockingStrategy()
 #ifdef US_ENABLE_THREADING_SUPPORT
     : m_Mtx()
 #endif
   {}
 
   MutexLockingStrategy(const MutexLockingStrategy&)
 #ifdef US_ENABLE_THREADING_SUPPORT
     : m_Mtx()
 #endif
   {}
 
   class Lock;
   friend class Lock;
 
   class Lock
   {
   public:
 
 #ifdef US_ENABLE_THREADING_SUPPORT
     // Lock object
     explicit Lock(const MutexLockingStrategy& host) : m_Host(host)
     {
       m_Host.m_Mtx.Lock();
     }
 
     // Lock object
     explicit Lock(const MutexLockingStrategy* host) : m_Host(*host)
     {
       m_Host.m_Mtx.Lock();
     }
 
     // Unlock object
     ~Lock()
     {
       m_Host.m_Mtx.Unlock();
     }
 #else
     explicit Lock(const MutexLockingStrategy&) {}
     explicit Lock(const MutexLockingStrategy*) {}
 #endif
 
   private:
 
     // private by design
     Lock();
     Lock(const Lock&);
     Lock& operator=(const Lock&);
 #ifdef US_ENABLE_THREADING_SUPPORT
     const MutexLockingStrategy& m_Host;
 #endif
   };
 
 protected:
 
 #ifdef US_ENABLE_THREADING_SUPPORT
   mutable Mutex m_Mtx;
 #endif
 };
 
 class NoLockingStrategy
 {
 };
 
 US_END_NAMESPACE
 
 #include <usWaitCondition_p.h>
 
 US_BEGIN_NAMESPACE
 
 template<class LockingStrategy = MutexLockingStrategy,
          template<class Host> class WaitConditionStrategy = NoWaitCondition
         >
 class MultiThreaded : public LockingStrategy,
                       public WaitConditionStrategy<MultiThreaded<LockingStrategy, WaitConditionStrategy> >
 {
   friend class WaitConditionStrategy<MultiThreaded<LockingStrategy, WaitConditionStrategy> >;
 };
 
 US_END_NAMESPACE
 
 #endif // USTHREADINGMODEL_H
diff --git a/Modules/CppMicroServices/core/src/util/usUtils.cpp b/Modules/CppMicroServices/core/src/util/usUtils.cpp
index 4e01fb9ef0..507d6d2e70 100644
--- a/Modules/CppMicroServices/core/src/util/usUtils.cpp
+++ b/Modules/CppMicroServices/core/src/util/usUtils.cpp
@@ -1,350 +1,350 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usUtils_p.h"
 
 #include "usLog_p.h"
 #include "usModuleInfo.h"
 #include "usModuleSettings.h"
 
 #include <string>
 #include <cstdio>
 #include <cctype>
 #include <algorithm>
 #include <typeinfo>
 
 #ifdef US_PLATFORM_POSIX
   #include <cerrno>
   #include <cstring>
   #include <dlfcn.h>
   #include <dirent.h>
 #else
   #ifndef WIN32_LEAN_AND_MEAN
     #define WIN32_LEAN_AND_MEAN
   #endif
   #include <windows.h>
   #include <crtdbg.h>
   #include "dirent_win32.h"
 #endif
 
 //-------------------------------------------------------------------
 // Module auto-loading
 //-------------------------------------------------------------------
 
 namespace {
 
 #if !defined(US_PLATFORM_LINUX)
 std::string library_suffix()
 {
 #ifdef US_PLATFORM_WINDOWS
   return ".dll";
 #elif defined(US_PLATFORM_APPLE)
   return ".dylib";
 #else
   return ".so";
 #endif
 }
 #endif
 
 #ifdef US_PLATFORM_POSIX
 
 const char DIR_SEP = '/';
 
 bool load_impl(const std::string& modulePath)
 {
   void* handle = dlopen(modulePath.c_str(), RTLD_NOW | RTLD_LOCAL);
   if (handle == nullptr)
   {
     US_WARN << dlerror();
   }
   return (handle != nullptr);
 }
 
 #elif defined(US_PLATFORM_WINDOWS)
 
 const char DIR_SEP = '\\';
 
 bool load_impl(const std::string& modulePath)
 {
   void* handle = LoadLibrary(modulePath.c_str());
   if (handle == nullptr)
   {
     US_WARN << us::GetLastErrorStr();
   }
   return (handle != nullptr);
 }
 
 #else
 
   #ifdef US_ENABLE_AUTOLOADING_SUPPORT
     #error "Missing load_impl implementation for this platform."
   #else
 bool load_impl(const std::string&) { return false; }
   #endif
 
 #endif
 
 }
 
 US_BEGIN_NAMESPACE
 
 std::vector<std::string> AutoLoadModulesFromPath(const std::string& absoluteBasePath, const std::string& subDir)
 {
   std::vector<std::string> loadedModules;
 
   std::string loadPath = absoluteBasePath + DIR_SEP + subDir;
 
   DIR* dir = opendir(loadPath.c_str());
 #ifdef CMAKE_INTDIR
   // Try intermediate output directories
   if (dir == nullptr)
   {
     std::size_t indexOfLastSeparator = absoluteBasePath.find_last_of(DIR_SEP);
     if (indexOfLastSeparator != std::string::npos)
     {
       std::string intermediateDir = absoluteBasePath.substr(indexOfLastSeparator+1);
       bool equalSubDir = intermediateDir.size() == std::strlen(CMAKE_INTDIR);
       for (std::size_t i = 0; equalSubDir && i < intermediateDir.size(); ++i)
       {
         if (std::tolower(intermediateDir[i]) != std::tolower(CMAKE_INTDIR[i]))
         {
           equalSubDir = false;
         }
       }
       if (equalSubDir)
       {
         loadPath = absoluteBasePath.substr(0, indexOfLastSeparator+1) + subDir + DIR_SEP + CMAKE_INTDIR;
         dir = opendir(loadPath.c_str());
       }
     }
   }
 #endif
 
   if (dir != nullptr)
   {
     struct dirent *ent = nullptr;
     while ((ent = readdir(dir)) != nullptr)
     {
       bool loadFile = true;
 #ifdef _DIRENT_HAVE_D_TYPE
       if (ent->d_type != DT_UNKNOWN && ent->d_type != DT_REG)
       {
         loadFile = false;
       }
 #endif
 
       std::string entryFileName(ent->d_name);
 
       // On Linux, library file names can have version numbers appended. On other platforms, we
       // check the file ending. This could be refined for Linux in the future.
 #if !defined(US_PLATFORM_LINUX)
       if (entryFileName.rfind(library_suffix()) != (entryFileName.size() - library_suffix().size()))
       {
         loadFile = false;
       }
 #endif
       if (!loadFile) continue;
 
       std::string libPath = loadPath;
       if (!libPath.empty() && libPath.find_last_of(DIR_SEP) != libPath.size() -1)
       {
         libPath += DIR_SEP;
       }
       libPath += entryFileName;
       US_DEBUG << "Auto-loading module " << libPath;
 
       if (!load_impl(libPath))
       {
         US_WARN << "Auto-loading of module " << libPath << " failed.";
       }
       else
       {
         loadedModules.push_back(libPath);
       }
     }
     closedir(dir);
   }
   return loadedModules;
 }
 
 std::vector<std::string> AutoLoadModules(const ModuleInfo& moduleInfo)
 {
   std::vector<std::string> loadedModules;
 
   if (moduleInfo.autoLoadDir.empty())
   {
     return loadedModules;
   }
 
   ModuleSettings::PathList autoLoadPaths = ModuleSettings::GetAutoLoadPaths();
 
   std::size_t indexOfLastSeparator = moduleInfo.location.find_last_of(DIR_SEP);
   std::string moduleBasePath = moduleInfo.location.substr(0, indexOfLastSeparator);
 
   for (ModuleSettings::PathList::iterator i = autoLoadPaths.begin();
        i != autoLoadPaths.end(); ++i)
   {
     if (*i == ModuleSettings::CURRENT_MODULE_PATH())
     {
       // Load all modules from a directory located relative to this modules location
       // and named after this modules library name.
       *i = moduleBasePath;
     }
   }
 
   // We could have introduced a duplicate above, so remove it.
   std::sort(autoLoadPaths.begin(), autoLoadPaths.end());
   autoLoadPaths.erase(std::unique(autoLoadPaths.begin(), autoLoadPaths.end()), autoLoadPaths.end());
   for (ModuleSettings::PathList::iterator i = autoLoadPaths.begin();
        i != autoLoadPaths.end(); ++i)
   {
     if (i->empty()) continue;
     std::vector<std::string> paths = AutoLoadModulesFromPath(*i, moduleInfo.autoLoadDir);
     loadedModules.insert(loadedModules.end(), paths.begin(), paths.end());
   }
   return loadedModules;
 }
 
 US_END_NAMESPACE
 
 //-------------------------------------------------------------------
 // Error handling
 //-------------------------------------------------------------------
 
 US_BEGIN_NAMESPACE
 
 std::string GetLastErrorStr()
 {
 #ifdef US_PLATFORM_POSIX
   return std::string(strerror(errno));
 #else
   // Retrieve the system error message for the last-error code
   LPVOID lpMsgBuf;
   DWORD dw = GetLastError();
 
   FormatMessage(
     FORMAT_MESSAGE_ALLOCATE_BUFFER |
     FORMAT_MESSAGE_FROM_SYSTEM |
     FORMAT_MESSAGE_IGNORE_INSERTS,
     nullptr,
     dw,
     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
     (LPTSTR) &lpMsgBuf,
     0, nullptr );
 
   std::string errMsg((LPCTSTR)lpMsgBuf);
 
   LocalFree(lpMsgBuf);
 
   return errMsg;
 #endif
 }
 
 static MsgHandler handler = nullptr;
 
 MsgHandler installMsgHandler(MsgHandler h)
 {
   MsgHandler old = handler;
   handler = h;
   return old;
 }
 
 void message_output(MsgType msgType, const char *buf)
 {
   if (handler)
   {
     (*handler)(msgType, buf);
   }
   else
   {
     fprintf(stderr, "%s\n", buf);
     fflush(stderr);
   }
 
   if (msgType == ErrorMsg)
   {
   #if defined(_MSC_VER) && !defined(NDEBUG) && defined(_DEBUG) && defined(_CRT_ERROR)
     // get the current report mode
     int reportMode = _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_WNDW);
     _CrtSetReportMode(_CRT_ERROR, reportMode);
     int ret = _CrtDbgReport(_CRT_ERROR, __FILE__, __LINE__, CppMicroServices_VERSION_STR, buf);
     if (ret == 0  && reportMode & _CRTDBG_MODE_WNDW)
       return; // ignore
     else if (ret == 1)
       _CrtDbgBreak();
   #endif
 
   #ifdef US_PLATFORM_POSIX
     abort(); // trap; generates core dump
   #else
     exit(1); // goodbye cruel world
   #endif
   }
 }
 
 #ifdef US_HAVE_CXXABI_H
 #include <cxxabi.h>
 #endif
 
 US_Core_EXPORT ::std::string GetDemangledName(const ::std::type_info& typeInfo)
 {
   ::std::string result;
 #ifdef US_HAVE_CXXABI_H
   int status = 0;
   char* demangled = abi::__cxa_demangle(typeInfo.name(), nullptr, nullptr, &status);
   if (demangled && status == 0)
   {
     result = demangled;
     free(demangled);
   }
 #elif defined(US_PLATFORM_WINDOWS)
   const char* demangled = typeInfo.name();
   if (demangled != nullptr)
   {
     result = demangled;
     // remove "struct" qualifiers
     std::size_t pos = 0;
     while (pos != std::string::npos)
     {
       if ((pos = result.find("struct ", pos)) != std::string::npos)
       {
         result = result.substr(0, pos) + result.substr(pos + 7);
         pos += 8;
       }
     }
     // remove "class" qualifiers
     pos = 0;
     while (pos != std::string::npos)
     {
       if ((pos = result.find("class ", pos)) != std::string::npos)
       {
         result = result.substr(0, pos) + result.substr(pos + 6);
         pos += 7;
       }
     }
   }
 #else
   (void)typeInfo;
 #endif
   return result;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/src/util/usUtils_p.h b/Modules/CppMicroServices/core/src/util/usUtils_p.h
index 34e2bc3a00..216e0f84e0 100644
--- a/Modules/CppMicroServices/core/src/util/usUtils_p.h
+++ b/Modules/CppMicroServices/core/src/util/usUtils_p.h
@@ -1,53 +1,53 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USUTILS_H
 #define USUTILS_H
 
 #include <usCoreConfig.h>
 
 #include <string>
 #include <vector>
 
 //-------------------------------------------------------------------
 // Module auto-loading
 //-------------------------------------------------------------------
 
 US_BEGIN_NAMESPACE
 
 struct ModuleInfo;
 
 std::vector<std::string> AutoLoadModules(const ModuleInfo& moduleInfo);
 
 US_END_NAMESPACE
 
 //-------------------------------------------------------------------
 // Error handling
 //-------------------------------------------------------------------
 
 US_BEGIN_NAMESPACE
 
 US_Core_EXPORT std::string GetLastErrorStr();
 
 US_END_NAMESPACE
 
 #endif // USUTILS_H
diff --git a/Modules/CppMicroServices/core/src/util/usWaitCondition_p.h b/Modules/CppMicroServices/core/src/util/usWaitCondition_p.h
index f58201eb69..a020bd1391 100644
--- a/Modules/CppMicroServices/core/src/util/usWaitCondition_p.h
+++ b/Modules/CppMicroServices/core/src/util/usWaitCondition_p.h
@@ -1,378 +1,376 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USWAITCONDITION_P_H
 #define USWAITCONDITION_P_H
 
 #include "usCoreConfig.h"
 #include "usLog_p.h"
 #include "usUtils_p.h"
 #include "usThreads_p.h"
 
 #ifdef US_PLATFORM_POSIX
 #include <sys/time.h>
 #include <cerrno>
 #endif
 
 US_BEGIN_NAMESPACE
 
 /**
  * \brief A thread synchronization object used to suspend execution until some
  * condition on shared data is met.
  *
  * A thread calls Wait() to suspend its execution until the condition is
  * met. Each call to Notify() from an executing thread will then cause a single
  * waiting thread to be released.  A call to Notify() means, "signal
  * that the condition is true."  NotifyAll() releases all threads waiting on
  * the condition variable.
  *
  * The WaitCondition implementation is consistent with the standard
  * definition and use of condition variables in pthreads and other common
  * thread libraries.
  *
  * IMPORTANT: A condition variable always requires an associated mutex
  * object. The mutex object is used to avoid a dangerous race condition when
  * Wait() and Notify() are called simultaneously from two different
  * threads.
  *
  * On systems using pthreads, this implementation abstracts the
  * standard calls to the pthread condition variable.  On Win32
  * systems, there is no system provided condition variable.  This
  * class implements a condition variable using a critical section, a
  * semphore, an event and a number of counters.  The implementation is
  * almost an extract translation of the implementation presented by
  * Douglas C Schmidt and Irfan Pyarali in "Strategies for Implementing
- * POSIX Condition Variables on Win32". This article can be found at
- * http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
- *
+ * POSIX Condition Variables on Win32".
  */
 template<class MutexHost>
 class WaitCondition
 {
 public:
 
   WaitCondition();
   ~WaitCondition();
 
   bool Wait(unsigned long time = 0);
 
   /** Notify that the condition is true and release one waiting thread */
   void Notify();
 
   /** Notify that the condition is true and release all waiting threads */
   void NotifyAll();
 
 private:
 
   // purposely not implemented
   WaitCondition(const WaitCondition& other);
   const WaitCondition& operator=(const WaitCondition&);
 
 #ifdef US_ENABLE_THREADING_SUPPORT
 
   /** Suspend execution of this thread until the condition is signaled. The
    *  argument is a SimpleMutex object that must be locked prior to calling
    *  this method.  */
   bool Wait(Mutex& mutex, unsigned long time = 0);
 
   bool Wait(Mutex* mutex, unsigned long time = 0);
 
   #ifdef US_PLATFORM_POSIX
   pthread_cond_t m_WaitCondition;
   #else
 
   int m_NumberOfWaiters;                   // number of waiting threads
   CRITICAL_SECTION m_NumberOfWaitersLock;  // Serialize access to
   // m_NumberOfWaiters
 
   HANDLE m_Semaphore;                      // Semaphore to queue threads
   HANDLE m_WaitersAreDone;                 // Auto-reset event used by the
                                            // broadcast/signal thread to
                                            // wait for all the waiting
                                            // threads to wake up and
                                            // release the semaphore
 
   std::size_t m_WasNotifyAll;              // Keeps track of whether we
                                            // were broadcasting or signaling
   #endif
 
 #endif // US_ENABLE_THREADING_SUPPORT
 };
 
 template<class MutexHost>
 class NoWaitCondition
 {
 public:
   NoWaitCondition() {}
 private:
   // purposely not implemented
   NoWaitCondition(const NoWaitCondition& other);
   const NoWaitCondition& operator=(const NoWaitCondition&);
 };
 
 // ------------------------------------------------------------------------
 // WaitCondition implementation
 // ------------------------------------------------------------------------
 
 #ifdef US_ENABLE_THREADING_SUPPORT
 template<class MutexHost>
 WaitCondition<MutexHost>::WaitCondition()
 {
   #ifdef US_PLATFORM_POSIX
     pthread_cond_init(&m_WaitCondition, nullptr);
   #else
     m_NumberOfWaiters = 0;
     m_WasNotifyAll = 0;
     m_Semaphore = CreateSemaphore(0,            // no security
                                   0,            // initial value
                                   0x7fffffff,   // max count
                                   0);           // unnamed
     InitializeCriticalSection(&m_NumberOfWaitersLock);
     m_WaitersAreDone = CreateEvent(0,           // no security
                                    FALSE,       // auto-reset
                                    FALSE,       // non-signaled initially
                                    0 );         // unnamed
   #endif
 }
 
 template<class MutexHost>
 WaitCondition<MutexHost>::~WaitCondition()
 {
   #ifdef US_PLATFORM_POSIX
     pthread_cond_destroy(&m_WaitCondition);
   #else
     CloseHandle(m_Semaphore);
     CloseHandle(m_WaitersAreDone);
     DeleteCriticalSection(&m_NumberOfWaitersLock);
   #endif
 }
 
 template<class MutexHost>
 bool WaitCondition<MutexHost>::Wait(unsigned long time)
 {
   return this->Wait(static_cast<MutexHost*>(this)->m_Mtx, time);
 }
 
 template<class MutexHost>
 void WaitCondition<MutexHost>::Notify()
 {
   #ifdef US_PLATFORM_POSIX
     pthread_cond_signal(&m_WaitCondition);
   #else
     EnterCriticalSection(&m_NumberOfWaitersLock);
     int haveWaiters = m_NumberOfWaiters > 0;
     LeaveCriticalSection(&m_NumberOfWaitersLock);
 
     // if there were not any waiters, then this is a no-op
     if (haveWaiters)
     {
       ReleaseSemaphore(m_Semaphore, 1, 0);
     }
   #endif
 }
 
 template<class MutexHost>
 void WaitCondition<MutexHost>::NotifyAll()
 {
   #ifdef US_PLATFORM_POSIX
     pthread_cond_broadcast(&m_WaitCondition);
   #else
     // This is needed to ensure that m_NumberOfWaiters and m_WasNotifyAll are
     // consistent
     EnterCriticalSection(&m_NumberOfWaitersLock);
     int haveWaiters = 0;
 
     if (m_NumberOfWaiters > 0)
     {
       // We are broadcasting, even if there is just one waiter...
       // Record that we are broadcasting, which helps optimize Notify()
       // for the non-broadcast case
       m_WasNotifyAll = 1;
       haveWaiters = 1;
     }
 
     if (haveWaiters)
     {
       // Wake up all waiters atomically
       ReleaseSemaphore(m_Semaphore, m_NumberOfWaiters, 0);
 
       LeaveCriticalSection(&m_NumberOfWaitersLock);
 
       // Wait for all the awakened threads to acquire the counting
       // semaphore
       WaitForSingleObject(m_WaitersAreDone, INFINITE);
       // This assignment is ok, even without the m_NumberOfWaitersLock held
       // because no other waiter threads can wake up to access it.
       m_WasNotifyAll = 0;
     }
     else
     {
       LeaveCriticalSection(&m_NumberOfWaitersLock);
     }
   #endif
 }
 
 template<class MutexHost>
 bool WaitCondition<MutexHost>::Wait(Mutex* mutex, unsigned long timeoutMillis)
 {
   return Wait(*mutex, timeoutMillis);
 }
 
 template<class MutexHost>
 bool WaitCondition<MutexHost>::Wait(Mutex& mutex, unsigned long timeoutMillis)
 {
   #ifdef US_PLATFORM_POSIX
     struct timespec ts, * pts = nullptr;
     if (timeoutMillis)
     {
       pts = &ts;
       struct timeval tv;
       int error = gettimeofday(&tv, nullptr);
       if (error)
       {
         US_ERROR << "gettimeofday error: " << GetLastErrorStr();
         return false;
       }
       ts.tv_sec = tv.tv_sec;
       ts.tv_nsec = tv.tv_usec * 1000;
       ts.tv_sec += timeoutMillis / 1000;
       ts.tv_nsec += (timeoutMillis % 1000) * 1000000;
       ts.tv_sec += ts.tv_nsec / 1000000000;
       ts.tv_nsec = ts.tv_nsec % 1000000000;
     }
 
     if (pts)
     {
       int error = pthread_cond_timedwait(&m_WaitCondition, &mutex.m_Mtx, pts);
       if (error == 0)
       {
         return true;
       }
       else
       {
         if (error != ETIMEDOUT)
         {
           US_ERROR << "pthread_cond_timedwait error: " << GetLastErrorStr();
         }
         return false;
       }
     }
     else
     {
       int error = pthread_cond_wait(&m_WaitCondition, &mutex.m_Mtx);
       if (error)
       {
         US_ERROR << "pthread_cond_wait error: " << GetLastErrorStr();
         return false;
       }
       return true;
     }
 
   #else
 
     // Avoid race conditions
     EnterCriticalSection(&m_NumberOfWaitersLock);
     m_NumberOfWaiters++;
     LeaveCriticalSection(&m_NumberOfWaitersLock);
 
     DWORD dw;
     bool result = true;
 
     // This call atomically releases the mutex and waits on the
     // semaphore until signaled
     dw = SignalObjectAndWait(mutex.m_Mtx, m_Semaphore, timeoutMillis ? timeoutMillis : INFINITE, FALSE);
     if (dw == WAIT_TIMEOUT)
     {
       result = false;
     }
     else if (dw == WAIT_FAILED)
     {
       result = false;
       US_ERROR << "SignalObjectAndWait failed: " << GetLastErrorStr();
     }
 
     // Reacquire lock to avoid race conditions
     EnterCriticalSection(&m_NumberOfWaitersLock);
 
     // We're no longer waiting....
     m_NumberOfWaiters--;
 
     // Check to see if we're the last waiter after the broadcast
     int lastWaiter = m_WasNotifyAll && m_NumberOfWaiters == 0;
 
     LeaveCriticalSection(&m_NumberOfWaitersLock);
 
     // If we're the last waiter thread during this particular broadcast
     // then let the other threads proceed
     if (lastWaiter)
     {
       // This call atomically signals the m_WaitersAreDone event and waits
       // until it can acquire the external mutex.  This is required to
       // ensure fairness
       dw = SignalObjectAndWait(m_WaitersAreDone, mutex.m_Mtx,
                           INFINITE, FALSE);
       if (result && dw == WAIT_FAILED)
       {
         result = false;
         US_ERROR << "SignalObjectAndWait failed: " << GetLastErrorStr();
       }
     }
     else
     {
       // Always regain the external mutex since that's the guarentee we
       // give to our callers
       dw = WaitForSingleObject(mutex.m_Mtx, INFINITE);
       if (result && dw == WAIT_FAILED)
       {
         result = false;
         US_ERROR << "SignalObjectAndWait failed: " << GetLastErrorStr();
       }
     }
 
     return result;
   #endif
 }
 
 #else
 
 template<class MutexHost>
 WaitCondition<MutexHost>::WaitCondition() {}
 
 template<class MutexHost>
 WaitCondition<MutexHost>::~WaitCondition() {}
 
 template<class MutexHost>
 bool WaitCondition<MutexHost>::Wait(unsigned long)
 {
   return true;
 }
 
 template<class MutexHost>
 void WaitCondition<MutexHost>::Notify() {}
 
 template<class MutexHost>
 void WaitCondition<MutexHost>::NotifyAll() {}
 
 #endif
 
 US_END_NAMESPACE
 
 #endif // USWAITCONDITION_P_H
diff --git a/Modules/CppMicroServices/core/test/modules/libA/usTestModuleA.cpp b/Modules/CppMicroServices/core/test/modules/libA/usTestModuleA.cpp
index 556c1acb04..761c53c507 100644
--- a/Modules/CppMicroServices/core/test/modules/libA/usTestModuleA.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libA/usTestModuleA.cpp
@@ -1,77 +1,77 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usTestModuleAService.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usGlobalConfig.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleA : public TestModuleAService
 {
 
   TestModuleA(ModuleContext* mc)
   {
     US_INFO << "Registering TestModuleAService";
     sr = mc->RegisterService<TestModuleAService>(this);
   }
 
   void Unregister()
   {
     if (sr)
     {
       sr.Unregister();
       sr = 0;
     }
   }
 
 private:
 
   ServiceRegistration<TestModuleAService> sr;
 
 };
 
 class TestModuleAActivator : public ModuleActivator
 {
 public:
 
   TestModuleAActivator() : s(nullptr) {}
   ~TestModuleAActivator() override { delete s; }
 
   void Load(ModuleContext* context) override
   {
     s = new TestModuleA(context);
   }
 
   void Unload(ModuleContext*) override
   {
   }
 
 private:
 
   TestModuleA* s;
 };
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(TestModuleAActivator))
diff --git a/Modules/CppMicroServices/core/test/modules/libA/usTestModuleAService.h b/Modules/CppMicroServices/core/test/modules/libA/usTestModuleAService.h
index d7a5ec7dfb..a868692a01 100644
--- a/Modules/CppMicroServices/core/test/modules/libA/usTestModuleAService.h
+++ b/Modules/CppMicroServices/core/test/modules/libA/usTestModuleAService.h
@@ -1,38 +1,38 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTESTMODULEASERVICE_H
 #define USTESTMODULEASERVICE_H
 
 #include <usGlobalConfig.h>
 #include <usServiceInterface.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleAService
 {
   virtual ~TestModuleAService() {}
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTMODULEASERVICE_H
diff --git a/Modules/CppMicroServices/core/test/modules/libA2/usTestModuleA2.cpp b/Modules/CppMicroServices/core/test/modules/libA2/usTestModuleA2.cpp
index 13fc6a192a..77f546454a 100644
--- a/Modules/CppMicroServices/core/test/modules/libA2/usTestModuleA2.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libA2/usTestModuleA2.cpp
@@ -1,76 +1,76 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usTestModuleA2Service.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleA2 : public TestModuleA2Service
 {
 
   TestModuleA2(ModuleContext* mc)
   {
     US_INFO << "Registering TestModuleA2Service";
     sr = mc->RegisterService<TestModuleA2Service>(this);
   }
 
   void Unregister()
   {
     if (sr)
     {
       sr.Unregister();
     }
   }
 
 private:
 
   ServiceRegistration<TestModuleA2Service> sr;
 };
 
 class TestModuleA2Activator : public ModuleActivator
 {
 public:
 
   TestModuleA2Activator() : s(nullptr) {}
 
   ~TestModuleA2Activator() override { delete s; }
 
   void Load(ModuleContext* context) override
   {
     s = new TestModuleA2(context);
   }
 
   void Unload(ModuleContext* /*context*/) override
   {
     s->Unregister();
   }
 
 private:
 
   TestModuleA2* s;
 };
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(TestModuleA2Activator))
diff --git a/Modules/CppMicroServices/core/test/modules/libA2/usTestModuleA2Service.h b/Modules/CppMicroServices/core/test/modules/libA2/usTestModuleA2Service.h
index 8323712fd0..e975c4e817 100644
--- a/Modules/CppMicroServices/core/test/modules/libA2/usTestModuleA2Service.h
+++ b/Modules/CppMicroServices/core/test/modules/libA2/usTestModuleA2Service.h
@@ -1,38 +1,38 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTESTMODULEA2SERVICE_H
 #define USTESTMODULEA2SERVICE_H
 
 #include <usGlobalConfig.h>
 #include <usServiceInterface.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleA2Service
 {
   virtual ~TestModuleA2Service() {}
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTMODULEA2SERVICE_H
diff --git a/Modules/CppMicroServices/core/test/modules/libAL/libAL_1/usTestModuleAL_1.cpp b/Modules/CppMicroServices/core/test/modules/libAL/libAL_1/usTestModuleAL_1.cpp
index d2892ff0a8..aecb75f978 100644
--- a/Modules/CppMicroServices/core/test/modules/libAL/libAL_1/usTestModuleAL_1.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libAL/libAL_1/usTestModuleAL_1.cpp
@@ -1,30 +1,30 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usGlobalConfig.h>
 
 US_BEGIN_NAMESPACE
 
 struct US_ABI_EXPORT TestModuleAL_1_Dummy
 {
 };
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/test/modules/libAL/usTestModuleAL.cpp b/Modules/CppMicroServices/core/test/modules/libAL/usTestModuleAL.cpp
index d5d6b61c24..1d4f6923a2 100644
--- a/Modules/CppMicroServices/core/test/modules/libAL/usTestModuleAL.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libAL/usTestModuleAL.cpp
@@ -1,30 +1,30 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usGlobalConfig.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleAL_Dummy
 {
 };
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/test/modules/libAL2/libAL2_1/usTestModuleAL2_1.cpp b/Modules/CppMicroServices/core/test/modules/libAL2/libAL2_1/usTestModuleAL2_1.cpp
index 4f8dd1fcfc..ad5fcf9ee4 100644
--- a/Modules/CppMicroServices/core/test/modules/libAL2/libAL2_1/usTestModuleAL2_1.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libAL2/libAL2_1/usTestModuleAL2_1.cpp
@@ -1,30 +1,30 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usGlobalConfig.h>
 
 US_BEGIN_NAMESPACE
 
 struct US_ABI_EXPORT TestModuleAL2_1_Dummy
 {
 };
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/test/modules/libAL2/usTestModuleAL2.cpp b/Modules/CppMicroServices/core/test/modules/libAL2/usTestModuleAL2.cpp
index 139f18cc11..d27c443589 100644
--- a/Modules/CppMicroServices/core/test/modules/libAL2/usTestModuleAL2.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libAL2/usTestModuleAL2.cpp
@@ -1,30 +1,30 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usGlobalConfig.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleAL2_Dummy
 {
 };
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleB.cpp b/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleB.cpp
index afb095675b..e01576e1bc 100644
--- a/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleB.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleB.cpp
@@ -1,66 +1,66 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usTestModuleBService.h"
 
 #include <usModuleImport.h>
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleB : public TestModuleBService
 {
 
   TestModuleB(ModuleContext* mc)
   {
     US_INFO << "Registering TestModuleBService";
     mc->RegisterService<TestModuleBService>(this);
   }
 
 };
 
 class TestModuleBActivator : public ModuleActivator
 {
 public:
 
   TestModuleBActivator() : s(nullptr) {}
   ~TestModuleBActivator() override { delete s; }
 
   void Load(ModuleContext* context) override
   {
     s = new TestModuleB(context);
   }
 
   void Unload(ModuleContext*) override
   {
   }
 
 private:
 
   TestModuleB* s;
 };
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(TestModuleBActivator))
 
 US_IMPORT_MODULE(TestModuleImportedByB)
diff --git a/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleBService.h b/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleBService.h
index 084912a926..d3b82ce5ef 100644
--- a/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleBService.h
+++ b/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleBService.h
@@ -1,38 +1,38 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTESTMODULEBSERVICE_H
 #define USTESTMODULEBSERVICE_H
 
 #include <usGlobalConfig.h>
 #include <usServiceInterface.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleBService
 {
   virtual ~TestModuleBService() {}
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTMODULEASERVICE_H
diff --git a/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleImportedByB.cpp b/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleImportedByB.cpp
index 80f6a7bb91..25096f0609 100644
--- a/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleImportedByB.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libBWithStatic/usTestModuleImportedByB.cpp
@@ -1,64 +1,64 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usTestModuleBService.h"
 
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleImportedByB : public TestModuleBService
 {
 
   TestModuleImportedByB(ModuleContext* mc)
   {
     US_INFO << "Registering TestModuleImportedByB";
     mc->RegisterService<TestModuleBService>(this);
   }
 
 };
 
 class TestModuleImportedByBActivator : public ModuleActivator
 {
 public:
 
   TestModuleImportedByBActivator() : s(nullptr) {}
   ~TestModuleImportedByBActivator() override { delete s; }
 
   void Load(ModuleContext* context) override
   {
     s = new TestModuleImportedByB(context);
   }
 
   void Unload(ModuleContext*) override
   {
   }
 
 private:
 
   TestModuleImportedByB* s;
 };
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(TestModuleImportedByBActivator))
diff --git a/Modules/CppMicroServices/core/test/modules/libH/usTestModuleH.cpp b/Modules/CppMicroServices/core/test/modules/libH/usTestModuleH.cpp
index 1effdf75de..ad522d7766 100644
--- a/Modules/CppMicroServices/core/test/modules/libH/usTestModuleH.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libH/usTestModuleH.cpp
@@ -1,140 +1,140 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usServiceInterface.h>
 #include <usModuleActivator.h>
 #include <usServiceFactory.h>
 #include <usPrototypeServiceFactory.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 
 #include <iostream>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleH
 {
   virtual ~TestModuleH() {}
 };
 
 struct TestModuleH2
 {
   virtual ~TestModuleH2() {}
 };
 
 class TestProduct : public TestModuleH
 {
   // Module* caller;
 
 public:
 
   TestProduct(Module* /*caller*/)
     //: caller(caller)
   {}
 
 };
 
 class TestProduct2 : public TestProduct, public TestModuleH2
 {
 public:
 
   TestProduct2(Module* caller)
     : TestProduct(caller)
   {}
 
 };
 
 class TestModuleHPrototypeServiceFactory : public PrototypeServiceFactory
 {
   std::map<long, std::list<TestProduct2*> > fcbind;   // Map calling module with implementation
 
 public:
 
   InterfaceMap GetService(Module* caller, const ServiceRegistrationBase& /*sReg*/) override
   {
     std::cout << "GetService (prototype) in H" << std::endl;
     TestProduct2* product = new TestProduct2(caller);
     fcbind[caller->GetModuleId()].push_back(product);
     return MakeInterfaceMap<TestModuleH,TestModuleH2>(product);
   }
 
   void UngetService(Module* caller, const ServiceRegistrationBase& /*sReg*/, const InterfaceMap& service) override
   {
     TestProduct2* product = dynamic_cast<TestProduct2*>(ExtractInterface<TestModuleH>(service));
     delete product;
     fcbind[caller->GetModuleId()].remove(product);
   }
 
 };
 
 
 class TestModuleHActivator : public ModuleActivator, public ServiceFactory
 {
   std::string thisServiceName;
   ServiceRegistration<TestModuleH> factoryService;
   ServiceRegistration<TestModuleH,TestModuleH2> prototypeFactoryService;
   ModuleContext* mc;
 
   std::map<long, TestProduct*> fcbind;   // Map calling module with implementation
   TestModuleHPrototypeServiceFactory prototypeFactory;
 
 public:
 
   TestModuleHActivator()
     : thisServiceName(us_service_interface_iid<TestModuleH>())
     , mc(nullptr)
   {}
 
   void Load(ModuleContext* mc) override
   {
     std::cout << "start in H" << std::endl;
     this->mc = mc;
     factoryService = mc->RegisterService<TestModuleH>(this);
     prototypeFactoryService = mc->RegisterService<TestModuleH,TestModuleH2>(static_cast<ServiceFactory*>(&prototypeFactory));
   }
 
   void Unload(ModuleContext* /*mc*/) override
   {
     factoryService.Unregister();
   }
 
   InterfaceMap GetService(Module* caller, const ServiceRegistrationBase& /*sReg*/) override
   {
     std::cout << "GetService in H" << std::endl;
     TestProduct* product = new TestProduct(caller);
     fcbind.insert(std::make_pair(caller->GetModuleId(), product));
     return MakeInterfaceMap<TestModuleH>(product);
   }
 
   void UngetService(Module* caller, const ServiceRegistrationBase& /*sReg*/, const InterfaceMap& service) override
   {
     TestModuleH* product = ExtractInterface<TestModuleH>(service);
     delete product;
     fcbind.erase(caller->GetModuleId());
   }
 
 };
 
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(us::TestModuleHActivator)
diff --git a/Modules/CppMicroServices/core/test/modules/libM/usTestModuleM.cpp b/Modules/CppMicroServices/core/test/modules/libM/usTestModuleM.cpp
index aef358ac73..74340ba8b4 100644
--- a/Modules/CppMicroServices/core/test/modules/libM/usTestModuleM.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libM/usTestModuleM.cpp
@@ -1,43 +1,43 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModuleActivator.h>
 
 US_BEGIN_NAMESPACE
 
 class TestModuleMActivator : public ModuleActivator
 {
 public:
 
   void Load(ModuleContext*) override
   {
   }
 
   void Unload(ModuleContext*) override
   {
   }
 
 };
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(TestModuleMActivator))
diff --git a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleS.cpp b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleS.cpp
index f8d444d48b..f3fcce94f9 100644
--- a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleS.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleS.cpp
@@ -1,142 +1,142 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "../../usServiceControlInterface.h"
 
 #include "usTestModuleSService0.h"
 #include "usTestModuleSService1.h"
 #include "usTestModuleSService2.h"
 #include "usTestModuleSService3.h"
 
 #include <usServiceRegistration.h>
 #include <usModuleContext.h>
 #include <usModuleActivator.h>
 
 
 US_BEGIN_NAMESPACE
 
 class TestModuleS : public ServiceControlInterface,
                     public TestModuleSService0,
                     public TestModuleSService1,
                     public TestModuleSService2,
                     public TestModuleSService3
 {
 
 public:
 
   TestModuleS(ModuleContext* mc)
     : mc(mc)
   {
     for(int i = 0; i <= 3; ++i)
     {
       servregs.push_back(ServiceRegistrationU());
     }
     sreg = mc->RegisterService<TestModuleSService0>(this);
     sciReg = mc->RegisterService<ServiceControlInterface>(this);
   }
 
   virtual const char* GetNameOfClass() const
   {
     return "TestModuleS";
   }
 
   void ServiceControl(int offset, const std::string& operation, int ranking) override
   {
     if (0 <= offset && offset <= 3)
     {
       if (operation == "register")
       {
         if (!servregs[offset])
         {
           std::stringstream servicename;
           servicename << SERVICE << offset;
           InterfaceMap ifm;
           ifm.insert(std::make_pair(servicename.str(), static_cast<void*>(this)));
           ServiceProperties props;
           props.insert(std::make_pair(ServiceConstants::SERVICE_RANKING(), Any(ranking)));
           servregs[offset] = mc->RegisterService(ifm, props);
         }
       }
       if (operation == "unregister")
       {
         if (servregs[offset])
         {
           ServiceRegistrationU sr1 = servregs[offset];
           sr1.Unregister();
           servregs[offset] = 0;
         }
       }
     }
   }
 
   void Unregister()
   {
     if (sreg)
     {
       sreg.Unregister();
     }
     if (sciReg)
     {
       sciReg.Unregister();
     }
   }
 
 private:
 
   static const std::string SERVICE; // = "us::TestModuleSService"
 
   ModuleContext* mc;
   std::vector<ServiceRegistrationU> servregs;
   ServiceRegistration<TestModuleSService0> sreg;
   ServiceRegistration<ServiceControlInterface> sciReg;
 };
 
 const std::string TestModuleS::SERVICE = "us::TestModuleSService";
 
 class TestModuleSActivator : public ModuleActivator
 {
 
 public:
 
   TestModuleSActivator() : s(nullptr) {}
   ~TestModuleSActivator() override { delete s; }
 
   void Load(ModuleContext* context) override
   {
     s = new TestModuleS(context);
   }
 
   void Unload(ModuleContext* /*context*/) override
   {
   #ifndef US_BUILD_SHARED_LIBS
     s->Unregister();
   #endif
   }
 
 private:
 
   TestModuleS* s;
 
 };
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(TestModuleSActivator))
diff --git a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService0.h b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService0.h
index c37a109410..44dc7f1d99 100644
--- a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService0.h
+++ b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService0.h
@@ -1,37 +1,37 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTESTMODULESSERVICE0_H
 #define USTESTMODULESSERVICE0_H
 
 #include <usServiceInterface.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleSService0
 {
   virtual ~TestModuleSService0() {}
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTMODULESSERVICE0_H
diff --git a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService1.h b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService1.h
index ac37600bfd..ffeb2df967 100644
--- a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService1.h
+++ b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService1.h
@@ -1,37 +1,37 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTESTMODULESSERVICE1_H
 #define USTESTMODULESSERVICE1_H
 
 #include <usServiceInterface.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleSService1
 {
   virtual ~TestModuleSService1() {}
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTMODULESSERVICE1_H
diff --git a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService2.h b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService2.h
index c43989d016..c03f19853a 100644
--- a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService2.h
+++ b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService2.h
@@ -1,37 +1,37 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTESTMODULESSERVICE2_H
 #define USTESTMODULESSERVICE2_H
 
 #include <usServiceInterface.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleSService2
 {
   virtual ~TestModuleSService2() {}
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTMODULESSERVICE0_H
diff --git a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService3.h b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService3.h
index 2be388b717..76b31a3392 100644
--- a/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService3.h
+++ b/Modules/CppMicroServices/core/test/modules/libS/usTestModuleSService3.h
@@ -1,37 +1,37 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USTESTMODULESSERVICE3_H
 #define USTESTMODULESSERVICE3_H
 
 #include <usServiceInterface.h>
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleSService3
 {
   virtual ~TestModuleSService3() {}
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTMODULESSERVICE0_H
diff --git a/Modules/CppMicroServices/core/test/modules/libSL1/usActivatorSL1.cpp b/Modules/CppMicroServices/core/test/modules/libSL1/usActivatorSL1.cpp
index d6d38ba2e4..8cd577392b 100644
--- a/Modules/CppMicroServices/core/test/modules/libSL1/usActivatorSL1.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libSL1/usActivatorSL1.cpp
@@ -1,106 +1,106 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModuleActivator.h>
 #include <usModulePropsInterface.h>
 
 #include <usServiceTracker.h>
 #include <usServiceTrackerCustomizer.h>
 
 #include "usFooService.h"
 
 US_BEGIN_NAMESPACE
 
 class ActivatorSL1 :
     public ModuleActivator, public ModulePropsInterface,
     public ServiceTrackerCustomizer<FooService>
 {
 
 public:
 
   ActivatorSL1()
     : tracker(nullptr), context(nullptr)
   {
 
   }
 
   ~ActivatorSL1() override
   {
     delete tracker;
   }
 
   void Load(ModuleContext* context) override
   {
     this->context = context;
 
     InterfaceMap im = MakeInterfaceMap<ModulePropsInterface>(this);
     im.insert(std::make_pair(std::string("ActivatorSL1"), this));
     sr = context->RegisterService(im);
 
     delete tracker;
     tracker = new FooTracker(context, this);
     tracker->Open();
   }
 
   void Unload(ModuleContext* /*context*/) override
   {
     tracker->Close();
   }
 
   const Properties& GetProperties() const override
   {
     return props;
   }
 
   FooService* AddingService(const ServiceReferenceType& reference) override
   {
     props["serviceAdded"] = true;
 
     FooService* fooService = context->GetService<FooService>(reference);
     fooService->foo();
     return fooService;
   }
 
   void ModifiedService(const ServiceReferenceType& /*reference*/, FooService* /*service*/) override
   {}
 
   void RemovedService(const ServiceReferenceType& /*reference*/, FooService* /*service*/) override
   {
     props["serviceRemoved"] = true;
   }
 
 private:
 
   ModulePropsInterface::Properties props;
 
   ServiceRegistrationU sr;
 
   typedef ServiceTracker<FooService> FooTracker;
 
   FooTracker* tracker;
   ModuleContext* context;
 
 }; // ActivatorSL1
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(ActivatorSL1))
diff --git a/Modules/CppMicroServices/core/test/modules/libSL1/usFooService.h b/Modules/CppMicroServices/core/test/modules/libSL1/usFooService.h
index 3e3d12096d..5dafcd78a6 100644
--- a/Modules/CppMicroServices/core/test/modules/libSL1/usFooService.h
+++ b/Modules/CppMicroServices/core/test/modules/libSL1/usFooService.h
@@ -1,38 +1,38 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USFOOSERVICE_H
 #define USFOOSERVICE_H
 
 #include <usServiceInterface.h>
 
 US_BEGIN_NAMESPACE
 
 struct FooService
 {
   virtual ~FooService() {}
   virtual void foo() = 0;
 };
 
 US_END_NAMESPACE
 
 #endif // USFOOSERVICE_H
diff --git a/Modules/CppMicroServices/core/test/modules/libSL3/usActivatorSL3.cpp b/Modules/CppMicroServices/core/test/modules/libSL3/usActivatorSL3.cpp
index e1b49c68e7..4fc9a59fef 100644
--- a/Modules/CppMicroServices/core/test/modules/libSL3/usActivatorSL3.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libSL3/usActivatorSL3.cpp
@@ -1,99 +1,99 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModuleActivator.h>
 #include <usModulePropsInterface.h>
 #include <usServiceTracker.h>
 #include <usServiceTrackerCustomizer.h>
 #include <usFooService.h>
 
 US_BEGIN_NAMESPACE
 
 class ActivatorSL3 :
     public ModuleActivator, public ModulePropsInterface,
     public ServiceTrackerCustomizer<FooService>
 {
 
 public:
 
   ActivatorSL3() : tracker(nullptr), context(nullptr) {}
 
   ~ActivatorSL3() override
   { delete tracker; }
 
   void Load(ModuleContext* context) override
   {
     this->context = context;
 
     InterfaceMap im = MakeInterfaceMap<ModulePropsInterface>(this);
     im.insert(std::make_pair(std::string("ActivatorSL3"), this));
     sr = context->RegisterService(im);
     delete tracker;
     tracker = new FooTracker(context, this);
     tracker->Open();
   }
 
   void Unload(ModuleContext* /*context*/) override
   {
     tracker->Close();
   }
 
   const ModulePropsInterface::Properties& GetProperties() const override
   {
     return props;
   }
 
   FooService* AddingService(const ServiceReferenceType& reference) override
   {
     props["serviceAdded"] = true;
     US_INFO << "SL3: Adding reference =" << reference;
 
     FooService* fooService = context->GetService(reference);
     fooService->foo();
     return fooService;
   }
 
   void ModifiedService(const ServiceReferenceType& /*reference*/, FooService* /*service*/) override
   {
 
   }
 
   void RemovedService(const ServiceReferenceType& reference, FooService* /*service*/) override
   {
     props["serviceRemoved"] = true;
     US_INFO << "SL3: Removing reference =" << reference;
   }
 
 private:
 
   typedef ServiceTracker<FooService> FooTracker;
   FooTracker* tracker;
   ModuleContext* context;
 
   ServiceRegistrationU sr;
 
   ModulePropsInterface::Properties props;
 
 };
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(ActivatorSL3))
diff --git a/Modules/CppMicroServices/core/test/modules/libSL4/usActivatorSL4.cpp b/Modules/CppMicroServices/core/test/modules/libSL4/usActivatorSL4.cpp
index e31548d537..f1e5a1c52a 100644
--- a/Modules/CppMicroServices/core/test/modules/libSL4/usActivatorSL4.cpp
+++ b/Modules/CppMicroServices/core/test/modules/libSL4/usActivatorSL4.cpp
@@ -1,64 +1,64 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usServiceRegistration.h>
 
 #include <usFooService.h>
 
 US_BEGIN_NAMESPACE
 
 class ActivatorSL4 :
   public ModuleActivator, public FooService
 {
 
 public:
 
   ~ActivatorSL4() override
   {
 
   }
 
   void foo() override
   {
     US_INFO << "TestModuleSL4: Doing foo";
   }
 
   void Load(ModuleContext* context) override
   {
     sr = context->RegisterService<FooService>(this);
     US_INFO << "TestModuleSL4: Registered " << sr;
   }
 
   void Unload(ModuleContext* /*context*/) override
   {
   }
 
 private:
 
   ServiceRegistration<FooService> sr;
 };
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(US_PREPEND_NAMESPACE(ActivatorSL4))
diff --git a/Modules/CppMicroServices/core/test/usAnyTest.cpp b/Modules/CppMicroServices/core/test/usAnyTest.cpp
index 137db91e44..6b6406eaf2 100644
--- a/Modules/CppMicroServices/core/test/usAnyTest.cpp
+++ b/Modules/CppMicroServices/core/test/usAnyTest.cpp
@@ -1,147 +1,147 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usAny.h>
 
 #include "usTestingMacros.h"
 
 #include <limits>
 
 US_USE_NAMESPACE
 
 int usAnyTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("AnyTest");
 
   Any anyBool = true;
   US_TEST_CONDITION(anyBool.Type() == typeid(bool), "Any[bool].Type()")
   US_TEST_CONDITION(any_cast<bool>(anyBool) == true, "any_cast<bool>()")
   US_TEST_CONDITION(anyBool.ToString() == "1", "Any[bool].ToString()")
   US_TEST_CONDITION(anyBool.ToJSON() == "true", "Any[bool].ToJSON()")
   anyBool = false;
   US_TEST_CONDITION(anyBool.ToString() == "0", "Any[bool].ToString()")
   US_TEST_CONDITION(anyBool.ToJSON() == "false", "Any[bool].ToJSON()")
 
   Any anyInt = 13;
   US_TEST_CONDITION(anyInt.Type() == typeid(int), "Any[int].Type()")
   US_TEST_CONDITION(any_cast<int>(anyInt) == 13, "any_cast<int>()")
   US_TEST_CONDITION(anyInt.ToString() == "13", "Any[int].ToString()")
   US_TEST_CONDITION(anyInt.ToJSON() == "13", "Any[int].ToJSON()")
 
   Any anyChar = 'a';
   US_TEST_CONDITION(anyChar.Type() == typeid(char), "Any[char].Type()")
   US_TEST_CONDITION(any_cast<char>(anyChar) == 'a', "any_cast<char>()")
   US_TEST_CONDITION(anyChar.ToString() == "a", "Any[char].ToString()")
   US_TEST_CONDITION(anyChar.ToJSON() == "a", "Any[char].ToJSON()")
 
   Any anyFloat = 0.2f;
   US_TEST_CONDITION(anyFloat.Type() == typeid(float), "Any[float].Type()")
   US_TEST_CONDITION(any_cast<float>(anyFloat) - 0.2f < std::numeric_limits<float>::epsilon(), "any_cast<float>()")
   US_TEST_CONDITION(anyFloat.ToString() == "0.2", "Any[float].ToString()")
   US_TEST_CONDITION(anyFloat.ToString() == "0.2", "Any[float].ToJSON()")
 
   Any anyDouble = 0.5;
   US_TEST_CONDITION(anyDouble.Type() == typeid(double), "Any[double].Type()")
   US_TEST_CONDITION(any_cast<double>(anyDouble) - 0.5 < std::numeric_limits<double>::epsilon(), "any_cast<double>()")
   US_TEST_CONDITION(anyDouble.ToString() == "0.5", "Any[double].ToString()")
   US_TEST_CONDITION(anyDouble.ToString() == "0.5", "Any[double].ToJSON()")
 
   Any anyString = std::string("hello");
   US_TEST_CONDITION(anyString.Type() == typeid(std::string), "Any[std::string].Type()")
   US_TEST_CONDITION(any_cast<std::string>(anyString) == "hello", "any_cast<std::string>()")
   US_TEST_CONDITION(anyString.ToString() == "hello", "Any[std::string].ToString()")
   US_TEST_CONDITION(anyString.ToJSON() == "\"hello\"", "Any[std::string].ToJSON()")
 
   std::vector<int> vecInts;
   vecInts.push_back(1);
   vecInts.push_back(2);
   Any anyVectorOfInts = vecInts;
   US_TEST_CONDITION(anyVectorOfInts.Type() == typeid(std::vector<int>), "Any[std::vector<int>].Type()")
   US_TEST_CONDITION(any_cast<std::vector<int> >(anyVectorOfInts) == vecInts, "any_cast<std::vector<int>>()")
   US_TEST_CONDITION(anyVectorOfInts.ToString() == "[1,2]", "Any[std::vector<int>].ToString()")
   US_TEST_CONDITION(anyVectorOfInts.ToJSON() == "[1,2]", "Any[std::vector<int>].ToJSON()")
 
   std::list<int> listInts;
   listInts.push_back(1);
   listInts.push_back(2);
   Any anyListOfInts = listInts;
   US_TEST_CONDITION(anyListOfInts.Type() == typeid(std::list<int>), "Any[std::list<int>].Type()")
   US_TEST_CONDITION(any_cast<std::list<int> >(anyListOfInts) == listInts, "any_cast<std::list<int>>()")
   US_TEST_CONDITION(anyListOfInts.ToString() == "[1,2]", "Any[std::list<int>].ToString()")
   US_TEST_CONDITION(anyListOfInts.ToJSON() == "[1,2]", "Any[std::list<int>].ToJSON()")
 
   std::set<int> setInts;
   setInts.insert(1);
   setInts.insert(2);
   Any anySetOfInts = setInts;
   US_TEST_CONDITION(anySetOfInts.Type() == typeid(std::set<int>), "Any[std::set<int>].Type()")
   US_TEST_CONDITION(any_cast<std::set<int> >(anySetOfInts) == setInts, "any_cast<std::set<int>>()")
   US_TEST_CONDITION(anySetOfInts.ToString() == "[1,2]", "Any[std::set<int>].ToString()")
   US_TEST_CONDITION(anySetOfInts.ToJSON() == "[1,2]", "Any[std::set<int>].ToJSON()")
 
   std::vector<Any> vecAny;
   vecAny.push_back(1);
   vecAny.push_back(std::string("hello"));
   Any anyVectorOfAnys = vecAny;
   US_TEST_CONDITION(anyVectorOfAnys.Type() == typeid(std::vector<Any>), "Any[std::vector<Any>].Type()")
   US_TEST_CONDITION(anyVectorOfAnys.ToString() == "[1,hello]", "Any[std::vector<Any>].ToString()")
   US_TEST_CONDITION(anyVectorOfAnys.ToJSON() == "[1,\"hello\"]", "Any[std::vector<Any>].ToJSON()")
 
   std::list<Any> listAny;
   listAny.push_back(1);
   listAny.push_back(std::string("hello"));
   Any anyListOfAnys = listAny;
   US_TEST_CONDITION(anyListOfAnys.Type() == typeid(std::list<Any>), "Any[std::list<Any>].Type()")
   US_TEST_CONDITION(anyListOfAnys.ToString() == "[1,hello]", "Any[std::list<Any>].ToString()")
   US_TEST_CONDITION(anyListOfAnys.ToJSON() == "[1,\"hello\"]", "Any[std::list<Any>].ToJSON()")
 
   std::map<std::string, int> map1;
   map1["one"] = 1;
   map1["two"] = 2;
   Any anyMap1 = map1;
   US_TEST_CONDITION(anyMap1.Type() == typeid(std::map<std::string, int>), "Any[std::map<std::string,int>].Type()")
   US_TEST_CONDITION((any_cast<std::map<std::string, int> >(anyMap1) == map1), "any_cast<std::map<std::string,int>>()")
   US_TEST_CONDITION(anyMap1.ToString() == "{one : 1, two : 2}", "Any[std::map<std::string,int>].ToString()")
   US_TEST_CONDITION(anyMap1.ToJSON() == "{\"one\" : 1, \"two\" : 2}", "Any[std::map<std::string,int>].ToJSON()")
 
   std::map<int, Any> map2;
   map2[1] = 0.3;
   map2[3] = std::string("bye");
   Any anyMap2 = map2;
   US_TEST_CONDITION(anyMap2.Type() == typeid(std::map<int, Any>), "Any[std::map<int,Any>].Type()")
   US_TEST_CONDITION(anyMap2.ToString() == "{1 : 0.3, 3 : bye}", "Any[std::map<int,Any>].ToString()")
   US_TEST_CONDITION(anyMap2.ToJSON() == "{\"1\" : 0.3, \"3\" : \"bye\"}", "Any[std::map<int,Any>].ToJSON()")
 
   std::map<std::string, Any> map3;
   map3["number"] = 5;
   std::vector<int> numbers;
   numbers.push_back(9);
   numbers.push_back(8);
   numbers.push_back(7);
   map3["vector"] = numbers;
   map3["map"] = map2;
   Any anyMap3 = map3;
   US_TEST_CONDITION(anyMap3.Type() == typeid(std::map<std::string, Any>), "Any[std::map<std::string,Any>].Type()")
   US_TEST_CONDITION(anyMap3.ToString() == "{map : {1 : 0.3, 3 : bye}, number : 5, vector : [9,8,7]}", "Any[std::map<std::string,Any>].ToString()")
   US_TEST_CONDITION(anyMap3.ToJSON() == "{\"map\" : {\"1\" : 0.3, \"3\" : \"bye\"}, \"number\" : 5, \"vector\" : [9,8,7]}", "Any[std::map<std::string,Any>].ToJSON()")
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usLDAPFilterTest.cpp b/Modules/CppMicroServices/core/test/usLDAPFilterTest.cpp
index 9e9f74ea2f..e9149e2a2c 100644
--- a/Modules/CppMicroServices/core/test/usLDAPFilterTest.cpp
+++ b/Modules/CppMicroServices/core/test/usLDAPFilterTest.cpp
@@ -1,169 +1,169 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usLDAPFilter.h>
 #include <usLDAPProp.h>
 
 #include "usTestingMacros.h"
 
 #include <stdexcept>
 
 US_USE_NAMESPACE
 
 int TestParsing()
 {
   // WELL FORMED Expr
   try
   {
     US_TEST_OUTPUT(<< "Parsing (cn=Babs Jensen)")
     LDAPFilter ldap( "(cn=Babs Jensen)" );
     US_TEST_OUTPUT(<< "Parsing (!(cn=Tim Howes))")
     ldap = LDAPFilter( "(!(cn=Tim Howes))" );
     US_TEST_OUTPUT(<< "Parsing " << std::string("(&(") + ServiceConstants::OBJECTCLASS() + "=Person)(|(sn=Jensen)(cn=Babs J*)))")
     ldap = LDAPFilter( std::string("(&(") + ServiceConstants::OBJECTCLASS() + "=Person)(|(sn=Jensen)(cn=Babs J*)))" );
     US_TEST_OUTPUT(<< "Parsing (o=univ*of*mich*)")
     ldap = LDAPFilter( "(o=univ*of*mich*)" );
   }
   catch (const std::invalid_argument& e)
   {
     US_TEST_OUTPUT(<< e.what());
     return EXIT_FAILURE;
   }
 
 
   // MALFORMED Expr
   try
   {
     US_TEST_OUTPUT( << "Parsing malformed expr: cn=Babs Jensen)")
     LDAPFilter ldap( "cn=Babs Jensen)" );
     return EXIT_FAILURE;
   }
   catch (const std::invalid_argument&)
   {
   }
 
   return EXIT_SUCCESS;
 }
 
 
 int TestEvaluate()
 {
   // EVALUATE
   try
   {
     LDAPFilter ldap( "(Cn=Babs Jensen)" );
     ServiceProperties props;
     bool eval = false;
 
     // Several values
     props["cn"] = std::string("Babs Jensen");
     props["unused"] = std::string("Jansen");
     US_TEST_OUTPUT(<< "Evaluating expr: " << ldap.ToString())
     eval = ldap.Match(props);
     if (!eval)
     {
       return EXIT_FAILURE;
     }
 
     // WILDCARD
     ldap = LDAPFilter( "(cn=Babs *)" );
     props.clear();
     props["cn"] = std::string("Babs Jensen");
     US_TEST_OUTPUT(<< "Evaluating wildcard expr: " << ldap.ToString())
     eval = ldap.Match(props);
     if ( !eval )
     {
       return EXIT_FAILURE;
     }
 
     // NOT FOUND
     ldap = LDAPFilter( "(cn=Babs *)" );
     props.clear();
     props["unused"] = std::string("New");
     US_TEST_OUTPUT(<< "Expr not found test: " << ldap.ToString())
     eval = ldap.Match(props);
     if ( eval )
     {
       return EXIT_FAILURE;
     }
 
     // std::vector with integer values
     ldap = LDAPFilter( "  ( |(cn=Babs *)(sn=1) )" );
     props.clear();
     std::vector<Any> list;
     list.push_back(std::string("Babs Jensen"));
     list.push_back(std::string("1"));
     props["sn"] = list;
     US_TEST_OUTPUT(<< "Evaluating vector expr: " << ldap.ToString())
     eval = ldap.Match(props);
     if (!eval)
     {
       return EXIT_FAILURE;
     }
 
     // wrong case
     ldap = LDAPFilter( "(cN=Babs *)" );
     props.clear();
     props["cn"] = std::string("Babs Jensen");
     US_TEST_OUTPUT(<< "Evaluating case sensitive expr: " << ldap.ToString())
     eval = ldap.MatchCase(props);
     if (eval)
     {
       return EXIT_FAILURE;
     }
   }
   catch (const std::invalid_argument& e)
   {
     US_TEST_OUTPUT( << e.what() )
     return EXIT_FAILURE;
   }
 
   return EXIT_SUCCESS;
 }
 
 void TestLDAPExpressions()
 {
   LDAPFilter filter(
         LDAPProp("bla") == "jo" && !(LDAPProp("ha") == 1) &&
         (LDAPProp("presence") || !LDAPProp("absence")) &&
         LDAPProp("le") <= 4.1 && LDAPProp("ge") >= -3 &&
         LDAPProp("approx").Approx("Approx")
         );
   const std::string filterStr = "(&(&(&(&(&(bla=jo)(!(ha=1)))(|(presence=*)(!(absence=*))))(le<=4.1))(ge>=-3))(approx~=Approx))";
   US_TEST_CONDITION(filter.ToString() == filterStr, "test generated filter string")
 
   std::string emptyValue;
   std::string someValue = "some";
   std::string filter1 = LDAPProp("key2") == someValue && LDAPProp("key3");
   std::string filter2 = LDAPProp("key2") == someValue && (LDAPProp("key1") == emptyValue || LDAPProp("key3"));
   US_TEST_CONDITION(filter1 == filter2, "test null expressions")
 }
 
 int usLDAPFilterTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("LDAPFilterTest");
 
   TestLDAPExpressions();
   US_TEST_CONDITION(TestParsing() == EXIT_SUCCESS, "Parsing LDAP expressions: ")
   US_TEST_CONDITION(TestEvaluate() == EXIT_SUCCESS, "Evaluating LDAP expressions: ")
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usLogTest.cpp b/Modules/CppMicroServices/core/test/usLogTest.cpp
index ea9b601b04..bfde61535a 100644
--- a/Modules/CppMicroServices/core/test/usLogTest.cpp
+++ b/Modules/CppMicroServices/core/test/usLogTest.cpp
@@ -1,177 +1,177 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usLog_p.h>
 
 #include "usTestingMacros.h"
 
 US_USE_NAMESPACE
 
 static int lastMsgType = -1;
 static std::string lastMsg;
 
 void handleMessages(MsgType type, const char* msg)
 {
   lastMsgType = type;
   lastMsg.assign(msg);
 }
 
 void resetLastMsg()
 {
   lastMsgType = -1;
   lastMsg.clear();
 }
 
 void logMsg(MsgType msgType, int logLevel)
 {
   resetLastMsg();
   std::string logMsg;
   switch (msgType)
   {
   case DebugMsg:
   {
     logMsg = "Debug msg";
     US_DEBUG << logMsg;
 #if !defined(US_ENABLE_DEBUG_OUTPUT)
     if (logLevel == DebugMsg) logLevel = InfoMsg;
 #endif
     break;
   }
   case InfoMsg:
   {
     logMsg = "Info msg";
     US_INFO << logMsg;
     break;
   }
   case WarningMsg:
   {
     logMsg = "Warning msg";
     US_WARN << logMsg;
     break;
   }
   case ErrorMsg:
   {
     // Skip error messages
     logLevel = 100;
     break;
   }
   }
 
   if (msgType >= logLevel)
   {
     US_TEST_CONDITION(lastMsgType == msgType && lastMsg.find(logMsg) != std::string::npos, "Testing for logged message")
   }
   else
   {
     US_TEST_CONDITION(lastMsgType == -1 && lastMsg.empty(), "Testing for skipped log message")
   }
 }
 
 void testLogMessages()
 {
   // Use the default message handler
   installMsgHandler(nullptr);
   {
     US_DEBUG << "Msg";
     US_DEBUG(false) << "Msg";
     US_INFO << "Msg";
     US_INFO(false) << "Msg";
     US_WARN << "Msg";
     US_WARN(false) << "Msg";
   }
   US_TEST_CONDITION(lastMsg.empty(), "Testing default message handler");
 
   resetLastMsg();
 
   installMsgHandler(handleMessages);
   {
     US_DEBUG << "Msg";
   }
 #if !defined(US_ENABLE_DEBUG_OUTPUT)
   US_TEST_CONDITION(lastMsgType == -1 && lastMsg.empty(), "Testing suppressed debug message")
 #else
   US_TEST_CONDITION(lastMsgType == 0 && lastMsg.find("Msg") != std::string::npos, "Testing debug message")
 #endif
   resetLastMsg();
 
   {
     US_DEBUG(false) << "No msg";
   }
   US_TEST_CONDITION(lastMsgType == -1 && lastMsg.empty(), "Testing disabled debug message")
   resetLastMsg();
 
   {
     US_INFO << "Info msg";
   }
   US_TEST_CONDITION(lastMsgType == 1 && lastMsg.find("Info msg") != std::string::npos, "Testing informational message")
   resetLastMsg();
 
   {
     US_WARN << "Warn msg";
   }
   US_TEST_CONDITION(lastMsgType == 2 && lastMsg.find("Warn msg") != std::string::npos, "Testing warning message")
   resetLastMsg();
 
   // We cannot test US_ERROR since it will call abort().
 
   installMsgHandler(nullptr);
 
   {
     US_INFO << "Info msg";
   }
   US_TEST_CONDITION(lastMsgType == -1 && lastMsg.empty(), "Testing message handler reset")
   resetLastMsg();
 }
 
 void testLogLevels()
 {
   installMsgHandler(handleMessages);
 
   MsgType logLevel = ModuleSettings::GetLogLevel();
   US_TEST_CONDITION_REQUIRED(logLevel == DebugMsg, "Default log level")
 
   logMsg(DebugMsg, logLevel);
   logMsg(InfoMsg, logLevel);
   logMsg(WarningMsg, logLevel);
   logMsg(ErrorMsg, logLevel);
 
   for (int level = ErrorMsg; level >= 0; --level)
   {
     ModuleSettings::SetLogLevel(static_cast<MsgType>(level));
     logMsg(DebugMsg, level);
     logMsg(InfoMsg, level);
     logMsg(WarningMsg, level);
     logMsg(ErrorMsg, level);
   }
 
   installMsgHandler(nullptr);
   resetLastMsg();
 }
 
 int usLogTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("DebugOutputTest");
 
   testLogMessages();
   testLogLevels();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usModuleAutoLoadTest.cpp b/Modules/CppMicroServices/core/test/usModuleAutoLoadTest.cpp
index 2a252a1fe6..a4035230cc 100644
--- a/Modules/CppMicroServices/core/test/usModuleAutoLoadTest.cpp
+++ b/Modules/CppMicroServices/core/test/usModuleAutoLoadTest.cpp
@@ -1,175 +1,175 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModuleContext.h>
 #include <usModuleEvent.h>
 #include <usGetModuleContext.h>
 #include <usModuleRegistry.h>
 #include <usModule.h>
 #include <usModuleSettings.h>
 #include <usSharedLibrary.h>
 
 #include <usTestingConfig.h>
 
 #include "usTestUtilModuleListener.h"
 #include "usTestingMacros.h"
 
 #include <cassert>
 
 US_USE_NAMESPACE
 
 namespace {
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
 void testDefaultAutoLoadPath(bool autoLoadEnabled)
 {
   ModuleContext* mc = GetModuleContext();
   assert(mc);
   TestModuleListener listener;
 
   ModuleListenerRegistrationHelper<TestModuleListener> listenerReg(mc, &listener, &TestModuleListener::ModuleChanged);
 
   SharedLibrary libAL(LIB_PATH, "TestModuleAL");
 
   try
   {
     libAL.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 
   Module* moduleAL = ModuleRegistry::GetModule("TestModuleAL");
   US_TEST_CONDITION_REQUIRED(moduleAL != nullptr, "Test for existing module TestModuleAL")
 
   US_TEST_CONDITION(moduleAL->GetName() == "TestModuleAL", "Test module name")
 
   // check the listeners for events
   std::vector<ModuleEvent> pEvts;
   pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleAL));
 
   Any loadedModules = moduleAL->GetProperty(Module::PROP_AUTOLOADED_MODULES());
   Module* moduleAL_1 = ModuleRegistry::GetModule("TestModuleAL_1");
   if (autoLoadEnabled)
   {
     US_TEST_CONDITION_REQUIRED(moduleAL_1 != nullptr, "Test for existing auto-loaded module TestModuleAL_1")
     US_TEST_CONDITION(moduleAL_1->GetName() == "TestModuleAL_1", "Test module name")
     US_TEST_CONDITION_REQUIRED(!loadedModules.Empty(), "Test for PROP_AUTOLOADED_MODULES property")
     US_TEST_CONDITION_REQUIRED(loadedModules.Type() == typeid(std::vector<std::string>), "Test for PROP_AUTOLOADED_MODULES property type")
     std::vector<std::string> loadedModulesVec = any_cast<std::vector<std::string> >(loadedModules);
     US_TEST_CONDITION_REQUIRED(loadedModulesVec.size() == 1, "Test for PROP_AUTOLOADED_MODULES vector size")
     US_TEST_CONDITION_REQUIRED(loadedModulesVec[0] == moduleAL_1->GetLocation(), "Test for PROP_AUTOLOADED_MODULES vector content")
 
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleAL_1));
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleAL_1));
   }
   else
   {
     US_TEST_CONDITION_REQUIRED(moduleAL_1 == nullptr, "Test for non-existing auto-loaded module TestModuleAL_1")
     US_TEST_CONDITION_REQUIRED(loadedModules.Empty(), "Test for empty PROP_AUTOLOADED_MODULES property")
   }
 
   pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleAL));
 
   US_TEST_CONDITION(listener.CheckListenerEvents(pEvts), "Test for unexpected events");
 
   mc->RemoveModuleListener(&listener, &TestModuleListener::ModuleChanged);
 
   libAL.Unload();
 }
 
 void testCustomAutoLoadPath()
 {
   ModuleContext* mc = GetModuleContext();
   assert(mc);
   TestModuleListener listener;
 
   try
   {
     mc->AddModuleListener(&listener, &TestModuleListener::ModuleChanged);
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_OUTPUT( << "module listener registration failed " << ise.what() );
     throw;
   }
 
   SharedLibrary libAL2(LIB_PATH, "TestModuleAL2");
 
   try
   {
     libAL2.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 
   Module* moduleAL2 = ModuleRegistry::GetModule("TestModuleAL2");
   US_TEST_CONDITION_REQUIRED(moduleAL2 != nullptr, "Test for existing module TestModuleAL2")
 
   US_TEST_CONDITION(moduleAL2->GetName() == "TestModuleAL2", "Test module name")
 
   // check the listeners for events
   std::vector<ModuleEvent> pEvts;
   pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleAL2));
 
   Module* moduleAL2_1 = ModuleRegistry::GetModule("TestModuleAL2_1");
 #ifdef US_ENABLE_AUTOLOADING_SUPPORT
   US_TEST_CONDITION_REQUIRED(moduleAL2_1 != nullptr, "Test for existing auto-loaded module TestModuleAL2_1")
   US_TEST_CONDITION(moduleAL2_1->GetName() == "TestModuleAL2_1", "Test module name")
 
   pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleAL2_1));
   pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleAL2_1));
 #else
   US_TEST_CONDITION_REQUIRED(moduleAL2_1 == nullptr, "Test for non-existing aut-loaded module TestModuleAL2_1")
 #endif
 
   pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleAL2));
 
   US_TEST_CONDITION(listener.CheckListenerEvents(pEvts), "Test for unexpected events");
 
   mc->RemoveModuleListener(&listener, &TestModuleListener::ModuleChanged);
 }
 
 } // end unnamed namespace
 
 
 int usModuleAutoLoadTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ModuleLoaderTest");
 
   ModuleSettings::SetAutoLoadingEnabled(false);
   testDefaultAutoLoadPath(false);
   ModuleSettings::SetAutoLoadingEnabled(true);
 
   testDefaultAutoLoadPath(true);
 
   testCustomAutoLoadPath();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usModuleHooksTest.cpp b/Modules/CppMicroServices/core/test/usModuleHooksTest.cpp
index e9b05620f4..172798fda2 100644
--- a/Modules/CppMicroServices/core/test/usModuleHooksTest.cpp
+++ b/Modules/CppMicroServices/core/test/usModuleHooksTest.cpp
@@ -1,194 +1,194 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModule.h>
 #include <usModuleEvent.h>
 #include <usModuleFindHook.h>
 #include <usModuleEventHook.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usSharedLibrary.h>
 
 #include "usTestingMacros.h"
 #include "usTestingConfig.h"
 
 US_USE_NAMESPACE
 
 namespace {
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
 class TestModuleListener
 {
 public:
 
   void ModuleChanged(const ModuleEvent moduleEvent)
   {
     this->events.push_back(moduleEvent);
   }
 
   std::vector<ModuleEvent> events;
 };
 
 class TestModuleFindHook : public ModuleFindHook
 {
 public:
 
   void Find(const ModuleContext* /*context*/, ShrinkableVector<Module*>& modules) override
   {
     for (ShrinkableVector<Module*>::iterator i = modules.begin();
          i != modules.end();)
     {
       if ((*i)->GetName() == "TestModuleA")
       {
         i = modules.erase(i);
       }
       else
       {
         ++i;
       }
     }
   }
 };
 
 class TestModuleEventHook : public ModuleEventHook
 {
 public:
 
   void Event(const ModuleEvent& event, ShrinkableVector<ModuleContext*>& contexts) override
   {
     if (event.GetType() == ModuleEvent::LOADING || event.GetType() == ModuleEvent::UNLOADING)
     {
       contexts.erase(std::remove(contexts.begin(), contexts.end(), GetModuleContext()), contexts.end());
     }
   }
 };
 
 void TestFindHook()
 {
   SharedLibrary libA(LIB_PATH, "TestModuleA");
 
 #ifdef US_BUILD_SHARED_LIBS
   try
   {
     libA.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 #endif
 
   Module* moduleA = GetModuleContext()->GetModule("TestModuleA");
   US_TEST_CONDITION_REQUIRED(moduleA != nullptr, "Test for existing module TestModuleA")
 
   US_TEST_CONDITION(moduleA->GetName() == "TestModuleA", "Test module name")
 
   US_TEST_CONDITION(moduleA->IsLoaded() == true, "Test if loaded correctly");
 
   long moduleAId = moduleA->GetModuleId();
   US_TEST_CONDITION_REQUIRED(moduleAId > 0, "Test for valid module id")
 
   US_TEST_CONDITION_REQUIRED(GetModuleContext()->GetModule(moduleAId) != nullptr, "Test for non-filtered GetModule(long) result")
 
   TestModuleFindHook findHook;
   ServiceRegistration<ModuleFindHook> findHookReg = GetModuleContext()->RegisterService<ModuleFindHook>(&findHook);
 
   US_TEST_CONDITION_REQUIRED(GetModuleContext()->GetModule(moduleAId) == nullptr, "Test for filtered GetModule(long) result")
 
   std::vector<Module*> modules = GetModuleContext()->GetModules();
   for (std::vector<Module*>::iterator i = modules.begin();
        i != modules.end(); ++i)
   {
     if((*i)->GetName() == "TestModuleA")
     {
       US_TEST_FAILED_MSG(<< "TestModuleA not filtered from GetModules()")
     }
   }
 
   findHookReg.Unregister();
 
   libA.Unload();
 }
 
 #ifdef US_BUILD_SHARED_LIBS
 void TestEventHook()
 {
   TestModuleListener moduleListener;
   GetModuleContext()->AddModuleListener(&moduleListener, &TestModuleListener::ModuleChanged);
 
   SharedLibrary libA(LIB_PATH, "TestModuleA");
   try
   {
     libA.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
   US_TEST_CONDITION_REQUIRED(moduleListener.events.size() == 2, "Test for received load module events")
 
   libA.Unload();
   US_TEST_CONDITION_REQUIRED(moduleListener.events.size() == 4, "Test for received unload module events")
 
   TestModuleEventHook eventHook;
   ServiceRegistration<ModuleEventHook> eventHookReg = GetModuleContext()->RegisterService<ModuleEventHook>(&eventHook);
 
   moduleListener.events.clear();
   try
   {
     libA.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 
   US_TEST_CONDITION_REQUIRED(moduleListener.events.size() == 1, "Test for filtered load module events")
   US_TEST_CONDITION_REQUIRED(moduleListener.events[0].GetType() == ModuleEvent::LOADED, "Test for LOADED event")
 
   libA.Unload();
   US_TEST_CONDITION_REQUIRED(moduleListener.events.size() == 2, "Test for filtered unload module events")
   US_TEST_CONDITION_REQUIRED(moduleListener.events[1].GetType() == ModuleEvent::UNLOADED, "Test for UNLOADED event")
 
   eventHookReg.Unregister();
   GetModuleContext()->RemoveModuleListener(&moduleListener, &TestModuleListener::ModuleChanged);
 }
 #endif
 
 } // end unnamed namespace
 
 int usModuleHooksTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ModuleHooksTest");
 
   TestFindHook();
 
 #ifdef US_BUILD_SHARED_LIBS
   TestEventHook();
 #endif
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usModuleManifestTest.cpp b/Modules/CppMicroServices/core/test/usModuleManifestTest.cpp
index 51f201efdc..01164d649b 100644
--- a/Modules/CppMicroServices/core/test/usModuleManifestTest.cpp
+++ b/Modules/CppMicroServices/core/test/usModuleManifestTest.cpp
@@ -1,96 +1,96 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModule.h>
 #include <usModuleEvent.h>
 #include <usServiceEvent.h>
 #include <usModuleContext.h>
 #include <usModuleRegistry.h>
 #include <usModuleActivator.h>
 #include <usSharedLibrary.h>
 
 #include "usTestingMacros.h"
 #include "usTestingConfig.h"
 
 US_USE_NAMESPACE
 
 namespace {
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
 } // end unnamed namespace
 
 int usModuleManifestTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ModuleManifestTest");
 
   SharedLibrary target(LIB_PATH, "TestModuleM");
 
 #ifdef US_BUILD_SHARED_LIBS
   try
   {
     target.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG( << "Failed to load module, got exception: "
                         << e.what() << " + in frameSL02a:FAIL" );
   }
 #endif
 
   Module* moduleM = ModuleRegistry::GetModule("TestModuleM");
   US_TEST_CONDITION_REQUIRED(moduleM != nullptr, "Test for existing module TestModuleM")
 
   US_TEST_CONDITION(moduleM->GetProperty(Module::PROP_NAME()).ToString() == "TestModuleM", "Module name")
   US_TEST_CONDITION(moduleM->GetName() == "TestModuleM", "Module name 2")
   US_TEST_CONDITION(moduleM->GetProperty(Module::PROP_DESCRIPTION()).ToString() == "My Module description", "Module description")
   US_TEST_CONDITION(moduleM->GetLocation() == moduleM->GetProperty(Module::PROP_LOCATION()).ToString(), "Module location")
   US_TEST_CONDITION(moduleM->GetProperty(Module::PROP_VERSION()).ToString() == "1.0.0", "Module version")
   US_TEST_CONDITION(moduleM->GetVersion() == ModuleVersion(1,0,0), "Module version 2")
 
   Any anyVector = moduleM->GetProperty("vector");
   US_TEST_CONDITION_REQUIRED(anyVector.Type() == typeid(std::vector<Any>), "vector type")
   std::vector<Any>& vec = ref_any_cast<std::vector<Any> >(anyVector);
   US_TEST_CONDITION_REQUIRED(vec.size() == 3, "vector size")
   US_TEST_CONDITION_REQUIRED(vec[0].Type() == typeid(std::string), "vector 0 type")
   US_TEST_CONDITION_REQUIRED(vec[0].ToString() == "first", "vector 0 value")
   US_TEST_CONDITION_REQUIRED(vec[1].Type() == typeid(int), "vector 1 type")
   US_TEST_CONDITION_REQUIRED(any_cast<int>(vec[1]) == 2, "vector 1 value")
 
   Any anyMap = moduleM->GetProperty("map");
   US_TEST_CONDITION_REQUIRED(anyMap.Type() == typeid(std::map<std::string,Any>), "map type")
   std::map<std::string, Any>& m = ref_any_cast<std::map<std::string, Any> >(anyMap);
   US_TEST_CONDITION_REQUIRED(m.size() == 3, "map size")
   US_TEST_CONDITION_REQUIRED(m["string"].Type() == typeid(std::string), "map 0 type")
   US_TEST_CONDITION_REQUIRED(m["string"].ToString() == "hi", "map 0 value")
   US_TEST_CONDITION_REQUIRED(m["number"].Type() == typeid(int), "map 1 type")
   US_TEST_CONDITION_REQUIRED(any_cast<int>(m["number"]) == 4, "map 1 value")
   US_TEST_CONDITION_REQUIRED(m["list"].Type() == typeid(std::vector<Any>), "map 2 type")
   US_TEST_CONDITION_REQUIRED(any_cast<std::vector<Any> >(m["list"]).size() == 2, "map 2 value size")
 
   target.Unload();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usModulePropsInterface.h b/Modules/CppMicroServices/core/test/usModulePropsInterface.h
index 7755ea9cbd..26eefd32ab 100644
--- a/Modules/CppMicroServices/core/test/usModulePropsInterface.h
+++ b/Modules/CppMicroServices/core/test/usModulePropsInterface.h
@@ -1,42 +1,42 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USMODULEPROPSINTERFACE_H
 #define USMODULEPROPSINTERFACE_H
 
 #include <usServiceInterface.h>
 #include <usServiceProperties.h>
 
 US_BEGIN_NAMESPACE
 
 struct ModulePropsInterface
 {
   typedef ServiceProperties Properties;
 
   virtual ~ModulePropsInterface() {}
 
   virtual const Properties& GetProperties() const = 0;
 };
 
 US_END_NAMESPACE
 
 #endif // USMODULEPROPSINTERFACE_H
diff --git a/Modules/CppMicroServices/core/test/usModuleResourceTest.cpp b/Modules/CppMicroServices/core/test/usModuleResourceTest.cpp
index 0cced3fc62..0246b864b7 100644
--- a/Modules/CppMicroServices/core/test/usModuleResourceTest.cpp
+++ b/Modules/CppMicroServices/core/test/usModuleResourceTest.cpp
@@ -1,483 +1,483 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModuleRegistry.h>
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <usSharedLibrary.h>
 
 #include <usTestingConfig.h>
 
 #include "usTestingMacros.h"
 
 #include <cassert>
 
 #include <set>
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
 US_USE_NAMESPACE
 
 namespace {
 
   // Please confirm that a character count differing from the following targets is not due to
   // a misconfiguration of your versioning software (Correct line endings for your system)
   // See issue #18 ( https://github.com/saschazelzer/CppMicroServices/issues/18 )
 void checkResourceInfo(const ModuleResource& res, const std::string& path,
                        const std::string& baseName,
                        const std::string& completeBaseName, const std::string& suffix,
                        const std::string& completeSuffix,
                        int size, bool children = false)
 {
   US_TEST_CONDITION_REQUIRED(res.IsValid(), "Valid resource")
   US_TEST_CONDITION(res.GetBaseName() == baseName, "GetBaseName()")
   US_TEST_CONDITION(res.GetChildren().empty() == !children, "No children")
   US_TEST_CONDITION(res.GetCompleteBaseName() == completeBaseName, "GetCompleteBaseName()")
   US_TEST_CONDITION(res.GetName() == completeBaseName + "." + suffix, "GetName()")
   US_TEST_CONDITION(res.GetResourcePath() == path + completeBaseName + "." + suffix, "GetResourcePath()")
   US_TEST_CONDITION(res.GetPath() == path, "GetPath()")
   US_TEST_CONDITION(res.GetSize() == size, "Data size")
   US_TEST_CONDITION(res.GetSuffix() == suffix, "Suffix")
   US_TEST_CONDITION(res.GetCompleteSuffix() == completeSuffix, "Complete suffix")
 }
 
 void testTextResource(Module* module)
 {
   ModuleResource res = module->GetResource("foo.txt");
 #ifdef US_PLATFORM_WINDOWS
   checkResourceInfo(res, "/", "foo", "foo", "txt", "txt", 16, false);
   const std::streampos ssize(13);
   const std::string fileData = "foo and\nbar\n\n";
 #else
   checkResourceInfo(res, "/", "foo", "foo", "txt", "txt", 13, false);
   const std::streampos ssize(12);
   const std::string fileData = "foo and\nbar\n";
 #endif
 
   ModuleResourceStream rs(res);
 
   rs.seekg(0, std::ios::end);
   US_TEST_CONDITION(rs.tellg() == ssize, "Stream content length");
   rs.seekg(0, std::ios::beg);
 
   std::string content;
   content.reserve(res.GetSize());
   char buffer[1024];
   while (rs.read(buffer, sizeof(buffer)))
   {
     content.append(buffer, sizeof(buffer));
   }
   content.append(buffer, static_cast<std::size_t>(rs.gcount()));
 
   US_TEST_CONDITION(rs.eof(), "EOF check");
   US_TEST_CONDITION(content == fileData, "Resource content");
 
   rs.clear();
   rs.seekg(0);
 
   US_TEST_CONDITION_REQUIRED(rs.tellg() == std::streampos(0), "Move to start")
   US_TEST_CONDITION_REQUIRED(rs.good(), "Start re-reading");
 
   std::vector<std::string> lines;
   std::string line;
   while (std::getline(rs, line))
   {
     lines.push_back(line);
   }
   US_TEST_CONDITION_REQUIRED(lines.size() > 1, "Number of lines")
   US_TEST_CONDITION(lines[0] == "foo and", "Check first line")
   US_TEST_CONDITION(lines[1] == "bar", "Check second line")
 }
 
 void testTextResourceAsBinary(Module* module)
 {
   ModuleResource res = module->GetResource("foo.txt");
 
 #ifdef US_PLATFORM_WINDOWS
   checkResourceInfo(res, "/", "foo", "foo", "txt", "txt", 16, false);
   const std::streampos ssize(16);
   const std::string fileData = "foo and\r\nbar\r\n\r\n";
 #else
   checkResourceInfo(res, "/", "foo", "foo", "txt", "txt", 13, false);
   const std::streampos ssize(13);
   const std::string fileData = "foo and\nbar\n\n";
 #endif
 
 
   ModuleResourceStream rs(res, std::ios_base::binary);
 
   rs.seekg(0, std::ios::end);
   US_TEST_CONDITION(rs.tellg() == ssize, "Stream content length");
   rs.seekg(0, std::ios::beg);
 
   std::string content;
   content.reserve(res.GetSize());
   char buffer[1024];
   while (rs.read(buffer, sizeof(buffer)))
   {
     content.append(buffer, sizeof(buffer));
   }
   content.append(buffer, static_cast<std::size_t>(rs.gcount()));
 
   US_TEST_CONDITION(rs.eof(), "EOF check");
   US_TEST_CONDITION(content == fileData, "Resource content");
 }
 
 void testInvalidResource(Module* module)
 {
   ModuleResource res = module->GetResource("invalid");
   US_TEST_CONDITION_REQUIRED(res.IsValid() == false, "Check invalid resource")
   US_TEST_CONDITION(res.GetName().empty(), "Check empty name")
   US_TEST_CONDITION(res.GetPath().empty(), "Check empty path")
   US_TEST_CONDITION(res.GetResourcePath().empty(), "Check empty resource path")
   US_TEST_CONDITION(res.GetBaseName().empty(), "Check empty base name")
   US_TEST_CONDITION(res.GetCompleteBaseName().empty(), "Check empty complete base name")
   US_TEST_CONDITION(res.GetSuffix().empty(), "Check empty suffix")
 
   US_TEST_CONDITION(res.GetChildren().empty(), "Check empty children")
   US_TEST_CONDITION(res.GetSize() == 0, "Check zero size")
 
   ModuleResourceStream rs(res);
   US_TEST_CONDITION(rs.good() == true, "Check invalid resource stream")
   rs.ignore();
   US_TEST_CONDITION(rs.good() == false, "Check invalid resource stream")
   US_TEST_CONDITION(rs.eof() == true, "Check invalid resource stream")
 }
 
 void testSpecialCharacters(Module* module)
 {
   ModuleResource res = module->GetResource("special_chars.dummy.txt");
 #ifdef US_PLATFORM_WINDOWS
   checkResourceInfo(res, "/", "special_chars", "special_chars.dummy", "txt", "dummy.txt", 56, false);
   const std::streampos ssize(54);
   const std::string fileData = "German Füße (feet)\nFrench garçon de café (waiter)\n";
 #else
   checkResourceInfo(res, "/", "special_chars", "special_chars.dummy", "txt", "dummy.txt", 54, false);
   const std::streampos ssize(53);
   const std::string fileData = "German Füße (feet)\nFrench garçon de café (waiter)";
 #endif
 
   ModuleResourceStream rs(res);
 
   rs.seekg(0, std::ios_base::end);
   US_TEST_CONDITION(rs.tellg() == ssize, "Stream content length");
   rs.seekg(0, std::ios_base::beg);
 
   std::string content;
   content.reserve(res.GetSize());
   char buffer[1024];
   while (rs.read(buffer, sizeof(buffer)))
   {
     content.append(buffer, sizeof(buffer));
   }
   content.append(buffer, static_cast<std::size_t>(rs.gcount()));
 
   US_TEST_CONDITION(rs.eof(), "EOF check");
   US_TEST_CONDITION(content == fileData, "Resource content");
 }
 
 void testBinaryResource(Module* module)
 {
   ModuleResource res = module->GetResource("/icons/cppmicroservices.png");
   checkResourceInfo(res, "/icons/", "cppmicroservices", "cppmicroservices", "png", "png", 2598, false);
 
   ModuleResourceStream rs(res, std::ios_base::binary);
   rs.seekg(0, std::ios_base::end);
   std::streampos resLength = rs.tellg();
   rs.seekg(0);
 
   std::ifstream png(US_CORE_SOURCE_DIR "/test/modules/libRWithResources/resources/icons/cppmicroservices.png",
                     std::ifstream::in | std::ifstream::binary);
 
   US_TEST_CONDITION_REQUIRED(png.is_open(), "Open reference file")
 
   png.seekg(0, std::ios_base::end);
   std::streampos pngLength = png.tellg();
   png.seekg(0);
   US_TEST_CONDITION(res.GetSize() == resLength, "Check resource size")
   US_TEST_CONDITION_REQUIRED(resLength == pngLength, "Compare sizes")
 
   char c1 = 0;
   char c2 = 0;
   bool isEqual = true;
   int count = 0;
   while (png.get(c1) && rs.get(c2))
   {
     ++count;
     if (c1 != c2)
     {
       isEqual = false;
       break;
     }
   }
 
   US_TEST_CONDITION_REQUIRED(count == pngLength, "Check if everything was read");
   US_TEST_CONDITION_REQUIRED(isEqual, "Equal binary contents");
   US_TEST_CONDITION(png.eof(), "EOF check");
 }
 
 void testCompressedResource(Module* module)
 {
   ModuleResource res = module->GetResource("/icons/compressable.bmp");
   checkResourceInfo(res, "/icons/", "compressable", "compressable", "bmp", "bmp", 300122, false);
 
   ModuleResourceStream rs(res, std::ios_base::binary);
   rs.seekg(0, std::ios_base::end);
   std::streampos resLength = rs.tellg();
   rs.seekg(0);
 
   std::ifstream bmp(US_CORE_SOURCE_DIR "/test/modules/libRWithResources/resources/icons/compressable.bmp",
                     std::ifstream::in | std::ifstream::binary);
 
   US_TEST_CONDITION_REQUIRED(bmp.is_open(), "Open reference file")
 
   bmp.seekg(0, std::ios_base::end);
   std::streampos bmpLength = bmp.tellg();
   bmp.seekg(0);
   US_TEST_CONDITION(300122 == resLength, "Check resource size")
   US_TEST_CONDITION_REQUIRED(resLength == bmpLength, "Compare sizes")
 
   char c1 = 0;
   char c2 = 0;
   bool isEqual = true;
   int count = 0;
   while (bmp.get(c1) && rs.get(c2))
   {
     ++count;
     if (c1 != c2)
     {
       isEqual = false;
       break;
     }
   }
 
   US_TEST_CONDITION_REQUIRED(count == bmpLength, "Check if everything was read");
   US_TEST_CONDITION_REQUIRED(isEqual, "Equal binary contents");
   US_TEST_CONDITION(bmp.eof(), "EOF check");
 }
 
 struct ResourceComparator {
   bool operator()(const ModuleResource& mr1, const ModuleResource& mr2) const
   {
     return mr1 < mr2;
   }
 };
 
 void testResourceTree(Module* module)
 {
   ModuleResource res = module->GetResource("");
   US_TEST_CONDITION(res.GetResourcePath() == "/", "Check root file path")
   US_TEST_CONDITION(res.IsDir() == true, "Check type")
 
   std::vector<std::string> children = res.GetChildren();
   std::sort(children.begin(), children.end());
   US_TEST_CONDITION_REQUIRED(children.size() == 5, "Check child count")
   US_TEST_CONDITION(children[0] == "foo.txt", "Check child name")
   US_TEST_CONDITION(children[1] == "foo2.txt", "Check child name")
   US_TEST_CONDITION(children[2] == "icons/", "Check child name")
   US_TEST_CONDITION(children[3] == "special_chars.dummy.txt", "Check child name")
   US_TEST_CONDITION(children[4] == "test.xml", "Check child name")
 
   US_TEST_CONDITION(module->FindResources("!$noexist=?", std::string(), "true").empty(), "Check not existant path");
 
 
   ModuleResource readme = module->GetResource("/icons/readme.txt");
   US_TEST_CONDITION(readme.IsFile() && readme.GetChildren().empty(), "Check file resource")
 
   ModuleResource icons = module->GetResource("icons/");
   US_TEST_CONDITION(icons.IsDir() && !icons.IsFile() && !icons.GetChildren().empty(), "Check directory resource")
 
   children = icons.GetChildren();
   US_TEST_CONDITION_REQUIRED(children.size() == 3, "Check icons child count")
   std::sort(children.begin(), children.end());
   US_TEST_CONDITION(children[0] == "compressable.bmp", "Check child name")
   US_TEST_CONDITION(children[1] == "cppmicroservices.png", "Check child name")
   US_TEST_CONDITION(children[2] == "readme.txt", "Check child name")
 
   ResourceComparator resourceComparator;
 
   // find all .txt files
   std::vector<ModuleResource> nodes = module->FindResources("", "*.txt", false);
   std::sort(nodes.begin(), nodes.end(), resourceComparator);
   US_TEST_CONDITION_REQUIRED(nodes.size() == 3, "Found child count")
   US_TEST_CONDITION(nodes[0].GetResourcePath() == "/foo.txt", "Check child name")
   US_TEST_CONDITION(nodes[1].GetResourcePath() == "/foo2.txt", "Check child name")
   US_TEST_CONDITION(nodes[2].GetResourcePath() == "/special_chars.dummy.txt", "Check child name")
 
   nodes = module->FindResources("", "*.txt", true);
   std::sort(nodes.begin(), nodes.end(), resourceComparator);
   US_TEST_CONDITION_REQUIRED(nodes.size() == 4, "Found child count")
   US_TEST_CONDITION(nodes[0].GetResourcePath() == "/foo.txt", "Check child name")
   US_TEST_CONDITION(nodes[1].GetResourcePath() == "/foo2.txt", "Check child name")
   US_TEST_CONDITION(nodes[2].GetResourcePath() == "/icons/readme.txt", "Check child name")
   US_TEST_CONDITION(nodes[3].GetResourcePath() == "/special_chars.dummy.txt", "Check child name")
 
   // find all resources
   nodes = module->FindResources("", "", true);
   US_TEST_CONDITION(nodes.size() == 8, "Total resource number")
   nodes = module->FindResources("", "**", true);
   US_TEST_CONDITION(nodes.size() == 8, "Total resource number")
 
 
   // test pattern matching
   nodes.clear();
   nodes = module->FindResources("/icons", "*micro*.png", false);
   US_TEST_CONDITION(nodes.size() == 1 && nodes[0].GetResourcePath() == "/icons/cppmicroservices.png", "Check file pattern matches")
 
   nodes.clear();
   nodes = module->FindResources("", "*.txt", true);
   US_TEST_CONDITION(nodes.size() == 4, "Check recursive pattern matches")
 }
 
 void testResourceOperators(Module* module)
 {
   ModuleResource invalid = module->GetResource("invalid");
   ModuleResource foo = module->GetResource("foo.txt");
   US_TEST_CONDITION_REQUIRED(foo.IsValid() && foo, "Check valid resource")
   ModuleResource foo2(foo);
   US_TEST_CONDITION(foo == foo, "Check equality operator")
   US_TEST_CONDITION(foo == foo2, "Check copy constructor and equality operator")
   US_TEST_CONDITION(foo != invalid, "Check inequality with invalid resource")
 
   ModuleResource xml = module->GetResource("/test.xml");
   US_TEST_CONDITION_REQUIRED(xml.IsValid() && xml, "Check valid resource")
   US_TEST_CONDITION(foo != xml, "Check inequality")
   US_TEST_CONDITION(foo < xml, "Check operator<")
 
   // check operator< by using a set
   std::set<ModuleResource> resources;
   resources.insert(foo);
   resources.insert(foo);
   resources.insert(xml);
   US_TEST_CONDITION(resources.size() == 2, "Check operator< with set")
 
   // check hash function specialization
   US_UNORDERED_SET_TYPE<ModuleResource> resources2;
   resources2.insert(foo);
   resources2.insert(foo);
   resources2.insert(xml);
   US_TEST_CONDITION(resources2.size() == 2, "Check operator< with unordered set")
 
   // check operator<<
   std::ostringstream oss;
   oss << foo;
   US_TEST_CONDITION(oss.str() == foo.GetResourcePath(), "Check operator<<")
 }
 
 void testResourceFromExecutable(Module* module)
 {
   ModuleResource resource = module->GetResource("usTestResource.txt");
   US_TEST_CONDITION_REQUIRED(resource.IsValid(), "Check valid executable resource")
 
   std::string line;
   ModuleResourceStream rs(resource);
   std::getline(rs, line);
   US_TEST_CONDITION(line == "meant to be compiled into the test driver", "Check executable resource content")
 }
 
 void testResourcesFrom(const std::string& moduleName)
 {
 #ifdef US_BUILD_SHARED_LIBS
   SharedLibrary libR(LIB_PATH, moduleName);
   try
   {
     libR.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 #endif
 
   Module* moduleR = ModuleRegistry::GetModule(moduleName);
   US_TEST_CONDITION_REQUIRED(moduleR != nullptr, "Test for existing module")
 
   US_TEST_CONDITION(moduleR->GetName() == moduleName, "Test module name")
 
   US_TEST_CONDITION(moduleR->FindResources("", "*.txt", true).size() == 2, "Resource count")
 
 #ifdef US_BUILD_SHARED_LIBS
   libR.Unload();
 #endif
 }
 
 } // end unnamed namespace
 
 
 int usModuleResourceTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ModuleResourceTest");
 
   ModuleContext* mc = GetModuleContext();
   assert(mc);
 
 #ifdef US_BUILD_SHARED_LIBS
   SharedLibrary libR(LIB_PATH, "TestModuleR");
   try
   {
     libR.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 #endif
 
   Module* moduleR = ModuleRegistry::GetModule("TestModuleR");
   US_TEST_CONDITION_REQUIRED(moduleR != nullptr, "Test for existing module TestModuleR")
 
   US_TEST_CONDITION(moduleR->GetName() == "TestModuleR", "Test module name")
 
   testInvalidResource(moduleR);
 
   testResourceFromExecutable(mc->GetModule());
 
   testResourceTree(moduleR);
 
   testResourceOperators(moduleR);
 
   testTextResource(moduleR);
   testTextResourceAsBinary(moduleR);
   testSpecialCharacters(moduleR);
 
   testBinaryResource(moduleR);
 
   testCompressedResource(moduleR);
 
   ModuleResource foo = moduleR->GetResource("foo.txt");
   US_TEST_CONDITION(foo.IsValid() == true, "Valid resource")
 #ifdef US_BUILD_SHARED_LIBS
   libR.Unload();
   US_TEST_CONDITION(foo.IsValid() == true, "Still valid resource")
 #endif
 
   testResourcesFrom("TestModuleRL");
   testResourcesFrom("TestModuleRA");
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usModuleTest.cpp b/Modules/CppMicroServices/core/test/usModuleTest.cpp
index 683ad97c37..713d16e17f 100644
--- a/Modules/CppMicroServices/core/test/usModuleTest.cpp
+++ b/Modules/CppMicroServices/core/test/usModuleTest.cpp
@@ -1,350 +1,350 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModule.h>
 #include <usModuleEvent.h>
 #include <usServiceEvent.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModuleRegistry.h>
 #include <usModuleActivator.h>
 #include <usModuleSettings.h>
 #include <usSharedLibrary.h>
 
 #include "usTestUtilModuleListener.h"
 #include "usTestDriverActivator.h"
 #include "usTestingMacros.h"
 #include "usTestingConfig.h"
 
 US_USE_NAMESPACE
 
 namespace {
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
   static const char PATH_SEPARATOR = '\\';
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
   static const char PATH_SEPARATOR = '/';
 #endif
 
 // Check that the executable's activator was loaded and called
 void frame01()
 {
   US_TEST_CONDITION_REQUIRED(TestDriverActivator::LoadCalled(), "ModuleActivator::Load() called for executable")
 }
 
 // Verify that the same member function pointers registered as listeners
 // with different receivers works.
 void frame02a()
 {
   ModuleContext* mc = GetModuleContext();
 
   TestModuleListener listener1;
   TestModuleListener listener2;
 
   try
   {
     mc->RemoveModuleListener(&listener1, &TestModuleListener::ModuleChanged);
     mc->AddModuleListener(&listener1, &TestModuleListener::ModuleChanged);
     mc->RemoveModuleListener(&listener2, &TestModuleListener::ModuleChanged);
     mc->AddModuleListener(&listener2, &TestModuleListener::ModuleChanged);
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_FAILED_MSG( << "module listener registration failed " << ise.what()
                         << " : frameSL02a:FAIL" );
   }
 
   SharedLibrary target(LIB_PATH, "TestModuleA");
 
 #ifdef US_BUILD_SHARED_LIBS
   // Start the test target
   try
   {
     target.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG( << "Failed to load module, got exception: "
                         << e.what() << " + in frameSL02a:FAIL" );
   }
 #endif
 
   Module* moduleA = ModuleRegistry::GetModule("TestModuleA");
   US_TEST_CONDITION_REQUIRED(moduleA != nullptr, "Test for existing module TestModuleA")
 
   std::vector<ModuleEvent> pEvts;
 #ifdef US_BUILD_SHARED_LIBS
   pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleA));
   pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleA));
 #endif
 
   std::vector<ServiceEvent> seEvts;
 
   US_TEST_CONDITION(listener1.CheckListenerEvents(pEvts, seEvts), "Check first module listener")
   US_TEST_CONDITION(listener2.CheckListenerEvents(pEvts, seEvts), "Check second module listener")
 
   mc->RemoveModuleListener(&listener1, &TestModuleListener::ModuleChanged);
   mc->RemoveModuleListener(&listener2, &TestModuleListener::ModuleChanged);
 
   target.Unload();
 }
 
 // Verify information from the ModuleInfo struct
 void frame005a(ModuleContext* mc)
 {
   Module* m = mc->GetModule();
 
   // check expected headers
 
   US_TEST_CONDITION("main" == m->GetName(), "Test module name")
   US_TEST_CONDITION(ModuleVersion(0,1,0) == m->GetVersion(), "Test test driver module version")
   US_TEST_CONDITION(ModuleVersion(CppMicroServices_MAJOR_VERSION, CppMicroServices_MINOR_VERSION, CppMicroServices_PATCH_VERSION) == ModuleRegistry::GetModule(1)->GetVersion(), "Test CppMicroServices version")
 }
 
 // Get context id, location and status of the module
 void frame010a(ModuleContext* mc)
 {
   Module* m = mc->GetModule();
 
   long int contextid = m->GetModuleId();
   US_DEBUG << "CONTEXT ID:" << contextid;
 
   std::string location = m->GetLocation();
   US_DEBUG << "LOCATION:" << location;
   US_TEST_CONDITION(!location.empty(), "Test for non-empty module location")
 
   US_TEST_CONDITION(m->IsLoaded(), "Test for loaded flag")
 
   US_TEST_CONDITION(ModuleSettings::GetStoragePath().empty(), "Test for empty base storage path")
   US_TEST_CONDITION(m->GetModuleContext()->GetDataFile("").empty(), "Test for empty data path")
   US_TEST_CONDITION(m->GetModuleContext()->GetDataFile("bla").empty(), "Test for empty data file path")
 }
 
 //----------------------------------------------------------------------------
 //Test result of GetService(ServiceReference()). Should throw std::invalid_argument
 void frame018a(ModuleContext* mc)
 {
   try
   {
     mc->GetService(ServiceReferenceU());
     US_DEBUG << "Got service object, expected std::invalid_argument exception";
     US_TEST_FAILED_MSG(<< "Got service object, excpected std::invalid_argument exception")
   }
   catch (const std::invalid_argument& )
   {}
   catch (...)
   {
     US_TEST_FAILED_MSG(<< "Got wrong exception, expected std::invalid_argument")
   }
 }
 
 // Load libA and check that it exists and that the service it registers exists,
 // also check that the expected events occur and that the storage paths are correct
 void frame020a(ModuleContext* mc, TestModuleListener& listener,
 #ifdef US_BUILD_SHARED_LIBS
                SharedLibrary& libA)
 {
   try
   {
     libA.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 #else
                SharedLibrary& /*libA*/)
 {
 #endif
 
   ModuleSettings::SetStoragePath(std::string("/tmp") + PATH_SEPARATOR);
   US_TEST_CONDITION(ModuleSettings::GetStoragePath() == "/tmp", "Test for valid base storage path")
 
   Module* moduleA = ModuleRegistry::GetModule("TestModuleA");
   US_TEST_CONDITION_REQUIRED(moduleA != nullptr, "Test for existing module TestModuleA")
 
   US_TEST_CONDITION(moduleA->GetName() == "TestModuleA", "Test module name")
 
   std::cout << moduleA->GetModuleContext()->GetDataFile("") << std::endl;
   std::stringstream ss;
   ss << moduleA->GetModuleId();
   const std::string baseStoragePath = std::string("/tmp") + PATH_SEPARATOR + ss.str() + "_TestModuleA" + PATH_SEPARATOR;
   US_TEST_CONDITION(moduleA->GetModuleContext()->GetDataFile("") == baseStoragePath, "Test for valid data path")
   US_TEST_CONDITION(moduleA->GetModuleContext()->GetDataFile("bla") == baseStoragePath + "bla", "Test for valid data file path")
 
   // Check if libA registered the expected service
   try
   {
     ServiceReferenceU sr1 = mc->GetServiceReference("us::TestModuleAService");
     InterfaceMap o1 = mc->GetService(sr1);
     US_TEST_CONDITION(!o1.empty(), "Test if service object found");
 
     try
     {
       US_TEST_CONDITION(mc->UngetService(sr1), "Test if Service UnGet returns true");
     }
     catch (const std::logic_error& le)
     {
       US_TEST_FAILED_MSG(<< "UnGetService exception: " << le.what())
     }
 
     // check the listeners for events
     std::vector<ModuleEvent> pEvts;
 #ifdef US_BUILD_SHARED_LIBS
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleA));
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleA));
 #endif
 
     std::vector<ServiceEvent> seEvts;
 #ifdef US_BUILD_SHARED_LIBS
     seEvts.push_back(ServiceEvent(ServiceEvent::REGISTERED, sr1));
 #endif
 
     US_TEST_CONDITION(listener.CheckListenerEvents(pEvts, seEvts), "Test for unexpected events");
 
   }
   catch (const ServiceException& /*se*/)
   {
     US_TEST_FAILED_MSG(<< "test module, expected service not found");
   }
 
   US_TEST_CONDITION(moduleA->IsLoaded() == true, "Test if loaded correctly");
 }
 
 
 // Unload libA and check for correct events
 void frame030b(ModuleContext* mc, TestModuleListener& listener, SharedLibrary& libA)
 {
   Module* moduleA = ModuleRegistry::GetModule("TestModuleA");
   US_TEST_CONDITION_REQUIRED(moduleA != nullptr, "Test for non-null module")
 
   ServiceReferenceU sr1
       = mc->GetServiceReference("us::TestModuleAService");
   US_TEST_CONDITION(sr1, "Test for valid service reference")
 
   try
   {
     libA.Unload();
 #ifdef US_BUILD_SHARED_LIBS
     US_TEST_CONDITION(moduleA->IsLoaded() == false, "Test for unloaded state")
 #endif
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "UnLoad module exception: " << e.what())
   }
 
   std::vector<ModuleEvent> pEvts;
 #ifdef US_BUILD_SHARED_LIBS
   pEvts.push_back(ModuleEvent(ModuleEvent::UNLOADING, moduleA));
   pEvts.push_back(ModuleEvent(ModuleEvent::UNLOADED, moduleA));
 #endif
 
   std::vector<ServiceEvent> seEvts;
 #ifdef US_BUILD_SHARED_LIBS
   seEvts.push_back(ServiceEvent(ServiceEvent::UNREGISTERING, sr1));
 #endif
 
   US_TEST_CONDITION(listener.CheckListenerEvents(pEvts, seEvts), "Test for unexpected events");
 }
 
 
 struct LocalListener {
   void ServiceChanged(const ServiceEvent) {}
 };
 
 // Add a service listener with a broken LDAP filter to Get an exception
 void frame045a(ModuleContext* mc)
 {
   LocalListener sListen1;
   std::string brokenFilter = "A broken LDAP filter";
 
   try
   {
     mc->AddServiceListener(&sListen1, &LocalListener::ServiceChanged, brokenFilter);
   }
   catch (const std::invalid_argument& /*ia*/)
   {
     //assertEquals("InvalidSyntaxException.GetFilter should be same as input string", brokenFilter, ise.GetFilter());
   }
   catch (...)
   {
     US_TEST_FAILED_MSG(<< "test module, wrong exception on broken LDAP filter:");
   }
 }
 
 } // end unnamed namespace
 
 int usModuleTest(int /*argc*/, char* /*argv*/[])
 {
   //US_TEST_BEGIN("ModuleTest");
 
   std::vector<Module*> modules = ModuleRegistry::GetModules();
   for (std::vector<Module*>::iterator iter = modules.begin(), iterEnd = modules.end();
        iter != iterEnd; ++iter)
   {
     std::cout << "----- " << (*iter)->GetName() << std::endl;
   }
 
   frame01();
   frame02a();
 
   ModuleContext* mc = GetModuleContext();
   TestModuleListener listener;
 
   try
   {
     mc->AddModuleListener(&listener, &TestModuleListener::ModuleChanged);
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_OUTPUT( << "module listener registration failed " << ise.what() );
     throw;
   }
 
   try
   {
     mc->AddServiceListener(&listener, &TestModuleListener::ServiceChanged);
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_OUTPUT( << "service listener registration failed " << ise.what() );
     throw;
   }
 
   frame005a(mc);
   frame010a(mc);
   frame018a(mc);
 
   SharedLibrary libA(LIB_PATH, "TestModuleA");
   frame020a(mc, listener, libA);
   frame030b(mc, listener, libA);
 
   frame045a(mc);
 
   mc->RemoveModuleListener(&listener, &TestModuleListener::ModuleChanged);
   mc->RemoveServiceListener(&listener, &TestModuleListener::ServiceChanged);
 
   //US_TEST_END()
   return 0;
 }
diff --git a/Modules/CppMicroServices/core/test/usServiceControlInterface.h b/Modules/CppMicroServices/core/test/usServiceControlInterface.h
index 07b09b39ec..2811e61fb9 100644
--- a/Modules/CppMicroServices/core/test/usServiceControlInterface.h
+++ b/Modules/CppMicroServices/core/test/usServiceControlInterface.h
@@ -1,43 +1,43 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 
 #ifndef USSERVICECONTROLINTERFACE_H
 #define USSERVICECONTROLINTERFACE_H
 
 #include <usGlobalConfig.h>
 #include <usServiceInterface.h>
 
 #include <string>
 
 US_BEGIN_NAMESPACE
 
 struct ServiceControlInterface
 {
 
   virtual ~ServiceControlInterface() {}
 
   virtual void ServiceControl(int service, const std::string& operation, int ranking) = 0;
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICECONTROLINTERFACE_H
diff --git a/Modules/CppMicroServices/core/test/usServiceFactoryTest.cpp b/Modules/CppMicroServices/core/test/usServiceFactoryTest.cpp
index 2c3cf29f73..15ff92cd6e 100644
--- a/Modules/CppMicroServices/core/test/usServiceFactoryTest.cpp
+++ b/Modules/CppMicroServices/core/test/usServiceFactoryTest.cpp
@@ -1,231 +1,231 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModule.h>
 #include <usModuleRegistry.h>
 #include <usServiceObjects.h>
 #include <usSharedLibrary.h>
 
 #include "usTestingMacros.h"
 #include "usTestingConfig.h"
 
 US_USE_NAMESPACE
 
 namespace {
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
 } // end unnamed namespace
 
 
 US_BEGIN_NAMESPACE
 
 struct TestModuleH
 {
   virtual ~TestModuleH() {}
 };
 
 struct TestModuleH2
 {
   virtual ~TestModuleH2() {}
 };
 
 US_END_NAMESPACE
 
 
 void TestServiceFactoryModuleScope()
 {
 
   // Install and start test module H, a service factory and test that the methods
   // in that interface works.
 
   SharedLibrary target(LIB_PATH, "TestModuleH");
 
 #ifdef US_BUILD_SHARED_LIBS
   try
   {
     target.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG( << "Failed to load module, got exception: " << e.what())
   }
 #endif
 
   Module* moduleH = ModuleRegistry::GetModule("TestModuleH");
   US_TEST_CONDITION_REQUIRED(moduleH != nullptr, "Test for existing module TestModuleH")
 
   std::vector<ServiceReferenceU> registeredRefs = moduleH->GetRegisteredServices();
   US_TEST_CONDITION_REQUIRED(registeredRefs.size() == 2, "# of registered services")
   US_TEST_CONDITION(registeredRefs[0].GetProperty(ServiceConstants::SERVICE_SCOPE()).ToString() == ServiceConstants::SCOPE_MODULE(), "service scope")
   US_TEST_CONDITION(registeredRefs[1].GetProperty(ServiceConstants::SERVICE_SCOPE()).ToString() == ServiceConstants::SCOPE_PROTOTYPE(), "service scope")
 
   ModuleContext* mc = GetModuleContext();
   // Check that a service reference exist
   const ServiceReferenceU sr1 = mc->GetServiceReference("us::TestModuleH");
   US_TEST_CONDITION_REQUIRED(sr1, "Service shall be present.")
   US_TEST_CONDITION(sr1.GetProperty(ServiceConstants::SERVICE_SCOPE()).ToString() == ServiceConstants::SCOPE_MODULE(), "service scope")
 
   InterfaceMap service = mc->GetService(sr1);
   US_TEST_CONDITION_REQUIRED(service.size() >= 1, "GetService()")
   InterfaceMap::const_iterator serviceIter = service.find("us::TestModuleH");
   US_TEST_CONDITION_REQUIRED(serviceIter != service.end(), "GetService()")
   US_TEST_CONDITION_REQUIRED(serviceIter->second != nullptr, "GetService()")
 
   InterfaceMap service2 = mc->GetService(sr1);
   US_TEST_CONDITION(service == service2, "Same service pointer")
 
   std::vector<ServiceReferenceU> usedRefs = mc->GetModule()->GetServicesInUse();
   US_TEST_CONDITION_REQUIRED(usedRefs.size() == 1, "services in use")
   US_TEST_CONDITION(usedRefs[0] == sr1, "service ref in use")
 
   InterfaceMap service3 = moduleH->GetModuleContext()->GetService(sr1);
   US_TEST_CONDITION(service != service3, "Different service pointer")
   US_TEST_CONDITION(moduleH->GetModuleContext()->UngetService(sr1), "UngetService()")
 
   US_TEST_CONDITION_REQUIRED(mc->UngetService(sr1) == false, "ungetService()")
   US_TEST_CONDITION_REQUIRED(mc->UngetService(sr1) == true, "ungetService()")
 
   target.Unload();
 }
 
 void TestServiceFactoryPrototypeScope()
 {
 
   // Install and start test module H, a service factory and test that the methods
   // in that interface works.
 
   SharedLibrary target(LIB_PATH, "TestModuleH");
 
 #ifdef US_BUILD_SHARED_LIBS
   try
   {
     target.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG( << "Failed to load module, got exception: " << e.what())
   }
 
   Module* moduleH = ModuleRegistry::GetModule("TestModuleH");
   US_TEST_CONDITION_REQUIRED(moduleH != nullptr, "Test for existing module TestModuleH")
 #endif
 
   ModuleContext* mc = GetModuleContext();
   // Check that a service reference exist
   const ServiceReference<TestModuleH2> sr1 = mc->GetServiceReference<TestModuleH2>();
   US_TEST_CONDITION_REQUIRED(sr1, "Service shall be present.")
   US_TEST_CONDITION(sr1.GetProperty(ServiceConstants::SERVICE_SCOPE()).ToString() == ServiceConstants::SCOPE_PROTOTYPE(), "service scope")
 
   ServiceObjects<TestModuleH2> svcObjects = mc->GetServiceObjects(sr1);
   TestModuleH2* prototypeServiceH2 = svcObjects.GetService();
 
   const ServiceReferenceU sr1void = mc->GetServiceReference(us_service_interface_iid<TestModuleH2>());
   ServiceObjects<void> svcObjectsVoid = mc->GetServiceObjects(sr1void);
   InterfaceMap prototypeServiceH2Void = svcObjectsVoid.GetService();
   US_TEST_CONDITION_REQUIRED(prototypeServiceH2Void.find(us_service_interface_iid<TestModuleH2>()) != prototypeServiceH2Void.end(),
                              "ServiceObjects<void>::GetService()")
 
 #ifdef US_BUILD_SHARED_LIBS
   // There should be only one service in use
   US_TEST_CONDITION_REQUIRED(mc->GetModule()->GetServicesInUse().size() == 1, "services in use")
 #endif
 
   TestModuleH2* moduleScopeService = mc->GetService(sr1);
   US_TEST_CONDITION_REQUIRED(moduleScopeService && moduleScopeService != prototypeServiceH2, "GetService()")
 
   US_TEST_CONDITION_REQUIRED(prototypeServiceH2 != prototypeServiceH2Void.find(us_service_interface_iid<TestModuleH2>())->second,
                              "GetService()")
 
   svcObjectsVoid.UngetService(prototypeServiceH2Void);
 
   TestModuleH2* moduleScopeService2 = mc->GetService(sr1);
   US_TEST_CONDITION(moduleScopeService == moduleScopeService2, "Same service pointer")
 
 #ifdef US_BUILD_SHARED_LIBS
   std::vector<ServiceReferenceU> usedRefs = mc->GetModule()->GetServicesInUse();
   US_TEST_CONDITION_REQUIRED(usedRefs.size() == 1, "services in use")
   US_TEST_CONDITION(usedRefs[0] == sr1, "service ref in use")
 #endif
 
   std::string filter = "(" + ServiceConstants::SERVICE_ID() + "=" + sr1.GetProperty(ServiceConstants::SERVICE_ID()).ToString() + ")";
   const ServiceReference<TestModuleH> sr2 = mc->GetServiceReferences<TestModuleH>(filter).front();
   US_TEST_CONDITION_REQUIRED(sr2, "Service shall be present.")
   US_TEST_CONDITION(sr2.GetProperty(ServiceConstants::SERVICE_SCOPE()).ToString() == ServiceConstants::SCOPE_PROTOTYPE(), "service scope")
   US_TEST_CONDITION(any_cast<long>(sr2.GetProperty(ServiceConstants::SERVICE_ID())) == any_cast<long>(sr1.GetProperty(ServiceConstants::SERVICE_ID())), "same service id")
 
   try
   {
     svcObjects.UngetService(moduleScopeService2);
     US_TEST_FAILED_MSG(<< "std::invalid_argument exception expected")
   }
   catch (const std::invalid_argument&)
   {
     // this is expected
   }
 
 #ifdef US_BUILD_SHARED_LIBS
   // There should still be only one service in use
   usedRefs = mc->GetModule()->GetServicesInUse();
   US_TEST_CONDITION_REQUIRED(usedRefs.size() == 1, "services in use")
 #endif
 
   ServiceObjects<TestModuleH2> svcObjects2 = svcObjects;
   ServiceObjects<TestModuleH2> svcObjects3 = mc->GetServiceObjects(sr1);
   try
   {
     svcObjects3.UngetService(prototypeServiceH2);
     US_TEST_FAILED_MSG(<< "std::invalid_argument exception expected")
   }
   catch (const std::invalid_argument&)
   {
     // this is expected
   }
 
   svcObjects2.UngetService(prototypeServiceH2);
   prototypeServiceH2 = svcObjects2.GetService();
   TestModuleH2* prototypeServiceH2_2 = svcObjects3.GetService();
 
   US_TEST_CONDITION_REQUIRED(prototypeServiceH2_2 && prototypeServiceH2_2 != prototypeServiceH2, "prototype service")
 
   svcObjects2.UngetService(prototypeServiceH2);
   svcObjects3.UngetService(prototypeServiceH2_2);
   US_TEST_CONDITION_REQUIRED(mc->UngetService(sr1) == false, "ungetService()")
   US_TEST_CONDITION_REQUIRED(mc->UngetService(sr1) == true, "ungetService()")
 
   target.Unload();
 }
 
 int usServiceFactoryTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ServiceFactoryTest");
 
   TestServiceFactoryModuleScope();
   TestServiceFactoryPrototypeScope();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usServiceHooksTest.cpp b/Modules/CppMicroServices/core/test/usServiceHooksTest.cpp
index 3818374da0..46b4ed2a44 100644
--- a/Modules/CppMicroServices/core/test/usServiceHooksTest.cpp
+++ b/Modules/CppMicroServices/core/test/usServiceHooksTest.cpp
@@ -1,414 +1,414 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModule.h>
 #include <usModuleEvent.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usLDAPProp.h>
 #include <usServiceFindHook.h>
 #include <usServiceEventListenerHook.h>
 #include <usServiceListenerHook.h>
 #include <usSharedLibrary.h>
 
 #include "usTestingMacros.h"
 #include "usTestingConfig.h"
 
 US_USE_NAMESPACE
 
 namespace {
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
 class TestServiceListener
 {
 public:
 
   void ServiceChanged(const ServiceEvent serviceEvent)
   {
     this->events.push_back(serviceEvent);
   }
 
   std::vector<ServiceEvent> events;
 };
 
 class TestServiceEventListenerHook : public ServiceEventListenerHook
 {
 private:
 
   int id;
 
 public:
 
   TestServiceEventListenerHook(int id)
   : id(id)
   {
   }
 
   typedef ShrinkableMap<ModuleContext*, ShrinkableVector<ServiceListenerHook::ListenerInfo> > MapType;
 
   void Event(const ServiceEvent& /*event*/, MapType& listeners) override
   {
     US_TEST_CONDITION_REQUIRED(listeners.size() > 0 && listeners.find(GetModuleContext()) != listeners.end(), "Check listener content");
     ShrinkableVector<ServiceListenerHook::ListenerInfo>& listenerInfos = listeners[GetModuleContext()];
 
     // listener count should be 2 because the event listener hooks are called with
     // the list of listeners before filtering them according to ther LDAP filter
     if (id == 1)
     {
 #ifdef US_BUILD_SHARED_LIBS
       US_TEST_CONDITION(listenerInfos.size() == 2, "2 service listeners expected");
 #else
       US_TEST_CONDITION(listenerInfos.size() >= 2, "2 service listeners expected");
 #endif
       US_TEST_CONDITION(listenerInfos[0].IsRemoved() == false, "Listener is not removed");
       US_TEST_CONDITION(listenerInfos[1].IsRemoved() == false, "Listener is not removed");
       US_TEST_CONDITION(!(listenerInfos[0] == listenerInfos[1]), "listener info inequality");
     }
     else
     {
       // there is already one listener filtered out
 #ifdef US_BUILD_SHARED_LIBS
       US_TEST_CONDITION(listenerInfos.size() == 1, "1 service listener expected");
 #else
       US_TEST_CONDITION(listenerInfos.size() >= 1, "1 service listener expected");
 #endif
       US_TEST_CONDITION(listenerInfos[0].IsRemoved() == false, "Listener is not removed");
     }
     if (listenerInfo.IsNull())
     {
       listenerInfo = listenerInfos[0];
     }
     else
     {
       US_TEST_CONDITION(listenerInfo == listenerInfos[0], "Equal listener info objects");
     }
 
     // Remove the listener without a filter from the list
     for(ShrinkableVector<ServiceListenerHook::ListenerInfo>::iterator infoIter = listenerInfos.begin();
         infoIter != listenerInfos.end();)
     {
       if (infoIter->GetFilter().empty())
       {
         infoIter = listenerInfos.erase(infoIter);
       }
       else
       {
         ++infoIter;
       }
     }
 #ifdef US_BUILD_SHARED_LIBS
     US_TEST_CONDITION(listenerInfos.size() == 1, "One listener with LDAP filter should remain");
 #else
     US_TEST_CONDITION(listenerInfos.size() >= 1, "One listener with LDAP filter should remain");
 #endif
 
     ordering.push_back(id);
   }
 
   ServiceListenerHook::ListenerInfo listenerInfo;
 
   static std::vector<int> ordering;
 };
 
 std::vector<int> TestServiceEventListenerHook::ordering;
 
 
 class TestServiceFindHook : public ServiceFindHook
 {
 private:
   int id;
 
 public:
 
   TestServiceFindHook(int id)
     : id(id)
   {
   }
 
   void Find(const ModuleContext* context, const std::string& /*name*/,
             const std::string& /*filter*/, ShrinkableVector<ServiceReferenceBase>& references) override
   {
     US_TEST_CONDITION(context == GetModuleContext(), "Module context");
 
     references.clear();
     ordering.push_back(id);
   }
 
   static std::vector<int> ordering;
 };
 
 std::vector<int> TestServiceFindHook::ordering;
 
 class TestServiceListenerHook : public ServiceListenerHook
 {
 private:
   int id;
 
 public:
 
   TestServiceListenerHook(int id)
     : id(id)
   {
   }
 
   void Added(const std::vector<ListenerInfo>& listeners) override
   {
     for (std::vector<ListenerInfo>::const_iterator iter = listeners.begin();
          iter != listeners.end(); ++iter)
     {
       if (iter->IsRemoved() || iter->GetModuleContext() != GetModuleContext()) continue;
       listenerInfos.insert(*iter);
       lastAdded = listeners.back();
       ordering.push_back(id);
     }
   }
 
   void Removed(const std::vector<ListenerInfo>& listeners) override
   {
     for (std::vector<ListenerInfo>::const_iterator iter = listeners.begin();
          iter != listeners.end(); ++iter)
     {
       listenerInfos.erase(*iter);
       ordering.push_back(id*10);
     }
     lastRemoved = listeners.back();
   }
 
   static std::vector<int> ordering;
 
   US_UNORDERED_SET_TYPE<ListenerInfo> listenerInfos;
   ListenerInfo lastAdded;
   ListenerInfo lastRemoved;
 };
 
 std::vector<int> TestServiceListenerHook::ordering;
 
 
 void TestEventListenerHook()
 {
   ModuleContext* context = GetModuleContext();
 
   TestServiceListener serviceListener1;
   TestServiceListener serviceListener2;
   context->AddServiceListener(&serviceListener1, &TestServiceListener::ServiceChanged);
   context->AddServiceListener(&serviceListener2, &TestServiceListener::ServiceChanged, LDAPProp(ServiceConstants::OBJECTCLASS()) == "bla");
 
   TestServiceEventListenerHook serviceEventListenerHook1(1);
   ServiceProperties hookProps1;
   hookProps1[ServiceConstants::SERVICE_RANKING()] = 10;
   ServiceRegistration<ServiceEventListenerHook> eventListenerHookReg1 =
       context->RegisterService<ServiceEventListenerHook>(&serviceEventListenerHook1, hookProps1);
 
   TestServiceEventListenerHook serviceEventListenerHook2(2);
   ServiceProperties hookProps2;
   hookProps2[ServiceConstants::SERVICE_RANKING()] = 0;
   ServiceRegistration<ServiceEventListenerHook> eventListenerHookReg2 =
       context->RegisterService<ServiceEventListenerHook>(&serviceEventListenerHook2, hookProps2);
 
   std::vector<int> expectedOrdering;
   expectedOrdering.push_back(1);
   expectedOrdering.push_back(1);
   expectedOrdering.push_back(2);
   US_TEST_CONDITION(serviceEventListenerHook1.ordering == expectedOrdering, "Event listener hook call order");
 
   US_TEST_CONDITION(serviceListener1.events.empty(), "service event of service event listener hook");
   US_TEST_CONDITION(serviceListener2.events.empty(), "no service event for filtered listener");
 
 #ifdef US_BUILD_SHARED_LIBS
   SharedLibrary libA(LIB_PATH, "TestModuleA");
   try
   {
     libA.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 
   expectedOrdering.push_back(1);
   expectedOrdering.push_back(2);
   US_TEST_CONDITION(serviceEventListenerHook1.ordering == expectedOrdering, "Event listener hook call order");
 
   libA.Unload();
 #endif
 
   US_TEST_CONDITION(serviceListener1.events.empty(), "no service event due to service event listener hook");
   US_TEST_CONDITION(serviceListener2.events.empty(), "no service event for filtered listener due to service event listener hook");
 
   eventListenerHookReg2.Unregister();
   eventListenerHookReg1.Unregister();
 
   context->RemoveServiceListener(&serviceListener1, &TestServiceListener::ServiceChanged);
   context->RemoveServiceListener(&serviceListener2, &TestServiceListener::ServiceChanged);
 }
 
 void TestListenerHook()
 {
   ModuleContext* context = GetModuleContext();
 
   TestServiceListener serviceListener1;
   TestServiceListener serviceListener2;
   context->AddServiceListener(&serviceListener1, &TestServiceListener::ServiceChanged);
   context->AddServiceListener(&serviceListener2, &TestServiceListener::ServiceChanged, LDAPProp(ServiceConstants::OBJECTCLASS()) == "bla");
 
   TestServiceListenerHook serviceListenerHook1(1);
   ServiceProperties hookProps1;
   hookProps1[ServiceConstants::SERVICE_RANKING()] = 0;
   ServiceRegistration<ServiceListenerHook> listenerHookReg1 =
       context->RegisterService<ServiceListenerHook>(&serviceListenerHook1, hookProps1);
 
   TestServiceListenerHook serviceListenerHook2(2);
   ServiceProperties hookProps2;
   hookProps2[ServiceConstants::SERVICE_RANKING()] = 10;
   ServiceRegistration<ServiceListenerHook> listenerHookReg2 =
       context->RegisterService<ServiceListenerHook>(&serviceListenerHook2, hookProps2);
 
 #ifdef US_BUILD_SHARED_LIBS
   // check if hooks got notified about the existing listeners
   US_TEST_CONDITION_REQUIRED(serviceListenerHook1.listenerInfos.size() == 2, "Notification about existing listeners")
 #endif
   const std::size_t listenerInfoSizeOld = serviceListenerHook1.listenerInfos.size() - 2;
 
   context->AddServiceListener(&serviceListener1, &TestServiceListener::ServiceChanged);
   ServiceListenerHook::ListenerInfo lastAdded = serviceListenerHook1.lastAdded;
 
 #ifdef US_BUILD_SHARED_LIBS
   std::vector<int> expectedOrdering;
   expectedOrdering.push_back(1);
   expectedOrdering.push_back(1);
   expectedOrdering.push_back(2);
   expectedOrdering.push_back(2);
   expectedOrdering.push_back(20);
   expectedOrdering.push_back(10);
   expectedOrdering.push_back(2);
   expectedOrdering.push_back(1);
   US_TEST_CONDITION(serviceListenerHook1.ordering == expectedOrdering, "Listener hook call order");
 #endif
 
   context->AddServiceListener(&serviceListener1, &TestServiceListener::ServiceChanged, LDAPProp(ServiceConstants::OBJECTCLASS()) == "blub");
   US_TEST_CONDITION(lastAdded == serviceListenerHook1.lastRemoved, "Same ListenerInfo object)");
   US_TEST_CONDITION(!(lastAdded == serviceListenerHook1.lastAdded), "New ListenerInfo object)");
 
 #ifdef US_BUILD_SHARED_LIBS
   expectedOrdering.push_back(20);
   expectedOrdering.push_back(10);
   expectedOrdering.push_back(2);
   expectedOrdering.push_back(1);
   US_TEST_CONDITION(serviceListenerHook1.ordering == expectedOrdering, "Listener hook call order");
 #endif
 
   context->RemoveServiceListener(&serviceListener1, &TestServiceListener::ServiceChanged);
   context->RemoveServiceListener(&serviceListener2, &TestServiceListener::ServiceChanged);
 
 #ifdef US_BUILD_SHARED_LIBS
   expectedOrdering.push_back(20);
   expectedOrdering.push_back(10);
   expectedOrdering.push_back(20);
   expectedOrdering.push_back(10);
   US_TEST_CONDITION(serviceListenerHook1.ordering == expectedOrdering, "Listener hook call order");
 #endif
 
   US_TEST_CONDITION_REQUIRED(serviceListenerHook1.listenerInfos.size() == listenerInfoSizeOld, "Removed listener infos")
 
   listenerHookReg2.Unregister();
   listenerHookReg1.Unregister();
 }
 
 void TestFindHook()
 {
   ModuleContext* context = GetModuleContext();
 
   TestServiceFindHook serviceFindHook1(1);
   ServiceProperties hookProps1;
   hookProps1[ServiceConstants::SERVICE_RANKING()] = 0;
   ServiceRegistration<ServiceFindHook> findHookReg1 =
       context->RegisterService<ServiceFindHook>(&serviceFindHook1, hookProps1);
 
   TestServiceFindHook serviceFindHook2(2);
   ServiceProperties hookProps2;
   hookProps2[ServiceConstants::SERVICE_RANKING()] = 10;
   ServiceRegistration<ServiceFindHook> findHookReg2 =
       context->RegisterService<ServiceFindHook>(&serviceFindHook2, hookProps2);
 
   std::vector<int> expectedOrdering;
   US_TEST_CONDITION(serviceFindHook1.ordering == expectedOrdering, "Find hook call order");
 
   TestServiceListener serviceListener;
   context->AddServiceListener(&serviceListener, &TestServiceListener::ServiceChanged);
 
 #ifdef US_BUILD_SHARED_LIBS
   SharedLibrary libA(LIB_PATH, "TestModuleA");
   try
   {
     libA.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 
   US_TEST_CONDITION(serviceListener.events.size() == 1, "Service registered");
 #endif
 
   std::vector<ServiceReferenceU> refs = context->GetServiceReferences("us::TestModuleAService");
   US_TEST_CONDITION(refs.empty(), "Empty references");
   ServiceReferenceU ref = context->GetServiceReference("us::TestModuleAService");
   US_TEST_CONDITION(!ref, "Invalid reference (filtered out)");
 
   expectedOrdering.push_back(2);
   expectedOrdering.push_back(1);
   expectedOrdering.push_back(2);
   expectedOrdering.push_back(1);
 
   US_TEST_CONDITION(serviceFindHook1.ordering == expectedOrdering, "Find hook call order");
 
   findHookReg2.Unregister();
   findHookReg1.Unregister();
 
   refs = context->GetServiceReferences("us::TestModuleAService");
   US_TEST_CONDITION(!refs.empty(), "Non-empty references");
   ref = context->GetServiceReference("us::TestModuleAService");
   US_TEST_CONDITION(ref, "Valid reference");
 
 #ifdef US_BUILD_SHARED_LIBS
   libA.Unload();
 #endif
 
   context->RemoveServiceListener(&serviceListener, &TestServiceListener::ServiceChanged);
 }
 
 } // end unnamed namespace
 
 int usServiceHooksTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ServiceHooksTest");
 
   TestListenerHook();
   TestFindHook();
   TestEventListenerHook();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usServiceListenerTest.cpp b/Modules/CppMicroServices/core/test/usServiceListenerTest.cpp
index fe8ac3a2eb..cd80f8e2bb 100644
--- a/Modules/CppMicroServices/core/test/usServiceListenerTest.cpp
+++ b/Modules/CppMicroServices/core/test/usServiceListenerTest.cpp
@@ -1,565 +1,565 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usTestingMacros.h>
 #include <usTestingConfig.h>
 
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usSharedLibrary.h>
 
 #include <usModulePropsInterface.h>
 
 US_USE_NAMESPACE
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
 class TestServiceListener
 {
 
 private:
 
   friend bool runLoadUnloadTest(const std::string&, int cnt, SharedLibrary&,
                                 const std::vector<ServiceEvent::Type>&);
 
   const bool checkUsingModules;
   std::vector<ServiceEvent> events;
 
   bool teststatus;
 
   ModuleContext* mc;
 
 public:
 
   TestServiceListener(ModuleContext* mc, bool checkUsingModules = true)
     : checkUsingModules(checkUsingModules), events(), teststatus(true), mc(mc)
   {}
 
   bool getTestStatus() const
   {
     return teststatus;
   }
 
   void clearEvents()
   {
     events.clear();
   }
 
   bool checkEvents(const std::vector<ServiceEvent::Type>& eventTypes)
   {
     if (events.size() != eventTypes.size())
     {
       dumpEvents(eventTypes);
       return false;
     }
 
     for (std::size_t i=0; i < eventTypes.size(); ++i)
     {
       if (eventTypes[i] != events[i].GetType())
       {
         dumpEvents(eventTypes);
         return false;
       }
     }
     return true;
   }
 
   void serviceChanged(const ServiceEvent evt)
   {
     events.push_back(evt);
     US_TEST_OUTPUT( << "ServiceEvent: " << evt );
     if (ServiceEvent::UNREGISTERING == evt.GetType())
     {
       ServiceReferenceU sr = evt.GetServiceReference();
 
       // Validate that no module is marked as using the service
       std::vector<Module*> usingModules;
       sr.GetUsingModules(usingModules);
       if (checkUsingModules && !usingModules.empty())
       {
         teststatus = false;
         printUsingModules(sr, "*** Using modules (unreg) should be empty but is: ");
       }
 
       // Check if the service can be fetched
       InterfaceMap service = mc->GetService(sr);
       sr.GetUsingModules(usingModules);
       // if (UNREGISTERSERVICE_VALID_DURING_UNREGISTERING) {
       // In this mode the service shall be obtainable during
       // unregistration.
       if (service.empty())
       {
         teststatus = false;
         US_TEST_OUTPUT( << "*** Service should be available to ServiceListener "
                           << "while handling unregistering event." );
       }
       US_TEST_OUTPUT( << "Service (unreg): " << service.begin()->first << " -> " << service.begin()->second );
       if (checkUsingModules && usingModules.size() != 1)
       {
         teststatus = false;
         printUsingModules(sr, "*** One using module expected "
                           "(unreg, after getService), found: ");
       }
       else
       {
         printUsingModules(sr, "Using modules (unreg, after getService): ");
       }
       //    } else {
       //      // In this mode the service shall NOT be obtainable during
       //      // unregistration.
       //      if (null!=service) {
       //        teststatus = false;
       //        out.print("*** Service should not be available to ServiceListener "
       //                  +"while handling unregistering event.");
       //      }
       //      if (checkUsingBundles && null!=usingBundles) {
       //        teststatus = false;
       //        printUsingBundles(sr,
       //                          "*** Using bundles (unreg, after getService), "
       //                          +"should be null but is: ");
       //      } else {
       //        printUsingBundles(sr,
       //                          "Using bundles (unreg, after getService): null");
       //      }
       //    }
       mc->UngetService(sr);
 
       // Check that the UNREGISTERING service can not be looked up
       // using the service registry.
       try
       {
         long sid = any_cast<long>(sr.GetProperty(ServiceConstants::SERVICE_ID()));
         std::stringstream ss;
         ss << "(" << ServiceConstants::SERVICE_ID() << "=" << sid << ")";
         std::vector<ServiceReferenceU> srs = mc->GetServiceReferences("", ss.str());
         if (srs.empty())
         {
           US_TEST_OUTPUT( << "ServiceReference for UNREGISTERING service is not"
                             " found in the service registry; ok." );
         }
         else
         {
           teststatus = false;
           US_TEST_OUTPUT( << "*** ServiceReference for UNREGISTERING service,"
                             << sr << ", not found in the service registry; fail." );
           US_TEST_OUTPUT( << "Found the following Service references:") ;
           for(std::vector<ServiceReferenceU>::const_iterator sr = srs.begin();
               sr != srs.end(); ++sr)
           {
             US_TEST_OUTPUT( << (*sr) );
           }
         }
       }
       catch (const std::exception& e)
       {
         teststatus = false;
         US_TEST_OUTPUT( << "*** Unexpected excpetion when trying to lookup a"
                           " service while it is in state UNREGISTERING: "
                           << e.what() );
       }
     }
   }
 
   void printUsingModules(const ServiceReferenceU& sr, const std::string& caption)
   {
     std::vector<Module*> usingModules;
     sr.GetUsingModules(usingModules);
 
     US_TEST_OUTPUT( << (caption.empty() ? "Using modules: " : caption) );
     for(std::vector<Module*>::const_iterator module = usingModules.begin();
         module != usingModules.end(); ++module)
     {
       US_TEST_OUTPUT( << "  -" << (*module) );
     }
   }
 
   // Print expected and actual service events.
   void dumpEvents(const std::vector<ServiceEvent::Type>& eventTypes)
   {
     std::size_t max = events.size() > eventTypes.size() ? events.size() : eventTypes.size();
     US_TEST_OUTPUT( << "Expected event type --  Actual event" );
     for (std::size_t i=0; i < max; ++i)
     {
       ServiceEvent evt = i < events.size() ? events[i] : ServiceEvent();
       if (i < eventTypes.size())
       {
         US_TEST_OUTPUT( << " " << eventTypes[i] << "--" << evt );
       }
       else
       {
         US_TEST_OUTPUT( << " " << "- NONE - " << "--" << evt );
       }
     }
   }
 
 }; // end of class ServiceListener
 
 bool runLoadUnloadTest(const std::string& name, int cnt, SharedLibrary& target,
                        const std::vector<ServiceEvent::Type>& events)
 {
   bool teststatus = true;
 
   ModuleContext* mc = GetModuleContext();
 
   for (int i = 0; i < cnt && teststatus; ++i)
   {
     TestServiceListener sListen(mc);
     try
     {
       mc->AddServiceListener(&sListen, &TestServiceListener::serviceChanged);
       //mc->AddServiceListener(MessageDelegate1<ServiceListener, const ServiceEvent&>(&sListen, &ServiceListener::serviceChanged));
     }
     catch (const std::logic_error& ise)
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "service listener registration failed " << ise.what()
                           << " :" << name << ":FAIL" );
     }
 
     // Start the test target to get a service published.
     try
     {
       target.Load();
     }
     catch (const std::exception& e)
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "Failed to load module, got exception: "
                           << e.what() << " + in " << name << ":FAIL" );
     }
 
     // Stop the test target to get a service unpublished.
     try
     {
       target.Unload();
     }
     catch (const std::exception& e)
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "Failed to unload module, got exception: "
                           << e.what() << " + in " << name << ":FAIL" );
     }
 
     if (teststatus && !sListen.checkEvents(events))
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "Service listener event notification error :"
                           << name << ":FAIL" );
     }
 
     try
     {
       mc->RemoveServiceListener(&sListen, &TestServiceListener::serviceChanged);
       teststatus &= sListen.teststatus;
       sListen.clearEvents();
     }
     catch (const std::logic_error& ise)
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "service listener removal failed " << ise.what()
                           << " :" << name << ":FAIL" );
     }
   }
   return teststatus;
 }
 
 void frameSL02a()
 {
   ModuleContext* mc = GetModuleContext();
 
   TestServiceListener listener1(mc);
   TestServiceListener listener2(mc);
 
   try
   {
     mc->RemoveServiceListener(&listener1, &TestServiceListener::serviceChanged);
     mc->AddServiceListener(&listener1, &TestServiceListener::serviceChanged);
     mc->RemoveServiceListener(&listener2, &TestServiceListener::serviceChanged);
     mc->AddServiceListener(&listener2, &TestServiceListener::serviceChanged);
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_FAILED_MSG( << "service listener registration failed " << ise.what()
                         << " : frameSL02a:FAIL" );
   }
 
   SharedLibrary target(LIB_PATH, "TestModuleA");
 
   // Start the test target to get a service published.
   try
   {
     target.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG( << "Failed to load module, got exception: "
                         << e.what() << " + in frameSL02a:FAIL" );
   }
 
   std::vector<ServiceEvent::Type> events;
   events.push_back(ServiceEvent::REGISTERED);
 
   US_TEST_CONDITION(listener1.checkEvents(events), "Check first service listener")
   US_TEST_CONDITION(listener2.checkEvents(events), "Check second service listener")
 
   mc->RemoveServiceListener(&listener1, &TestServiceListener::serviceChanged);
   mc->RemoveServiceListener(&listener2, &TestServiceListener::serviceChanged);
 
   target.Unload();
 }
 
 void frameSL05a()
 {
   std::vector<ServiceEvent::Type> events;
   events.push_back(ServiceEvent::REGISTERED);
   events.push_back(ServiceEvent::UNREGISTERING);
   SharedLibrary libA(LIB_PATH, "TestModuleA");
   bool testStatus = runLoadUnloadTest("FrameSL05a", 1, libA, events);
   US_TEST_CONDITION(testStatus, "FrameSL05a")
 }
 
 void frameSL10a()
 {
   std::vector<ServiceEvent::Type> events;
   events.push_back(ServiceEvent::REGISTERED);
   events.push_back(ServiceEvent::UNREGISTERING);
   SharedLibrary libA2(LIB_PATH, "TestModuleA2");
   bool testStatus = runLoadUnloadTest("FrameSL10a", 1, libA2, events);
   US_TEST_CONDITION(testStatus, "FrameSL10a")
 }
 
 void frameSL25a()
 {
   ModuleContext* mc = GetModuleContext();
 
   TestServiceListener sListen(mc, false);
   try
   {
     mc->AddServiceListener(&sListen, &TestServiceListener::serviceChanged);
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_OUTPUT( << "service listener registration failed " << ise.what() );
     throw;
   }
 
   SharedLibrary libSL1(LIB_PATH, "TestModuleSL1");
   SharedLibrary libSL3(LIB_PATH, "TestModuleSL3");
   SharedLibrary libSL4(LIB_PATH, "TestModuleSL4");
 
   std::vector<ServiceEvent::Type> expectedServiceEventTypes;
 
   // Startup
   expectedServiceEventTypes.push_back(ServiceEvent::REGISTERED); // at start of libSL1
   expectedServiceEventTypes.push_back(ServiceEvent::REGISTERED); // FooService at start of libSL4
   expectedServiceEventTypes.push_back(ServiceEvent::REGISTERED); // at start of libSL3
 
   // Stop libSL4
   expectedServiceEventTypes.push_back(ServiceEvent::UNREGISTERING); // FooService at first stop of libSL4
 
 #ifdef US_BUILD_SHARED_LIBS
   // Shutdown
   expectedServiceEventTypes.push_back(ServiceEvent::UNREGISTERING); // at stop of libSL1
   expectedServiceEventTypes.push_back(ServiceEvent::UNREGISTERING); // at stop of libSL3
 #endif
 
   // Start libModuleTestSL1 to ensure that the Service interface is available.
   try
   {
     US_TEST_OUTPUT( << "Starting libModuleTestSL1: " << libSL1.GetFilePath() );
     libSL1.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to load module, got exception: " << e.what() );
     throw;
   }
 
   // Start libModuleTestSL4 that will require the serivce interface and publish
   // us::FooService
   try
   {
     US_TEST_OUTPUT( << "Starting libModuleTestSL4: " << libSL4.GetFilePath() );
     libSL4.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to load module, got exception: " << e.what() );
     throw;
   }
 
   // Start libModuleTestSL3 that will require the serivce interface and get the service
   try
   {
     US_TEST_OUTPUT( << "Starting libModuleTestSL3: " << libSL3.GetFilePath() );
     libSL3.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to load module, got exception: " << e.what() );
     throw;
   }
 
   // Check that libSL3 has been notified about the FooService.
   US_TEST_OUTPUT( << "Check that FooService is added to service tracker in libSL3" );
   try
   {
     ServiceReferenceU libSL3SR = mc->GetServiceReference("ActivatorSL3");
     InterfaceMap libSL3Activator = mc->GetService(libSL3SR);
     US_TEST_CONDITION_REQUIRED(!libSL3Activator.empty(), "ActivatorSL3 service != 0");
 
     ServiceReference<ModulePropsInterface> libSL3PropsI(libSL3SR);
     ModulePropsInterface* propsInterface = mc->GetService(libSL3PropsI);
     US_TEST_CONDITION_REQUIRED(propsInterface, "ModulePropsInterface != 0");
 
     ModulePropsInterface::Properties::const_iterator i = propsInterface->GetProperties().find("serviceAdded");
     US_TEST_CONDITION_REQUIRED(i != propsInterface->GetProperties().end(), "Property serviceAdded");
     Any serviceAddedField3 = i->second;
     US_TEST_CONDITION_REQUIRED(!serviceAddedField3.Empty() && any_cast<bool>(serviceAddedField3),
                                  "libSL3 notified about presence of FooService");
     mc->UngetService(libSL3SR);
   }
   catch (const ServiceException& se)
   {
     US_TEST_FAILED_MSG( << "Failed to get service reference:" << se );
   }
 
   // Check that libSL1 has been notified about the FooService.
   US_TEST_OUTPUT( << "Check that FooService is added to service tracker in libSL1" );
   try
   {
     ServiceReferenceU libSL1SR = mc->GetServiceReference("ActivatorSL1");
     InterfaceMap libSL1Activator = mc->GetService(libSL1SR);
     US_TEST_CONDITION_REQUIRED(!libSL1Activator.empty(), "ActivatorSL1 service != 0");
 
     ServiceReference<ModulePropsInterface> libSL1PropsI(libSL1SR);
     ModulePropsInterface* propsInterface = mc->GetService(libSL1PropsI);
     US_TEST_CONDITION_REQUIRED(propsInterface, "Cast to ModulePropsInterface");
 
     ModulePropsInterface::Properties::const_iterator i = propsInterface->GetProperties().find("serviceAdded");
     US_TEST_CONDITION_REQUIRED(i != propsInterface->GetProperties().end(), "Property serviceAdded");
     Any serviceAddedField1 = i->second;
     US_TEST_CONDITION_REQUIRED(!serviceAddedField1.Empty() && any_cast<bool>(serviceAddedField1),
                                  "libSL1 notified about presence of FooService");
     mc->UngetService(libSL1SR);
   }
   catch (const ServiceException& se)
   {
     US_TEST_FAILED_MSG( << "Failed to get service reference:" << se );
   }
 
   // Stop the service provider: libSL4
   try
   {
     US_TEST_OUTPUT( << "Stop libSL4: " << libSL4.GetFilePath() );
     libSL4.Unload();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to unload module, got exception:" << e.what() );
     throw;
   }
 
   // Check that libSL3 has been notified about the removal of FooService.
   US_TEST_OUTPUT( << "Check that FooService is removed from service tracker in libSL3" );
   try
   {
     ServiceReferenceU libSL3SR = mc->GetServiceReference("ActivatorSL3");
     InterfaceMap libSL3Activator = mc->GetService(libSL3SR);
     US_TEST_CONDITION_REQUIRED(!libSL3Activator.empty(), "ActivatorSL3 service != 0");
 
     ServiceReference<ModulePropsInterface> libSL3PropsI(libSL3SR);
     ModulePropsInterface* propsInterface = mc->GetService(libSL3PropsI);
     US_TEST_CONDITION_REQUIRED(propsInterface, "Cast to ModulePropsInterface");
 
     ModulePropsInterface::Properties::const_iterator i = propsInterface->GetProperties().find("serviceRemoved");
     US_TEST_CONDITION_REQUIRED(i != propsInterface->GetProperties().end(), "Property serviceRemoved");
 
     Any serviceRemovedField3 = i->second;
     US_TEST_CONDITION(!serviceRemovedField3.Empty() && any_cast<bool>(serviceRemovedField3),
                         "libSL3 notified about removal of FooService");
     mc->UngetService(libSL3SR);
   }
   catch (const ServiceException& se)
   {
     US_TEST_FAILED_MSG( << "Failed to get service reference:" << se );
   }
 
   // Stop libSL1
   try
   {
     US_TEST_OUTPUT( << "Stop libSL1:" << libSL1.GetFilePath() );
     libSL1.Unload();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to unload module got exception" << e.what() );
     throw;
   }
 
   // Stop pSL3
   try
   {
     US_TEST_OUTPUT( << "Stop libSL3:" << libSL3.GetFilePath() );
     libSL3.Unload();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to unload module got exception" << e.what() );
     throw;
   }
 
   // Check service events seen by this class
   US_TEST_OUTPUT( << "Checking ServiceEvents(ServiceListener):" );
   if (!sListen.checkEvents(expectedServiceEventTypes))
   {
     US_TEST_FAILED_MSG( << "Service listener event notification error" );
   }
 
   US_TEST_CONDITION_REQUIRED(sListen.getTestStatus(), "Service listener checks");
   try
   {
     mc->RemoveServiceListener(&sListen, &TestServiceListener::serviceChanged);
     sListen.clearEvents();
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_FAILED_MSG( << "service listener removal failed: " << ise.what() );
   }
 
 }
 
 int usServiceListenerTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ServiceListenerTest");
 
   frameSL02a();
   frameSL05a();
   frameSL10a();
   frameSL25a();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usServiceRegistryPerformanceTest.cpp b/Modules/CppMicroServices/core/test/usServiceRegistryPerformanceTest.cpp
index f763e0cdf2..2ffa3f0998 100644
--- a/Modules/CppMicroServices/core/test/usServiceRegistryPerformanceTest.cpp
+++ b/Modules/CppMicroServices/core/test/usServiceRegistryPerformanceTest.cpp
@@ -1,428 +1,428 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usTestingMacros.h"
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 US_USE_NAMESPACE
 
 #ifdef US_PLATFORM_APPLE
 #include <mach/mach_time.h>
 #elif defined(US_PLATFORM_POSIX)
 #include <ctime>
 #include <unistd.h>
 #ifndef _POSIX_MONOTONIC_CLOCK
 #error Monotonic clock support missing on this POSIX platform
 #endif
 #elif defined(US_PLATFORM_WINDOWS)
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
 #ifndef VC_EXTRA_LEAN
 #define VC_EXTRA_LEAN
 #endif
 #include <windows.h>
 #else
 #error High precision timer support nod available on this platform
 #endif
 
 #include <vector>
 
 class HighPrecisionTimer
 {
 
 public:
 
   inline HighPrecisionTimer();
 
   inline void Start();
 
   inline long long ElapsedMilli();
 
   inline long long ElapsedMicro();
 
 private:
 
 #ifdef US_PLATFORM_APPLE
   static double timeConvert;
   uint64_t startTime;
 #elif defined(US_PLATFORM_POSIX)
   timespec startTime;
 #elif defined(US_PLATFORM_WINDOWS)
   LARGE_INTEGER timerFrequency;
   LARGE_INTEGER startTime;
 #endif
 };
 
 #ifdef US_PLATFORM_APPLE
 
 double HighPrecisionTimer::timeConvert = 0.0;
 
 inline HighPrecisionTimer::HighPrecisionTimer()
 : startTime(0)
 {
   if (timeConvert == 0)
   {
     mach_timebase_info_data_t timeBase;
     mach_timebase_info(&timeBase);
     timeConvert = static_cast<double>(timeBase.numer) / static_cast<double>(timeBase.denom) / 1000.0;
   }
 }
 
 inline void HighPrecisionTimer::Start()
 {
   startTime = mach_absolute_time();
 }
 
 inline long long HighPrecisionTimer::ElapsedMilli()
 {
   uint64_t current = mach_absolute_time();
   return static_cast<double>(current - startTime) * timeConvert / 1000.0;
 }
 
 inline long long HighPrecisionTimer::ElapsedMicro()
 {
   uint64_t current = mach_absolute_time();
   return static_cast<double>(current - startTime) * timeConvert;
 }
 
 #elif defined(US_PLATFORM_POSIX)
 
 inline HighPrecisionTimer::HighPrecisionTimer()
 {
   startTime.tv_nsec = 0;
   startTime.tv_sec = 0;
 }
 
 inline void HighPrecisionTimer::Start()
 {
   clock_gettime(CLOCK_MONOTONIC, &startTime);
 }
 
 inline long long HighPrecisionTimer::ElapsedMilli()
 {
   timespec current;
   clock_gettime(CLOCK_MONOTONIC, &current);
   return (static_cast<long long>(current.tv_sec)*1000 + current.tv_nsec/1000/1000) -
       (static_cast<long long>(startTime.tv_sec)*1000 + startTime.tv_nsec/1000/1000);
 }
 
 inline long long HighPrecisionTimer::ElapsedMicro()
 {
   timespec current;
   clock_gettime(CLOCK_MONOTONIC, &current);
   return (static_cast<long long>(current.tv_sec)*1000*1000 + current.tv_nsec/1000) -
       (static_cast<long long>(startTime.tv_sec)*1000*1000 + startTime.tv_nsec/1000);
 }
 
 #elif defined(US_PLATFORM_WINDOWS)
 
 inline HighPrecisionTimer::HighPrecisionTimer()
 {
   if (!QueryPerformanceFrequency(&timerFrequency))
     throw std::runtime_error("QueryPerformanceFrequency() failed");
 }
 
 inline void HighPrecisionTimer::Start()
 {
   //DWORD_PTR oldmask = SetThreadAffinityMask(GetCurrentThread(), 0);
   QueryPerformanceCounter(&startTime);
   //SetThreadAffinityMask(GetCurrentThread(), oldmask);
 }
 
 inline long long HighPrecisionTimer::ElapsedMilli()
 {
   LARGE_INTEGER current;
   QueryPerformanceCounter(&current);
   return (current.QuadPart - startTime.QuadPart) / (timerFrequency.QuadPart / 1000);
 }
 
 inline long long HighPrecisionTimer::ElapsedMicro()
 {
   LARGE_INTEGER current;
   QueryPerformanceCounter(&current);
   return (current.QuadPart - startTime.QuadPart) / (timerFrequency.QuadPart / (1000*1000));
 }
 
 #endif
 
 class MyServiceListener;
 
 struct IPerfTestService
 {
   virtual ~IPerfTestService() {}
 };
 
 
 class ServiceRegistryPerformanceTest
 {
 
 private:
 
   friend class MyServiceListener;
 
   ModuleContext* mc;
 
   int nListeners;
   int nServices;
 
   std::size_t nRegistered;
   std::size_t nUnregistering;
   std::size_t nModified;
 
   std::vector<ServiceRegistration<IPerfTestService> > regs;
   std::vector<MyServiceListener*> listeners;
   std::vector<IPerfTestService*> services;
 
 public:
 
   ServiceRegistryPerformanceTest(ModuleContext* context);
 
   void InitTestCase();
   void CleanupTestCase();
 
   void TestAddListeners();
   void TestRegisterServices();
 
   void TestModifyServices();
   void TestUnregisterServices();
 
 private:
 
   std::ostream& Log() const
   {
     return std::cout;
   }
 
   void AddListeners(int n);
   void RegisterServices(int n);
   void ModifyServices();
   void UnregisterServices();
 
 };
 
 class MyServiceListener
 {
 
 private:
 
   ServiceRegistryPerformanceTest* ts;
 
 public:
 
   MyServiceListener(ServiceRegistryPerformanceTest* ts)
     : ts(ts)
   {
   }
 
   void ServiceChanged(const ServiceEvent ev)
   {
     switch(ev.GetType())
     {
     case ServiceEvent::REGISTERED:
       ts->nRegistered++;
       break;
     case ServiceEvent::UNREGISTERING:
       ts->nUnregistering++;
       break;
     case ServiceEvent::MODIFIED:
       ts->nModified++;
       break;
     default:
       break;
     }
   }
 };
 
 
 ServiceRegistryPerformanceTest::ServiceRegistryPerformanceTest(ModuleContext* context)
   : mc(context)
   , nListeners(100)
   , nServices(1000)
   , nRegistered(0)
   , nUnregistering(0)
   , nModified(0)
 {
 }
 
 void ServiceRegistryPerformanceTest::InitTestCase()
 {
   Log() << "Initialize event counters\n";
 
   nRegistered    = 0;
   nUnregistering = 0;
   nModified      = 0;
 }
 
 void ServiceRegistryPerformanceTest::CleanupTestCase()
 {
   Log() << "Remove all service listeners\n";
 
   for(std::size_t i = 0; i < listeners.size(); i++)
   {
     try
     {
       MyServiceListener* l = listeners[i];
       mc->RemoveServiceListener(l, &MyServiceListener::ServiceChanged);
       delete l;
     }
     catch (const std::exception& e)
     {
       Log() << e.what();
     }
   }
   listeners.clear();
 }
 
 void ServiceRegistryPerformanceTest::TestAddListeners()
 {
   AddListeners(nListeners);
 }
 
 void ServiceRegistryPerformanceTest::AddListeners(int n)
 {
   Log() << "adding " << n << " service listeners\n";
   for(int i = 0; i < n; i++)
   {
     MyServiceListener* l = new MyServiceListener(this);
     try
     {
       listeners.push_back(l);
       mc->AddServiceListener(l, &MyServiceListener::ServiceChanged, "(perf.service.value>=0)");
     }
     catch (const std::exception& e)
     {
       Log() << e.what();
     }
   }
   Log() << "listener count=" << listeners.size() << "\n";
 }
 
 void ServiceRegistryPerformanceTest::TestRegisterServices()
 {
   Log() << "Register services, and check that we get #of services ("
         << nServices << ") * #of listeners (" << nListeners << ")  REGISTERED events\n";
 
   Log() << "registering " << nServices << " services, listener count=" << listeners.size() << "\n";
 
   HighPrecisionTimer t;
   t.Start();
   RegisterServices(nServices);
   long long ms = t.ElapsedMilli();
   Log() << "register took " << ms << "ms\n";
   US_TEST_CONDITION_REQUIRED(nServices * listeners.size() == nRegistered,
                              "# REGISTERED events must be same as # of registered services  * # of listeners");
 }
 
 void ServiceRegistryPerformanceTest::RegisterServices(int n)
 {
   class PerfTestService : public IPerfTestService
   {
   };
 
   std::string pid("my.service.");
 
   for(int i = 0; i < n; i++)
   {
     ServiceProperties props;
     std::stringstream ss;
     ss << pid << i;
     props["service.pid"] = ss.str();
     props["perf.service.value"] = i+1;
 
     PerfTestService* service = new PerfTestService();
     services.push_back(service);
     ServiceRegistration<IPerfTestService> reg =
         mc->RegisterService<IPerfTestService>(service, props);
     regs.push_back(reg);
   }
 }
 
 void ServiceRegistryPerformanceTest::TestModifyServices()
 {
   Log() << "Modify all services, and check that we get #of services ("
         << nServices << ") * #of listeners (" << nListeners << ")  MODIFIED events\n";
 
   HighPrecisionTimer t;
   t.Start();
   ModifyServices();
   long long ms = t.ElapsedMilli();
   Log() << "modify took " << ms << "ms\n";
   US_TEST_CONDITION_REQUIRED(nServices * listeners.size() == nModified,
                              "# MODIFIED events must be same as # of modified services  * # of listeners");
 }
 
 void ServiceRegistryPerformanceTest::ModifyServices()
 {
   Log() << "modifying " << regs.size() << " services, listener count=" << listeners.size() << "\n";
 
   for(std::size_t i = 0; i < regs.size(); i++)
   {
     ServiceRegistration<IPerfTestService> reg = regs[i];
     ServiceProperties props;
     props["perf.service.value"] = i * 2;
     reg.SetProperties(props);
   }
 }
 
 void ServiceRegistryPerformanceTest::TestUnregisterServices()
 {
   Log() << "Unregister all services, and check that we get #of services ("
         << nServices << ") * #of listeners (" << nListeners
         << ")  UNREGISTERING events\n";
 
   HighPrecisionTimer t;
   t.Start();
   UnregisterServices();
   long long ms = t.ElapsedMilli();
   Log() <<  "unregister took " << ms << "ms\n";
   US_TEST_CONDITION_REQUIRED(nServices * listeners.size() == nUnregistering, "# UNREGISTERING events must be same as # of (un)registered services * # of listeners");
 }
 
 void ServiceRegistryPerformanceTest::UnregisterServices()
 {
   Log() << "unregistering " << regs.size() << " services, listener count="
         << listeners.size() << "\n";
   for(std::size_t i = 0; i < regs.size(); i++)
   {
     ServiceRegistration<IPerfTestService> reg = regs[i];
     reg.Unregister();
   }
   regs.clear();
 }
 
 
 int usServiceRegistryPerformanceTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ServiceRegistryPerformanceTest")
 
   ServiceRegistryPerformanceTest perfTest(GetModuleContext());
   perfTest.InitTestCase();
   perfTest.TestAddListeners();
   perfTest.TestRegisterServices();
   perfTest.TestModifyServices();
   perfTest.TestUnregisterServices();
   perfTest.CleanupTestCase();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usServiceRegistryTest.cpp b/Modules/CppMicroServices/core/test/usServiceRegistryTest.cpp
index c25fe315cf..0f39a6afae 100644
--- a/Modules/CppMicroServices/core/test/usServiceRegistryTest.cpp
+++ b/Modules/CppMicroServices/core/test/usServiceRegistryTest.cpp
@@ -1,140 +1,140 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usLDAPFilter.h>
 
 #include "usTestingMacros.h"
 #include <usServiceInterface.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 #include <stdexcept>
 
 US_USE_NAMESPACE
 
 struct ITestServiceA
 {
   virtual ~ITestServiceA() {}
 };
 
 
 void TestServiceInterfaceId()
 {
   US_TEST_CONDITION(us_service_interface_iid<int>() == "int", "Service interface id int")
   US_TEST_CONDITION(us_service_interface_iid<ITestServiceA>() == "ITestServiceA", "Service interface id ITestServiceA")
 }
 
 void TestMultipleServiceRegistrations()
 {
   struct TestServiceA : public ITestServiceA
   {
   };
 
   ModuleContext* context = GetModuleContext();
 
   TestServiceA s1;
   TestServiceA s2;
 
   ServiceRegistration<ITestServiceA> reg1 = context->RegisterService<ITestServiceA>(&s1);
   ServiceRegistration<ITestServiceA> reg2 = context->RegisterService<ITestServiceA>(&s2);
 
   std::vector<ServiceReference<ITestServiceA> > refs = context->GetServiceReferences<ITestServiceA>();
   US_TEST_CONDITION_REQUIRED(refs.size() == 2, "Testing for two registered ITestServiceA services")
 
   reg2.Unregister();
   refs = context->GetServiceReferences<ITestServiceA>();
   US_TEST_CONDITION_REQUIRED(refs.size() == 1, "Testing for one registered ITestServiceA services")
 
   reg1.Unregister();
   refs = context->GetServiceReferences<ITestServiceA>();
   US_TEST_CONDITION_REQUIRED(refs.empty(), "Testing for no ITestServiceA services")
 
   ServiceReference<ITestServiceA> ref = context->GetServiceReference<ITestServiceA>();
   US_TEST_CONDITION_REQUIRED(!ref, "Testing for invalid service reference")
 }
 
 void TestServicePropertiesUpdate()
 {
   struct TestServiceA : public ITestServiceA
   {
   };
 
   ModuleContext* context = GetModuleContext();
 
   TestServiceA s1;
   ServiceProperties props;
   props["string"] = std::string("A std::string");
   props["bool"] = false;
   const char* str = "A const char*";
   props["const char*"] = str;
 
   ServiceRegistration<ITestServiceA> reg1 = context->RegisterService<ITestServiceA>(&s1, props);
   ServiceReference<ITestServiceA> ref1 = context->GetServiceReference<ITestServiceA>();
 
   US_TEST_CONDITION_REQUIRED(context->GetServiceReferences<ITestServiceA>().size() == 1, "Testing service count")
   US_TEST_CONDITION_REQUIRED(any_cast<bool>(ref1.GetProperty("bool")) == false, "Testing bool property")
 
   // register second service with higher rank
   TestServiceA s2;
   ServiceProperties props2;
   props2[ServiceConstants::SERVICE_RANKING()] = 50;
 
   ServiceRegistration<ITestServiceA> reg2 = context->RegisterService<ITestServiceA>(&s2, props2);
 
   // Get the service with the highest rank, this should be s2.
   ServiceReference<ITestServiceA> ref2 = context->GetServiceReference<ITestServiceA>();
   TestServiceA* service = dynamic_cast<TestServiceA*>(context->GetService(ref2));
   US_TEST_CONDITION_REQUIRED(service == &s2, "Testing highest service rank")
 
   props["bool"] = true;
   // change the service ranking
   props[ServiceConstants::SERVICE_RANKING()] = 100;
   reg1.SetProperties(props);
 
   US_TEST_CONDITION_REQUIRED(context->GetServiceReferences<ITestServiceA>().size() == 2, "Testing service count")
   US_TEST_CONDITION_REQUIRED(any_cast<bool>(ref1.GetProperty("bool")) == true, "Testing bool property")
   US_TEST_CONDITION_REQUIRED(any_cast<int>(ref1.GetProperty(ServiceConstants::SERVICE_RANKING())) == 100, "Testing updated ranking")
 
   // Service with the highest ranking should now be s1
   service = dynamic_cast<TestServiceA*>(context->GetService<ITestServiceA>(ref1));
   US_TEST_CONDITION_REQUIRED(service == &s1, "Testing highest service rank")
 
   reg1.Unregister();
   US_TEST_CONDITION_REQUIRED(context->GetServiceReferences<ITestServiceA>("").size() == 1, "Testing service count")
 
   service = dynamic_cast<TestServiceA*>(context->GetService<ITestServiceA>(ref2));
   US_TEST_CONDITION_REQUIRED(service == &s2, "Testing highest service rank")
 
   reg2.Unregister();
   US_TEST_CONDITION_REQUIRED(context->GetServiceReferences<ITestServiceA>().empty(), "Testing service count")
 }
 
 
 int usServiceRegistryTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ServiceRegistryTest");
 
   TestServiceInterfaceId();
   TestMultipleServiceRegistrations();
   TestServicePropertiesUpdate();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usServiceTemplateTest.cpp b/Modules/CppMicroServices/core/test/usServiceTemplateTest.cpp
index da83dfd118..9782180fea 100644
--- a/Modules/CppMicroServices/core/test/usServiceTemplateTest.cpp
+++ b/Modules/CppMicroServices/core/test/usServiceTemplateTest.cpp
@@ -1,208 +1,208 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModule.h>
 #include <usServiceFactory.h>
 
 #include "usTestingMacros.h"
 
 struct Interface1 {};
 struct Interface2 {};
 struct Interface3 {};
 
 struct MyService1 : public Interface1
 {};
 
 struct MyService2 : public Interface1, public Interface2
 {};
 
 struct MyService3 : public Interface1, public Interface2, public Interface3
 {};
 
 struct MyFactory1 : public us::ServiceFactory
 {
   std::map<long, MyService1*> m_idToServiceMap;
 
   us::InterfaceMap GetService(us::Module* module, const us::ServiceRegistrationBase& /*registration*/) override
   {
     MyService1* s = new MyService1;
     m_idToServiceMap.insert(std::make_pair(module->GetModuleId(), s));
     return us::MakeInterfaceMap<Interface1>(s);
   }
 
   void UngetService(us::Module* module, const us::ServiceRegistrationBase& /*registration*/,
                             const us::InterfaceMap& service) override
   {
     std::map<long, MyService1*>::iterator iter = m_idToServiceMap.find(module->GetModuleId());
     if (iter != m_idToServiceMap.end())
     {
       US_TEST_CONDITION(static_cast<Interface1*>(iter->second) == us::ExtractInterface<Interface1>(service), "Compare service pointer")
       delete iter->second;
       m_idToServiceMap.erase(iter);
     }
   }
 };
 
 struct MyFactory2 : public us::ServiceFactory
 {
   std::map<long, MyService2*> m_idToServiceMap;
 
   us::InterfaceMap GetService(us::Module* module, const us::ServiceRegistrationBase& /*registration*/) override
   {
     MyService2* s = new MyService2;
     m_idToServiceMap.insert(std::make_pair(module->GetModuleId(), s));
     return us::MakeInterfaceMap<Interface1,Interface2>(s);
   }
 
   void UngetService(us::Module* module, const us::ServiceRegistrationBase& /*registration*/,
                             const us::InterfaceMap& service) override
   {
     std::map<long, MyService2*>::iterator iter = m_idToServiceMap.find(module->GetModuleId());
     if (iter != m_idToServiceMap.end())
     {
       US_TEST_CONDITION(static_cast<Interface2*>(iter->second) == us::ExtractInterface<Interface2>(service), "Compare service pointer")
       delete iter->second;
       m_idToServiceMap.erase(iter);
     }
   }
 };
 
 struct MyFactory3 : public us::ServiceFactory
 {
   std::map<long, MyService3*> m_idToServiceMap;
 
   us::InterfaceMap GetService(us::Module* module, const us::ServiceRegistrationBase& /*registration*/) override
   {
     MyService3* s = new MyService3;
     m_idToServiceMap.insert(std::make_pair(module->GetModuleId(), s));
     return us::MakeInterfaceMap<Interface1,Interface2,Interface3>(s);
   }
 
   void UngetService(us::Module* module, const us::ServiceRegistrationBase& /*registration*/,
                             const us::InterfaceMap& service) override
   {
     std::map<long, MyService3*>::iterator iter = m_idToServiceMap.find(module->GetModuleId());
     if (iter != m_idToServiceMap.end())
     {
       US_TEST_CONDITION(static_cast<Interface3*>(iter->second) == us::ExtractInterface<Interface3>(service), "Compare service pointer")
       delete iter->second;
       m_idToServiceMap.erase(iter);
     }
   }
 };
 
 
 US_USE_NAMESPACE
 
 int usServiceTemplateTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ServiceTemplateTest");
 
   ModuleContext* mc = GetModuleContext();
 
   // Register compile tests
   MyService1 s1;
   MyService2 s2;
   MyService3 s3;
 
   us::ServiceRegistration<Interface1> sr1 = mc->RegisterService<Interface1>(&s1);
   us::ServiceRegistration<Interface1,Interface2> sr2 = mc->RegisterService<Interface1,Interface2>(&s2);
   us::ServiceRegistration<Interface1,Interface2,Interface3> sr3 = mc->RegisterService<Interface1,Interface2,Interface3>(&s3);
 
   MyFactory1 f1;
   us::ServiceRegistration<Interface1> sfr1 = mc->RegisterService<Interface1>(&f1);
 
   MyFactory2 f2;
   us::ServiceRegistration<Interface1,Interface2> sfr2 = mc->RegisterService<Interface1,Interface2>(static_cast<ServiceFactory*>(&f2));
 
   MyFactory3 f3;
   us::ServiceRegistration<Interface1,Interface2,Interface3> sfr3 = mc->RegisterService<Interface1,Interface2,Interface3>(static_cast<ServiceFactory*>(&f3));
 
 #ifdef US_BUILD_SHARED_LIBS
   US_TEST_CONDITION(mc->GetModule()->GetRegisteredServices().size() == 6, "# of reg services")
 #endif
 
   std::vector<us::ServiceReference<Interface1> > s1refs = mc->GetServiceReferences<Interface1>();
   US_TEST_CONDITION(s1refs.size() == 6, "# of interface1 regs")
   std::vector<us::ServiceReference<Interface2> > s2refs = mc->GetServiceReferences<Interface2>();
   US_TEST_CONDITION(s2refs.size() == 4, "# of interface2 regs")
   std::vector<us::ServiceReference<Interface3> > s3refs = mc->GetServiceReferences<Interface3>();
   US_TEST_CONDITION(s3refs.size() == 2, "# of interface3 regs")
 
   Interface1* i1 = mc->GetService(sr1.GetReference());
   US_TEST_CONDITION(i1 == static_cast<Interface1*>(&s1), "interface1 ptr")
   i1 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sr1.GetReference()), "unget interface1 ptr")
   i1 = mc->GetService(sfr1.GetReference());
   US_TEST_CONDITION(i1 == static_cast<Interface1*>(f1.m_idToServiceMap[mc->GetModule()->GetModuleId()]), "interface1 factory ptr")
   i1 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sfr1.GetReference()), "unget interface1 factory ptr")
 
   i1 = mc->GetService(sr2.GetReference(InterfaceType<Interface1>()));
   US_TEST_CONDITION(i1 == static_cast<Interface1*>(&s2), "interface1 ptr")
   i1 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sr2.GetReference(InterfaceType<Interface1>())), "unget interface1 ptr")
   i1 = mc->GetService(sfr2.GetReference(InterfaceType<Interface1>()));
   US_TEST_CONDITION(i1 == static_cast<Interface1*>(f2.m_idToServiceMap[mc->GetModule()->GetModuleId()]), "interface1 factory ptr")
   i1 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sfr2.GetReference(InterfaceType<Interface1>())), "unget interface1 factory ptr")
   Interface2* i2 = mc->GetService(sr2.GetReference(InterfaceType<Interface2>()));
   US_TEST_CONDITION(i2 == static_cast<Interface2*>(&s2), "interface2 ptr")
   i2 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sr2.GetReference(InterfaceType<Interface2>())), "unget interface2 ptr")
   i2 = mc->GetService(sfr2.GetReference(InterfaceType<Interface2>()));
   US_TEST_CONDITION(i2 == static_cast<Interface2*>(f2.m_idToServiceMap[mc->GetModule()->GetModuleId()]), "interface2 factory ptr")
   i2 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sfr2.GetReference(InterfaceType<Interface2>())), "unget interface2 factory ptr")
 
   i1 = mc->GetService(sr3.GetReference(InterfaceType<Interface1>()));
   US_TEST_CONDITION(i1 == static_cast<Interface1*>(&s3), "interface1 ptr")
   i1 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sr3.GetReference(InterfaceType<Interface1>())), "unget interface1 ptr")
   i1 = mc->GetService(sfr3.GetReference(InterfaceType<Interface1>()));
   US_TEST_CONDITION(i1 == static_cast<Interface1*>(f3.m_idToServiceMap[mc->GetModule()->GetModuleId()]), "interface1 factory ptr")
   i1 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sfr3.GetReference(InterfaceType<Interface1>())), "unget interface1 factory ptr")
   i2 = mc->GetService(sr3.GetReference(InterfaceType<Interface2>()));
   US_TEST_CONDITION(i2 == static_cast<Interface2*>(&s3), "interface2 ptr")
   i2 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sr3.GetReference(InterfaceType<Interface2>())), "unget interface2 ptr")
   i2 = mc->GetService(sfr3.GetReference(InterfaceType<Interface2>()));
   US_TEST_CONDITION(i2 == static_cast<Interface2*>(f3.m_idToServiceMap[mc->GetModule()->GetModuleId()]), "interface2 factory ptr")
   i2 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sfr3.GetReference(InterfaceType<Interface2>())), "unget interface2 factory ptr")
   Interface3* i3 = mc->GetService(sr3.GetReference(InterfaceType<Interface3>()));
   US_TEST_CONDITION(i3 == static_cast<Interface3*>(&s3), "interface3 ptr")
   i3 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sr3.GetReference(InterfaceType<Interface3>())), "unget interface3 ptr")
   i3 = mc->GetService(sfr3.GetReference(InterfaceType<Interface3>()));
   US_TEST_CONDITION(i3 == static_cast<Interface3*>(f3.m_idToServiceMap[mc->GetModule()->GetModuleId()]), "interface3 factory ptr")
   i3 = nullptr;
   US_TEST_CONDITION(mc->UngetService(sfr3.GetReference(InterfaceType<Interface3>())), "unget interface3 factory ptr")
 
   sr1.Unregister();
   sr2.Unregister();
   sr3.Unregister();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usServiceTrackerTest.cpp b/Modules/CppMicroServices/core/test/usServiceTrackerTest.cpp
index 38d4dccaad..a6cb2f70ef 100644
--- a/Modules/CppMicroServices/core/test/usServiceTrackerTest.cpp
+++ b/Modules/CppMicroServices/core/test/usServiceTrackerTest.cpp
@@ -1,287 +1,287 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usTestingMacros.h>
 #include <usTestingConfig.h>
 
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usServiceInterface.h>
 #include <usServiceTracker.h>
 #include <usSharedLibrary.h>
 
 #include "usServiceControlInterface.h"
 
 #include <memory>
 
 US_USE_NAMESPACE
 
 bool CheckConvertibility(const std::vector<ServiceReferenceU>& refs,
                          std::vector<std::string>::const_iterator idBegin,
                          std::vector<std::string>::const_iterator idEnd)
 {
   std::vector<std::string> ids;
   ids.assign(idBegin, idEnd);
 
   for (std::vector<ServiceReferenceU>::const_iterator sri = refs.begin();
        sri != refs.end(); ++sri)
   {
     for (std::vector<std::string>::iterator idIter = ids.begin();
          idIter != ids.end(); ++idIter)
     {
       if (sri->IsConvertibleTo(*idIter))
       {
         ids.erase(idIter);
         break;
       }
     }
   }
 
   return ids.empty();
 }
 
 struct MyInterfaceOne {
   virtual ~MyInterfaceOne() {}
 };
 
 struct MyInterfaceTwo {
   virtual ~MyInterfaceTwo() {}
 };
 
 class MyCustomizer : public us::ServiceTrackerCustomizer<MyInterfaceOne>
 {
 
 public:
 
   MyCustomizer(us::ModuleContext* context)
     : m_context(context)
   {}
 
   MyInterfaceOne* AddingService(const ServiceReferenceType& reference) override
   {
     US_TEST_CONDITION_REQUIRED(reference, "AddingService() valid reference")
     return m_context->GetService(reference);
   }
 
   void ModifiedService(const ServiceReferenceType& reference, MyInterfaceOne* service) override
   {
     US_TEST_CONDITION(reference, "ModifiedService() valid reference")
     US_TEST_CONDITION(service, "ModifiedService() valid service")
   }
 
   void RemovedService(const ServiceReferenceType& reference, MyInterfaceOne* service) override
   {
     US_TEST_CONDITION(reference, "RemovedService() valid reference")
     US_TEST_CONDITION(service, "RemovedService() valid service")
   }
 
 private:
 
   us::ModuleContext* m_context;
 };
 
 void TestFilterString()
 {
   us::ModuleContext* context = us::GetModuleContext();
   MyCustomizer customizer(context);
 
   us::LDAPFilter filter("(" + us::ServiceConstants::SERVICE_ID() + ">=0)");
   us::ServiceTracker<MyInterfaceOne> tracker(context, filter, &customizer);
   tracker.Open();
 
   struct MyServiceOne : public MyInterfaceOne {};
   struct MyServiceTwo : public MyInterfaceTwo {};
 
   MyServiceOne serviceOne;
   MyServiceTwo serviceTwo;
 
   ServiceRegistration<MyInterfaceOne> reg1 = context->RegisterService<MyInterfaceOne>(&serviceOne);
   ServiceRegistration<MyInterfaceTwo> reg2 = context->RegisterService<MyInterfaceTwo>(&serviceTwo);
 
   US_TEST_CONDITION(tracker.GetServiceReferences().size() == 1, "tracking count")
 
   reg1.Unregister();
   reg2.Unregister();
 }
 
 void TestServiceTracker()
 {
 
 #ifdef US_PLATFORM_WINDOWS
   const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
   ModuleContext* mc = GetModuleContext();
   SharedLibrary libS(LIB_PATH, "TestModuleS");
 
 #ifdef US_BUILD_SHARED_LIBS
   // Start the test target to get a service published.
   try
   {
     libS.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG( << "Failed to load module, got exception: " << e.what() );
   }
 #endif
 
   // 1. Create a ServiceTracker with ServiceTrackerCustomizer == null
 
   std::string s1("us::TestModuleSService");
   ServiceReferenceU servref = mc->GetServiceReference(s1 + "0");
 
   US_TEST_CONDITION_REQUIRED(servref != nullptr, "Test if registered service of id us::TestModuleSService0");
 
   ServiceReference<ServiceControlInterface> servCtrlRef = mc->GetServiceReference<ServiceControlInterface>();
   US_TEST_CONDITION_REQUIRED(servCtrlRef != nullptr, "Test if constrol service was registered");
 
   ServiceControlInterface* serviceController = mc->GetService(servCtrlRef);
   US_TEST_CONDITION_REQUIRED(serviceController != nullptr, "Test valid service controller");
 
   std::unique_ptr<ServiceTracker<void>> st1(new ServiceTracker<void>(mc, servref));
 
   // 2. Check the size method with an unopened service tracker
 
   US_TEST_CONDITION_REQUIRED(st1->Size() == 0, "Test if size == 0");
 
   // 3. Open the service tracker and see what it finds,
   // expect to find one instance of the implementation,
   // "org.cppmicroservices.TestModuleSService0"
 
   st1->Open();
   std::vector<ServiceReferenceU> sa2 = st1->GetServiceReferences();
 
   US_TEST_CONDITION_REQUIRED(sa2.size() == 1, "Checking ServiceTracker size");
   US_TEST_CONDITION_REQUIRED(s1 + "0" == sa2[0].GetInterfaceId(), "Checking service implementation name");
 
   // 5. Close this service tracker
   st1->Close();
 
   // 6. Check the size method, now when the servicetracker is closed
   US_TEST_CONDITION_REQUIRED(st1->Size() == 0, "Checking ServiceTracker size");
 
   // 7. Check if we still track anything , we should get null
   sa2 = st1->GetServiceReferences();
   US_TEST_CONDITION_REQUIRED(sa2.empty(), "Checking ServiceTracker size");
 
   // 8. A new Servicetracker, this time with a filter for the object
   std::string fs = std::string("(") + ServiceConstants::OBJECTCLASS() + "=" + s1 + "*" + ")";
   LDAPFilter f1(fs);
   st1.reset(new ServiceTracker<void>(mc, f1));
   // add a service
   serviceController->ServiceControl(1, "register", 7);
 
   // 9. Open the service tracker and see what it finds,
   // expect to find two instances of references to
   // "org.cppmicroservices.TestModuleSService*"
   // i.e. they refer to the same piece of code
 
   std::vector<std::string> ids;
   ids.push_back((s1 + "0"));
   ids.push_back((s1 + "1"));
   ids.push_back((s1 + "2"));
   ids.push_back((s1 + "3"));
 
   st1->Open();
   sa2 = st1->GetServiceReferences();
   US_TEST_CONDITION_REQUIRED(sa2.size() == 2, "Checking service reference count");
   US_TEST_CONDITION_REQUIRED(CheckConvertibility(sa2, ids.begin(), ids.begin()+2), "Check for expected interface id [0]");
   US_TEST_CONDITION_REQUIRED(sa2[1].IsConvertibleTo(s1 + "1"), "Check for expected interface id [1]");
 
   // 10. Get libTestModuleS to register one more service and see if it appears
   serviceController->ServiceControl(2, "register", 1);
   sa2 = st1->GetServiceReferences();
 
   US_TEST_CONDITION_REQUIRED(sa2.size() == 3, "Checking service reference count");
 
   US_TEST_CONDITION_REQUIRED(CheckConvertibility(sa2, ids.begin(), ids.begin()+3), "Check for expected interface id [2]");
 
   // 11. Get libTestModuleS to register one more service and see if it appears
   serviceController->ServiceControl(3, "register", 2);
   sa2 = st1->GetServiceReferences();
   US_TEST_CONDITION_REQUIRED(sa2.size() == 4, "Checking service reference count");
   US_TEST_CONDITION_REQUIRED(CheckConvertibility(sa2, ids.begin(), ids.end()), "Check for expected interface id [3]");
 
   // 12. Get libTestModuleS to unregister one service and see if it disappears
   serviceController->ServiceControl(3, "unregister", 0);
   sa2 = st1->GetServiceReferences();
   US_TEST_CONDITION_REQUIRED(sa2.size() == 3, "Checking service reference count");
 
   // 13. Get the highest ranking service reference, it should have ranking 7
   ServiceReferenceU h1 = st1->GetServiceReference();
   int rank = any_cast<int>(h1.GetProperty(ServiceConstants::SERVICE_RANKING()));
   US_TEST_CONDITION_REQUIRED(rank == 7, "Check service rank");
 
   // 14. Get the service of the highest ranked service reference
 
   InterfaceMap o1 = st1->GetService(h1);
   US_TEST_CONDITION_REQUIRED(!o1.empty(), "Check for non-null service");
 
   // 14a Get the highest ranked service, directly this time
   InterfaceMap o3 = st1->GetService();
   US_TEST_CONDITION_REQUIRED(!o3.empty(), "Check for non-null service");
   US_TEST_CONDITION_REQUIRED(o1 == o3, "Check for equal service instances");
 
   // 15. Now release the tracking of that service and then try to get it
   //     from the servicetracker, which should yield a null object
   serviceController->ServiceControl(1, "unregister", 7);
   InterfaceMap o2 = st1->GetService(h1);
   US_TEST_CONDITION_REQUIRED(o2.empty(), "Checkt that service is null");
 
   // 16. Get all service objects this tracker tracks, it should be 2
   std::vector<InterfaceMap> ts1 = st1->GetServices();
   US_TEST_CONDITION_REQUIRED(ts1.size() == 2, "Check service count");
 
   // 17. Test the remove method.
   //     First register another service, then remove it being tracked
   serviceController->ServiceControl(1, "register", 7);
   h1 = st1->GetServiceReference();
   std::vector<ServiceReferenceU> sa3 = st1->GetServiceReferences();
   US_TEST_CONDITION_REQUIRED(sa3.size() == 3, "Check service reference count");
   US_TEST_CONDITION_REQUIRED(CheckConvertibility(sa3, ids.begin(), ids.begin()+3), "Check for expected interface id [0]");
 
   st1->Remove(h1);           // remove tracking on one servref
   sa2 = st1->GetServiceReferences();
   US_TEST_CONDITION_REQUIRED(sa2.size() == 2, "Check service reference count");
 
   // 18. Test the addingService method,add a service reference
 
   // 19. Test the removedService method, remove a service reference
 
 
   // 20. Test the waitForService method
   InterfaceMap o9 = st1->WaitForService(50);
   US_TEST_CONDITION_REQUIRED(!o9.empty(), "Checking WaitForService method");
 }
 
 int usServiceTrackerTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ServiceTrackerTest")
 
   TestFilterString();
   TestServiceTracker();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usSharedLibraryTest.cpp b/Modules/CppMicroServices/core/test/usSharedLibraryTest.cpp
index b700afa6ff..5cde7ea228 100644
--- a/Modules/CppMicroServices/core/test/usSharedLibraryTest.cpp
+++ b/Modules/CppMicroServices/core/test/usSharedLibraryTest.cpp
@@ -1,118 +1,118 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usSharedLibrary.h>
 
 #include "usTestingMacros.h"
 #include "usTestingConfig.h"
 
 #include <cstdlib>
 #include <stdexcept>
 
 US_USE_NAMESPACE
 
 int usSharedLibraryTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("SharedLibraryTest");
 
 #ifdef US_PLATFORM_WINDOWS
   const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
   const std::string LIB_PREFIX = "";
   const std::string LIB_SUFFIX = ".dll";
   const char PATH_SEPARATOR = '\\';
 #elif defined(US_PLATFORM_APPLE)
   const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
   const std::string LIB_PREFIX = "lib";
   const std::string LIB_SUFFIX = ".dylib";
   const char PATH_SEPARATOR = '/';
 #else
   const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
   const std::string LIB_PREFIX = "lib";
   const std::string LIB_SUFFIX = ".so";
   const char PATH_SEPARATOR = '/';
 
 #endif
 
   const std::string libAFilePath = LIB_PATH + PATH_SEPARATOR + LIB_PREFIX + "TestModuleA" + LIB_SUFFIX;
   SharedLibrary lib1(libAFilePath);
   US_TEST_CONDITION(lib1.GetFilePath() == libAFilePath, "Absolute file path")
   US_TEST_CONDITION(lib1.GetLibraryPath() == LIB_PATH, "Library path")
   US_TEST_CONDITION(lib1.GetName() == "TestModuleA", "Name")
   US_TEST_CONDITION(lib1.GetPrefix() == LIB_PREFIX, "Prefix")
   US_TEST_CONDITION(lib1.GetSuffix() == LIB_SUFFIX, "Suffix")
   lib1.SetName("bla");
   US_TEST_CONDITION(lib1.GetName() == "TestModuleA", "Name after SetName()")
   lib1.SetLibraryPath("bla");
   US_TEST_CONDITION(lib1.GetLibraryPath() == LIB_PATH, "Library path after SetLibraryPath()")
   lib1.SetPrefix("bla");
   US_TEST_CONDITION(lib1.GetPrefix() == LIB_PREFIX, "Prefix after SetPrefix()")
   lib1.SetSuffix("bla");
   US_TEST_CONDITION(lib1.GetSuffix() == LIB_SUFFIX, "Suffix after SetSuffix()")
   US_TEST_CONDITION(lib1.GetFilePath() == libAFilePath, "File path after setters")
 
   lib1.SetFilePath("bla");
   US_TEST_CONDITION(lib1.GetFilePath() == "bla", "Invalid file path")
   US_TEST_CONDITION(lib1.GetLibraryPath().empty(), "Empty lib path")
   US_TEST_CONDITION(lib1.GetName() == "bla", "Invalid file name")
   US_TEST_CONDITION(lib1.GetPrefix() == LIB_PREFIX, "Invalid prefix")
   US_TEST_CONDITION(lib1.GetSuffix() == LIB_SUFFIX, "Invalid suffix")
 
   US_TEST_FOR_EXCEPTION(std::runtime_error, lib1.Load())
   US_TEST_CONDITION(lib1.IsLoaded() == false, "Is loaded")
   US_TEST_CONDITION(lib1.GetHandle() == nullptr, "Handle")
 
   lib1.SetFilePath(libAFilePath);
   lib1.Load();
   US_TEST_CONDITION(lib1.IsLoaded() == true, "Is loaded")
   US_TEST_CONDITION(lib1.GetHandle() != nullptr, "Handle")
   US_TEST_FOR_EXCEPTION(std::logic_error, lib1.Load())
 
   lib1.SetFilePath("bla");
   US_TEST_CONDITION(lib1.GetFilePath() == libAFilePath, "File path")
   lib1.Unload();
 
 
   SharedLibrary lib2(LIB_PATH, "TestModuleA");
   US_TEST_CONDITION(lib2.GetFilePath() == libAFilePath, "File path")
   lib2.SetPrefix("");
   US_TEST_CONDITION(lib2.GetPrefix().empty(), "Lib prefix")
   US_TEST_CONDITION(lib2.GetFilePath() == LIB_PATH + PATH_SEPARATOR + "TestModuleA" + LIB_SUFFIX, "File path")
 
   SharedLibrary lib3 = lib2;
   US_TEST_CONDITION(lib3.GetFilePath() == lib2.GetFilePath(), "Compare file path")
   lib3.SetPrefix(LIB_PREFIX);
   US_TEST_CONDITION(lib3.GetFilePath() == libAFilePath, "Compare file path")
   lib3.Load();
   US_TEST_CONDITION(lib3.IsLoaded(), "lib3 loaded")
   US_TEST_CONDITION(!lib2.IsLoaded(), "lib2 not loaded")
   lib1 = lib3;
   US_TEST_FOR_EXCEPTION(std::logic_error, lib1.Load())
   lib2.SetPrefix(LIB_PREFIX);
   lib2.Load();
 
   lib3.Unload();
   US_TEST_CONDITION(!lib3.IsLoaded(), "lib3 unloaded")
   US_TEST_CONDITION(!lib1.IsLoaded(), "lib3 unloaded")
   lib2.Unload();
   lib1.Unload();
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usStaticModuleResourceTest.cpp b/Modules/CppMicroServices/core/test/usStaticModuleResourceTest.cpp
index c13f5c6481..1f5eb19632 100644
--- a/Modules/CppMicroServices/core/test/usStaticModuleResourceTest.cpp
+++ b/Modules/CppMicroServices/core/test/usStaticModuleResourceTest.cpp
@@ -1,146 +1,146 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModuleRegistry.h>
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <usSharedLibrary.h>
 
 #include "usTestingMacros.h"
 #include "usTestingConfig.h"
 
 #include <cassert>
 
 #include <set>
 
 US_USE_NAMESPACE
 
 namespace {
 
 std::string GetResourceContent(const ModuleResource& resource)
 {
   std::string line;
   ModuleResourceStream rs(resource);
   std::getline(rs, line);
   return line;
 }
 
 struct ResourceComparator {
   bool operator()(const ModuleResource& mr1, const ModuleResource& mr2) const
   {
     return mr1 < mr2;
   }
 };
 
 void testResourceOperators(Module* module)
 {
   std::vector<ModuleResource> resources = module->FindResources("", "res.txt", false);
   US_TEST_CONDITION_REQUIRED(resources.size() == 1, "Check resource count")
 }
 
 void testResourcesWithStaticImport(Module* module)
 {
   ModuleResource resource = module->GetResource("res.txt");
   US_TEST_CONDITION_REQUIRED(resource.IsValid(), "Check valid res.txt resource")
   std::string line = GetResourceContent(resource);
   US_TEST_CONDITION(line == "dynamic resource", "Check dynamic resource content")
 
   resource = module->GetResource("dynamic.txt");
   US_TEST_CONDITION_REQUIRED(resource.IsValid(), "Check valid dynamic.txt resource")
   line = GetResourceContent(resource);
   US_TEST_CONDITION(line == "dynamic", "Check dynamic resource content")
 
   resource = module->GetResource("static.txt");
   US_TEST_CONDITION_REQUIRED(!resource.IsValid(), "Check in-valid static.txt resource")
 
   Module* importedByBModule = ModuleRegistry::GetModule("TestModuleImportedByB");
   US_TEST_CONDITION_REQUIRED(importedByBModule != nullptr, "Check valid static module")
   resource = importedByBModule->GetResource("static.txt");
   US_TEST_CONDITION_REQUIRED(resource.IsValid(), "Check valid static.txt resource")
   line = GetResourceContent(resource);
   US_TEST_CONDITION(line == "static", "Check static resource content")
 
   std::vector<ModuleResource> resources = module->FindResources("", "*.txt", false);
   std::stable_sort(resources.begin(), resources.end(), ResourceComparator());
   std::vector<ModuleResource> importedResources = importedByBModule->FindResources("", "*.txt", false);
   std::stable_sort(importedResources.begin(), importedResources.end(), ResourceComparator());
 
   US_TEST_CONDITION(resources.size() == 2, "Check resource count")
   US_TEST_CONDITION(importedResources.size() == 2, "Check resource count")
   line = GetResourceContent(resources[0]);
   US_TEST_CONDITION(line == "dynamic", "Check dynamic.txt resource content")
   line = GetResourceContent(resources[1]);
   US_TEST_CONDITION(line == "dynamic resource", "Check res.txt (from importing module) resource content")
   line = GetResourceContent(importedResources[0]);
   US_TEST_CONDITION(line == "static resource", "Check res.txt (from imported module) resource content")
   line = GetResourceContent(importedResources[1]);
   US_TEST_CONDITION(line == "static", "Check static.txt (from importing module) resource content")
 }
 
 } // end unnamed namespace
 
 
 int usStaticModuleResourceTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("StaticModuleResourceTest");
 
   assert(GetModuleContext());
 
 
 #ifdef US_BUILD_SHARED_LIBS
 
 #ifdef US_PLATFORM_WINDOWS
   const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
   SharedLibrary libB(LIB_PATH, "TestModuleB");
 
   try
   {
     libB.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 #endif
 
   Module* module = ModuleRegistry::GetModule("TestModuleB");
   US_TEST_CONDITION_REQUIRED(module != nullptr, "Test for existing module TestModuleB")
   US_TEST_CONDITION(module->GetName() == "TestModuleB", "Test module name")
 
   testResourceOperators(module);
   testResourcesWithStaticImport(module);
 
   ModuleResource resource = ModuleRegistry::GetModule("TestModuleImportedByB")->GetResource("static.txt");
   US_TEST_CONDITION_REQUIRED(resource.IsValid(), "Check valid static.txt resource")
 #ifdef US_BUILD_SHARED_LIBS
   libB.Unload();
   US_TEST_CONDITION_REQUIRED(resource.IsValid() == true, "Check still valid static.txt resource")
 #endif
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usStaticModuleTest.cpp b/Modules/CppMicroServices/core/test/usStaticModuleTest.cpp
index 424ddd7c7f..ee433b74ed 100644
--- a/Modules/CppMicroServices/core/test/usStaticModuleTest.cpp
+++ b/Modules/CppMicroServices/core/test/usStaticModuleTest.cpp
@@ -1,183 +1,183 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <usModule.h>
 #include <usModuleEvent.h>
 #include <usServiceEvent.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModuleRegistry.h>
 #include <usModuleActivator.h>
 #include <usSharedLibrary.h>
 
 #include "usTestUtilModuleListener.h"
 #include "usTestingMacros.h"
 #include "usTestingConfig.h"
 
 US_USE_NAMESPACE
 
 namespace {
 
 #ifdef US_PLATFORM_WINDOWS
   static const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   static const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
 
 // Load libTestModuleB and check that it exists and that the service it registers exists,
 // also check that the expected events occur
 void frame020a(ModuleContext* mc, TestModuleListener& listener,
 #ifdef US_BUILD_SHARED_LIBS
                SharedLibrary& libB)
 {
   try
   {
     libB.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 #else
                SharedLibrary& /*libB*/)
 {
 #endif
 
   Module* moduleB = ModuleRegistry::GetModule("TestModuleB");
   US_TEST_CONDITION_REQUIRED(moduleB != nullptr, "Test for existing module TestModuleB")
 
   Module* moduleImportedByB = ModuleRegistry::GetModule("TestModuleImportedByB");
   US_TEST_CONDITION_REQUIRED(moduleImportedByB != nullptr, "Test for existing module TestModuleImportedByB")
 
   US_TEST_CONDITION(moduleB->GetName() == "TestModuleB", "Test module name")
 
   // Check if libB registered the expected service
   try
   {
     std::vector<ServiceReferenceU> refs = mc->GetServiceReferences("us::TestModuleBService");
     US_TEST_CONDITION_REQUIRED(refs.size() == 2, "Test that both the service from the shared and imported library are regsitered");
 
     InterfaceMap o1 = mc->GetService(refs.front());
     US_TEST_CONDITION(!o1.empty(), "Test if first service object found");
 
     InterfaceMap o2 = mc->GetService(refs.back());
     US_TEST_CONDITION(!o2.empty(), "Test if second service object found");
 
     try
     {
       US_TEST_CONDITION(mc->UngetService(refs.front()), "Test if Service UnGet for first service returns true");
       US_TEST_CONDITION(mc->UngetService(refs.back()), "Test if Service UnGet for second service returns true");
     }
     catch (const std::logic_error &le)
     {
       US_TEST_FAILED_MSG(<< "UnGetService exception: " << le.what())
     }
 
     // check the listeners for events
     std::vector<ModuleEvent> pEvts;
 #ifdef US_BUILD_SHARED_LIBS
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleB));
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleB));
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleImportedByB));
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleImportedByB));
 #endif
 
     std::vector<ServiceEvent> seEvts;
 #ifdef US_BUILD_SHARED_LIBS
     seEvts.push_back(ServiceEvent(ServiceEvent::REGISTERED, refs.back()));
     seEvts.push_back(ServiceEvent(ServiceEvent::REGISTERED, refs.front()));
 #endif
 
     US_TEST_CONDITION(listener.CheckListenerEvents(pEvts, seEvts), "Test for unexpected events");
 
   }
   catch (const ServiceException& /*se*/)
   {
     US_TEST_FAILED_MSG(<< "test module, expected service not found");
   }
 
 #ifdef US_BUILD_SHARED_LIBS
   US_TEST_CONDITION(moduleB->IsLoaded() == true, "Test if loaded correctly");
 #endif
 }
 
 
 // Unload libB and check for correct events
 void frame030b(ModuleContext* mc, TestModuleListener& listener, SharedLibrary& libB)
 {
   Module* moduleB = ModuleRegistry::GetModule("TestModuleB");
   US_TEST_CONDITION_REQUIRED(moduleB != nullptr, "Test for non-null module")
 
   Module* moduleImportedByB = ModuleRegistry::GetModule("TestModuleImportedByB");
   US_TEST_CONDITION_REQUIRED(moduleImportedByB != nullptr, "Test for non-null module")
 
   std::vector<ServiceReferenceU> refs
       = mc->GetServiceReferences("us::TestModuleBService");
   US_TEST_CONDITION(refs.front(), "Test for first valid service reference")
   US_TEST_CONDITION(refs.back(), "Test for second valid service reference")
 
   try
   {
     libB.Unload();
 #ifdef US_BUILD_SHARED_LIBS
     US_TEST_CONDITION(moduleB->IsLoaded() == false, "Test for unloaded state")
 #endif
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "UnLoad module exception: " << e.what())
   }
 
   std::vector<ModuleEvent> pEvts;
 #ifdef US_BUILD_SHARED_LIBS
   pEvts.push_back(ModuleEvent(ModuleEvent::UNLOADING, moduleImportedByB));
   pEvts.push_back(ModuleEvent(ModuleEvent::UNLOADED, moduleImportedByB));
   pEvts.push_back(ModuleEvent(ModuleEvent::UNLOADING, moduleB));
   pEvts.push_back(ModuleEvent(ModuleEvent::UNLOADED, moduleB));
 #endif
 
   std::vector<ServiceEvent> seEvts;
 #ifdef US_BUILD_SHARED_LIBS
   seEvts.push_back(ServiceEvent(ServiceEvent::UNREGISTERING, refs.front()));
   seEvts.push_back(ServiceEvent(ServiceEvent::UNREGISTERING, refs.back()));
 #endif
 
   US_TEST_CONDITION(listener.CheckListenerEvents(pEvts, seEvts), "Test for unexpected events");
 }
 
 } // end unnamed namespace
 
 int usStaticModuleTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("StaticModuleTest");
 
   ModuleContext* mc = GetModuleContext();
   TestModuleListener listener;
 
   ModuleListenerRegistrationHelper<TestModuleListener> ml(mc, &listener, &TestModuleListener::ModuleChanged);
   ServiceListenerRegistrationHelper<TestModuleListener> sl(mc, &listener, &TestModuleListener::ServiceChanged);
 
   SharedLibrary libB(LIB_PATH, "TestModuleB");
   frame020a(mc, listener, libB);
   frame030b(mc, listener, libB);
 
   US_TEST_END()
 }
diff --git a/Modules/CppMicroServices/core/test/usTestDriverActivator.cpp b/Modules/CppMicroServices/core/test/usTestDriverActivator.cpp
index 4f6a420f0f..ee9432a10c 100644
--- a/Modules/CppMicroServices/core/test/usTestDriverActivator.cpp
+++ b/Modules/CppMicroServices/core/test/usTestDriverActivator.cpp
@@ -1,69 +1,69 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usTestDriverActivator.h"
 #include "usModuleImport.h"
 
 US_BEGIN_NAMESPACE
 
 TestDriverActivator* TestDriverActivator::m_Instance = nullptr;
 
 TestDriverActivator::TestDriverActivator()
   : m_LoadCalled(false)
 {
 }
 
 bool TestDriverActivator::LoadCalled()
 {
   return m_Instance ? m_Instance->m_LoadCalled : false;
 }
 
 void TestDriverActivator::Load(ModuleContext*)
 {
   this->m_Instance = this;
   this->m_LoadCalled = true;
 }
 
 void TestDriverActivator::Unload(ModuleContext*)
 {
   this->m_Instance = nullptr;
 }
 
 US_END_NAMESPACE
 
 US_EXPORT_MODULE_ACTIVATOR(us::TestDriverActivator)
 
 #ifndef US_BUILD_SHARED_LIBS
 US_IMPORT_MODULE(CppMicroServices)
 US_IMPORT_MODULE(TestModuleA)
 US_IMPORT_MODULE(TestModuleA2)
 US_IMPORT_MODULE(TestModuleB)
 US_IMPORT_MODULE(TestModuleH)
 US_IMPORT_MODULE(TestModuleM)
 US_INITIALIZE_STATIC_MODULE(TestModuleR)
 US_INITIALIZE_STATIC_MODULE(TestModuleRL)
 US_INITIALIZE_STATIC_MODULE(TestModuleRA)
 US_IMPORT_MODULE(TestModuleS)
 US_IMPORT_MODULE(TestModuleSL1)
 US_IMPORT_MODULE(TestModuleSL3)
 US_IMPORT_MODULE(TestModuleSL4)
 US_IMPORT_MODULE(main)
 #endif
diff --git a/Modules/CppMicroServices/core/test/usTestDriverActivator.h b/Modules/CppMicroServices/core/test/usTestDriverActivator.h
index 97b0cda48d..5efc021bfd 100644
--- a/Modules/CppMicroServices/core/test/usTestDriverActivator.h
+++ b/Modules/CppMicroServices/core/test/usTestDriverActivator.h
@@ -1,49 +1,49 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USTESTDRIVERACTIVATOR_H
 #define USTESTDRIVERACTIVATOR_H
 
 #include <usModuleActivator.h>
 
 US_BEGIN_NAMESPACE
 
 class TestDriverActivator : public ModuleActivator
 {
 public:
 
   TestDriverActivator();
 
   static bool LoadCalled();
 
   void Load(ModuleContext*) override;
 
   void Unload(ModuleContext* ) override;
 
 private:
 
   static TestDriverActivator* m_Instance;
   bool m_LoadCalled;
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTDRIVERACTIVATOR_H
diff --git a/Modules/CppMicroServices/core/test/usTestManager.cpp b/Modules/CppMicroServices/core/test/usTestManager.cpp
index 1423d899da..46cd014368 100644
--- a/Modules/CppMicroServices/core/test/usTestManager.cpp
+++ b/Modules/CppMicroServices/core/test/usTestManager.cpp
@@ -1,59 +1,59 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usTestManager.h"
 
 
 US_BEGIN_NAMESPACE
 
 TestManager& TestManager::GetInstance()
 {
   static TestManager instance;
   return instance;
 }
 
 void TestManager::Initialize()
 {
   m_FailedTests = 0;
   m_PassedTests = 0;
 }
 
 int TestManager::NumberOfFailedTests()
 {
   return m_FailedTests;
 }
 
 int TestManager::NumberOfPassedTests()
 {
   return m_PassedTests;
 }
 
 void TestManager::TestFailed()
 {
   m_FailedTests++;
 }
 
 void TestManager::TestPassed()
 {
   m_PassedTests++;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/test/usTestManager.h b/Modules/CppMicroServices/core/test/usTestManager.h
index 44308228cb..63056319ef 100644
--- a/Modules/CppMicroServices/core/test/usTestManager.h
+++ b/Modules/CppMicroServices/core/test/usTestManager.h
@@ -1,57 +1,57 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef US_TESTMANAGER_H_INCLUDED
 #define US_TESTMANAGER_H_INCLUDED
 
 #include <usGlobalConfig.h>
 
 US_BEGIN_NAMESPACE
 
 class TestManager
 {
 public:
 
   TestManager() : m_FailedTests(0), m_PassedTests(0) {}
   virtual ~TestManager() {}
 
   static TestManager& GetInstance();
 
   /** \brief Must be called at the beginning of a test run. */
   void Initialize();
 
   int NumberOfFailedTests();
   int NumberOfPassedTests();
 
   /** \brief Tell manager a subtest failed */
   void TestFailed();
 
   /** \brief Tell manager a subtest passed */
   void TestPassed();
 
 protected:
   int m_FailedTests;
   int m_PassedTests;
 };
 
 US_END_NAMESPACE
 
 #endif // US_TESTMANAGER_H_INCLUDED
diff --git a/Modules/CppMicroServices/core/test/usTestUtilModuleListener.cpp b/Modules/CppMicroServices/core/test/usTestUtilModuleListener.cpp
index 75967289dc..71cb5fb779 100644
--- a/Modules/CppMicroServices/core/test/usTestUtilModuleListener.cpp
+++ b/Modules/CppMicroServices/core/test/usTestUtilModuleListener.cpp
@@ -1,160 +1,160 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "usTestUtilModuleListener.h"
 
 #include "usUtils_p.h"
 
 US_BEGIN_NAMESPACE
 
 TestModuleListener::TestModuleListener()
   : serviceEvents(), moduleEvents()
 {}
 
 void TestModuleListener::ModuleChanged(const ModuleEvent event)
 {
   moduleEvents.push_back(event);
   US_DEBUG << "ModuleEvent:" << event;
 }
 
 void TestModuleListener::ServiceChanged(const ServiceEvent event)
 {
   serviceEvents.push_back(event);
   US_DEBUG << "ServiceEvent:" << event;
 }
 
 ModuleEvent TestModuleListener::GetModuleEvent() const
 {
   if (moduleEvents.empty())
   {
     return ModuleEvent();
   }
   return moduleEvents.back();
 }
 
 ServiceEvent TestModuleListener::GetServiceEvent() const
 {
   if (serviceEvents.empty())
   {
     return ServiceEvent();
   }
   return serviceEvents.back();
 }
 
 bool TestModuleListener::CheckListenerEvents(
     bool pexp, ModuleEvent::Type ptype,
     bool sexp, ServiceEvent::Type stype,
     Module* moduleX, ServiceReferenceU* servX)
 {
   std::vector<ModuleEvent> pEvts;
   std::vector<ServiceEvent> seEvts;
 
   if (pexp) pEvts.push_back(ModuleEvent(ptype, moduleX));
   if (sexp) seEvts.push_back(ServiceEvent(stype, *servX));
 
   return CheckListenerEvents(pEvts, seEvts);
 }
 
 bool TestModuleListener::CheckListenerEvents(const std::vector<ModuleEvent>& pEvts)
 {
   bool listenState = true; // assume everything will work
 
   if (pEvts.size() != moduleEvents.size())
   {
     listenState = false;
     US_DEBUG << "*** Module event mismatch: expected "
              << pEvts.size() << " event(s), found "
              << moduleEvents.size() << " event(s).";
 
     const std::size_t max = pEvts.size() > moduleEvents.size() ? pEvts.size() : moduleEvents.size();
     for (std::size_t i = 0; i < max; ++i)
     {
       const ModuleEvent& pE = i < pEvts.size() ? pEvts[i] : ModuleEvent();
       const ModuleEvent& pR = i < moduleEvents.size() ? moduleEvents[i] : ModuleEvent();
       US_DEBUG << "    " << pE << " - " << pR;
     }
   }
   else
   {
     for (std::size_t i = 0; i < pEvts.size(); ++i)
     {
       const ModuleEvent& pE = pEvts[i];
       const ModuleEvent& pR = moduleEvents[i];
       if (pE.GetType() != pR.GetType()
           || pE.GetModule() != pR.GetModule())
       {
         listenState = false;
         US_DEBUG << "*** Wrong module event: " << pR << " expected " << pE;
       }
     }
   }
 
   moduleEvents.clear();
   return listenState;
 }
 
 bool TestModuleListener::CheckListenerEvents(const std::vector<ServiceEvent>& seEvts)
 {
   bool listenState = true; // assume everything will work
 
   if (seEvts.size() != serviceEvents.size())
   {
     listenState = false;
     US_DEBUG << "*** Service event mismatch: expected "
              << seEvts.size() << " event(s), found "
              << serviceEvents.size() << " event(s).";
 
     const std::size_t max = seEvts.size() > serviceEvents.size() ? seEvts.size() : serviceEvents.size();
     for (std::size_t i = 0; i < max; ++i)
     {
       const ServiceEvent& seE = i < seEvts.size() ? seEvts[i] : ServiceEvent();
       const ServiceEvent& seR = i < serviceEvents.size() ? serviceEvents[i] : ServiceEvent();
       US_DEBUG << "    " << seE << " - " << seR;
     }
   }
   else
   {
     for (std::size_t i = 0; i < seEvts.size(); ++i)
     {
       const ServiceEvent& seE = seEvts[i];
       const ServiceEvent& seR = serviceEvents[i];
       if (seE.GetType() != seR.GetType()
           || (!(seE.GetServiceReference() == seR.GetServiceReference())))
       {
         listenState = false;
         US_DEBUG << "*** Wrong service event: " << seR << " expected " << seE;
       }
     }
   }
 
   serviceEvents.clear();
   return listenState;
 }
 
 bool TestModuleListener::CheckListenerEvents(
     const std::vector<ModuleEvent>& pEvts,
     const std::vector<ServiceEvent>& seEvts)
 {
   if (!CheckListenerEvents(pEvts)) return false;
   return CheckListenerEvents(seEvts);
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/core/test/usTestUtilModuleListener.h b/Modules/CppMicroServices/core/test/usTestUtilModuleListener.h
index 82dc0c4946..a52dcb0c8e 100644
--- a/Modules/CppMicroServices/core/test/usTestUtilModuleListener.h
+++ b/Modules/CppMicroServices/core/test/usTestUtilModuleListener.h
@@ -1,141 +1,141 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USTESTUTILMODULELISTENER_H
 #define USTESTUTILMODULELISTENER_H
 
 #include "usModuleEvent.h"
 #include "usServiceEvent.h"
 #include "usModuleContext.h"
 
 #include "usTestingMacros.h"
 
 US_BEGIN_NAMESPACE
 
 class ModuleContext;
 
 class TestModuleListener {
 
 public:
 
   TestModuleListener();
 
   void ModuleChanged(const ModuleEvent event);
 
   void ServiceChanged(const ServiceEvent event);
 
   ModuleEvent GetModuleEvent() const;
 
   ServiceEvent GetServiceEvent() const;
 
   bool CheckListenerEvents(
       bool pexp, ModuleEvent::Type ptype,
       bool sexp, ServiceEvent::Type stype,
       Module* moduleX, ServiceReferenceU* servX);
 
   bool CheckListenerEvents(const std::vector<ModuleEvent>& pEvts);
 
   bool CheckListenerEvents(const std::vector<ServiceEvent>& seEvts);
 
   bool CheckListenerEvents(const std::vector<ModuleEvent>& pEvts,
                            const std::vector<ServiceEvent>& seEvts);
 
 private:
 
   std::vector<ServiceEvent> serviceEvents;
   std::vector<ModuleEvent> moduleEvents;
 };
 
 template<class Receiver>
 class ModuleListenerRegistrationHelper
 {
 
 public:
 
   typedef void(Receiver::*CallbackType)(const ModuleEvent);
 
   ModuleListenerRegistrationHelper(ModuleContext* context, Receiver* receiver, CallbackType callback)
     : context(context)
     , receiver(receiver)
     , callback(callback)
   {
     try
     {
       context->AddModuleListener(receiver, callback);
     }
     catch (const std::logic_error& ise)
     {
       US_TEST_OUTPUT( << "module listener registration failed " << ise.what() );
       throw;
     }
   }
 
   ~ModuleListenerRegistrationHelper()
   {
     context->RemoveModuleListener(receiver, callback);
   }
 
 private:
 
   ModuleContext* context;
   Receiver* receiver;
   CallbackType callback;
 };
 
 template<class Receiver>
 class ServiceListenerRegistrationHelper
 {
 
 public:
 
   typedef void(Receiver::*CallbackType)(const ServiceEvent);
 
   ServiceListenerRegistrationHelper(ModuleContext* context, Receiver* receiver, CallbackType callback)
     : context(context)
     , receiver(receiver)
     , callback(callback)
   {
     try
     {
       context->AddServiceListener(receiver, callback);
     }
     catch (const std::logic_error& ise)
     {
       US_TEST_OUTPUT( << "service listener registration failed " << ise.what() );
       throw;
     }
   }
 
   ~ServiceListenerRegistrationHelper()
   {
     context->RemoveServiceListener(receiver, callback);
   }
 
 private:
 
   ModuleContext* context;
   Receiver* receiver;
   CallbackType callback;
 };
 
 US_END_NAMESPACE
 
 #endif // USTESTUTILMODULELISTENER_H
diff --git a/Modules/CppMicroServices/core/test/usTestingMacros.h b/Modules/CppMicroServices/core/test/usTestingMacros.h
index b415f8471a..036cc1cbd2 100644
--- a/Modules/CppMicroServices/core/test/usTestingMacros.h
+++ b/Modules/CppMicroServices/core/test/usTestingMacros.h
@@ -1,138 +1,138 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USTESTINGMACROS_H_
 #define USTESTINGMACROS_H_
 
 #include <exception>
 #include <string>
 #include <iostream>
 #include <cstdlib>
 
 #include "usTestManager.h"
 
 US_BEGIN_NAMESPACE
   /** \brief Indicate a failed test. */
   class TestFailedException : public std::exception {
     public:
       TestFailedException() {}
   };
 US_END_NAMESPACE
 
 /**
  *
  * \brief Output some text without generating a terminating newline.
  *
  * */
 #define US_TEST_OUTPUT_NO_ENDL(x) \
   std::cout x << std::flush;
 
 /** \brief Output some text. */
 #define US_TEST_OUTPUT(x) \
   US_TEST_OUTPUT_NO_ENDL(x << "\n")
 
 /** \brief Do some general test preparations. Must be called first in the
      main test function. */
 #define US_TEST_BEGIN(testName)                                                               \
   std::string usTestName(#testName);                                                          \
   US_PREPEND_NAMESPACE(TestManager)::GetInstance().Initialize();                              \
   try {
 
 /** \brief Fail and finish test with message MSG */
 #define US_TEST_FAILED_MSG(MSG)                                                               \
   US_TEST_OUTPUT(MSG)                                                                         \
   throw US_PREPEND_NAMESPACE(TestFailedException)();
 
 /** \brief Must be called last in the main test function. */
 #define US_TEST_END()                                                                         \
   } catch (const US_PREPEND_NAMESPACE(TestFailedException)&) {                                \
     US_TEST_OUTPUT(<< "Further test execution skipped.")                                      \
     US_PREPEND_NAMESPACE(TestManager)::GetInstance().TestFailed();                            \
   } catch (const std::exception& ex) {                                                        \
     US_TEST_OUTPUT(<< "Exception occured " << ex.what())                                      \
     US_PREPEND_NAMESPACE(TestManager)::GetInstance().TestFailed();                            \
   }                                                                                           \
   if (US_PREPEND_NAMESPACE(TestManager)::GetInstance().NumberOfFailedTests() > 0) {           \
     US_TEST_OUTPUT(<< usTestName << ": [DONE FAILED] , subtests passed: " <<                  \
     US_PREPEND_NAMESPACE(TestManager)::GetInstance().NumberOfPassedTests() << " failed: " <<  \
     US_PREPEND_NAMESPACE(TestManager)::GetInstance().NumberOfFailedTests() )                  \
     return EXIT_FAILURE;                                                                      \
   } else {                                                                                    \
     US_TEST_OUTPUT(<< usTestName << ": "                                                      \
                    << US_PREPEND_NAMESPACE(TestManager)::GetInstance().NumberOfPassedTests()  \
                    << " tests [DONE PASSED]")                                                 \
     return EXIT_SUCCESS;                                                                      \
   }
 
 #define US_TEST_CONDITION(COND,MSG)                                                           \
   US_TEST_OUTPUT_NO_ENDL(<< MSG)                                                              \
   if ( ! (COND) ) {                                                                           \
     US_PREPEND_NAMESPACE(TestManager)::GetInstance().TestFailed();                            \
     US_TEST_OUTPUT(<< " [FAILED]\n" << "In " << __FILE__                                      \
                    << ", line " << __LINE__                                                   \
                    << ":  " #COND " : [FAILED]")                                              \
   } else {                                                                                    \
     US_TEST_OUTPUT(<< " [PASSED]")                                                            \
     US_PREPEND_NAMESPACE(TestManager)::GetInstance().TestPassed();                            \
  }
 
 #define US_TEST_CONDITION_REQUIRED(COND,MSG)                                                  \
   US_TEST_OUTPUT_NO_ENDL(<< MSG)                                                              \
   if ( ! (COND) ) {                                                                           \
     US_TEST_FAILED_MSG(<< " [FAILED]\n" << "  +--> in " << __FILE__                           \
                        << ", line " << __LINE__                                               \
                        << ", expression is false: \"" #COND "\"")                             \
   } else {                                                                                    \
     US_TEST_OUTPUT(<< " [PASSED]")                                                            \
     US_PREPEND_NAMESPACE(TestManager)::GetInstance().TestPassed();                            \
  }
 
 /**
  * \brief Begin block which should be checked for exceptions
  *
  * This macro, together with US_TEST_FOR_EXCEPTION_END, can be used
  * to test whether a code block throws an expected exception. The test FAILS if the
  * exception is NOT thrown.
  */
 #define US_TEST_FOR_EXCEPTION_BEGIN(EXCEPTIONCLASS) \
   try {
 
 #define US_TEST_FOR_EXCEPTION_END(EXCEPTIONCLASS)                                             \
     US_PREPEND_NAMESPACE(TestManager)::GetInstance().TestFailed();                            \
     US_TEST_OUTPUT( << "Expected an '" << #EXCEPTIONCLASS << "' exception. [FAILED]")         \
   }                                                                                           \
   catch (const EXCEPTIONCLASS &) {                                                                    \
     US_TEST_OUTPUT(<< "Caught an expected '" << #EXCEPTIONCLASS                               \
                    << "' exception. [PASSED]")                                                \
     US_PREPEND_NAMESPACE(TestManager)::GetInstance().TestPassed();                            \
   }
 
 
 /**
  * \brief Simplified version of US_TEST_FOR_EXCEPTION_BEGIN / END for
  * a single statement
  */
 #define US_TEST_FOR_EXCEPTION(EXCEPTIONCLASS, STATEMENT)                                      \
   US_TEST_FOR_EXCEPTION_BEGIN(EXCEPTIONCLASS)                                                 \
   STATEMENT ;                                                                                 \
   US_TEST_FOR_EXCEPTION_END(EXCEPTIONCLASS)
 
 #endif // USTESTINGMACROS_H_
diff --git a/Modules/CppMicroServices/doc/CMakeDoxygenFilter.cpp b/Modules/CppMicroServices/doc/CMakeDoxygenFilter.cpp
index 98911ce407..f04f7f0d18 100644
--- a/Modules/CppMicroServices/doc/CMakeDoxygenFilter.cpp
+++ b/Modules/CppMicroServices/doc/CMakeDoxygenFilter.cpp
@@ -1,495 +1,495 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 <cstdlib>
 #include <string>
 #include <fstream>
 #include <iostream>
 
 #include <assert.h>
 
 //--------------------------------------
 // Utilitiy classes and functions
 //--------------------------------------
 
 struct ci_char_traits : public std::char_traits<char>
     // just inherit all the other functions
     //  that we don't need to override
 {
   static bool eq(char c1, char c2)
   { return toupper(c1) == toupper(c2); }
 
   static bool ne(char c1, char c2)
   { return toupper(c1) != toupper(c2); }
 
   static bool lt(char c1, char c2)
   { return toupper(c1) <  toupper(c2); }
 
   static bool gt(char c1, char c2)
   { return toupper(c1) >  toupper(c2); }
 
   static int compare(const char* s1, const char* s2, std::size_t n)
   {
     while (n-- > 0)
     {
       if (lt(*s1, *s2)) return -1;
       if (gt(*s1, *s2)) return 1;
       ++s1; ++s2;
     }
     return 0;
   }
 
   static const char* find(const char* s, int n, char a)
   {
     while (n-- > 0 && toupper(*s) != toupper(a))
     {
       ++s;
     }
     return s;
   }
 };
 
 typedef std::basic_string<char, ci_char_traits> ci_string;
 
 //--------------------------------------
 // Lexer
 //--------------------------------------
 
 class CMakeLexer
 {
 public:
 
   enum Token {
     TOK_EOF = -1,
     TOK_EOL = -2,
 
     // commands
     TOK_MACRO = -3, TOK_ENDMACRO = -4,
     TOK_FUNCTION = -5, TOK_ENDFUNCTION = -6,
     TOK_DOXYGEN_COMMENT = -7,
     TOK_SET = -8,
     TOK_STRING_LITERAL = -100,
     TOK_NUMBER_LITERAL = -102,
 
     // primary
     TOK_IDENTIFIER = -200
   };
 
   CMakeLexer(std::istream& is)
     : _lastChar(' '), _is(is), _line(1), _col(1)
   {}
 
   int getToken()
   {
     // skip whitespace
     while (isspace(_lastChar) && _lastChar != '\r' && _lastChar != '\n')
     {
       _lastChar = getChar();
     }
 
     if (isalpha(_lastChar) || _lastChar == '_')
     {
       _identifier = _lastChar;
       while (isalnum(_lastChar = getChar()) || _lastChar == '-' || _lastChar == '_')
       {
         _identifier += _lastChar;
       }
 
       if (_identifier == "set")
         return TOK_SET;
       if (_identifier == "function")
         return TOK_FUNCTION;
       if (_identifier == "macro")
         return TOK_MACRO;
       if (_identifier == "endfunction")
         return TOK_ENDFUNCTION;
       if (_identifier == "endmacro")
         return TOK_ENDMACRO;
       return TOK_IDENTIFIER;
     }
 
     if (isdigit(_lastChar))
     {
       // very lax!! number detection
       _identifier = _lastChar;
       while (isalnum(_lastChar = getChar()) || _lastChar == '.' || _lastChar == ',')
       {
         _identifier += _lastChar;
       }
       return TOK_NUMBER_LITERAL;
     }
 
     if (_lastChar == '#')
     {
       _lastChar = getChar();
       if (_lastChar == '!')
       {
         // found a doxygen comment marker
         _identifier.clear();
 
         _lastChar = getChar();
         while (_lastChar != EOF && _lastChar != '\n' && _lastChar != '\r')
         {
           _identifier += _lastChar;
           _lastChar = getChar();
         }
         return TOK_DOXYGEN_COMMENT;
       }
 
       // skip the comment
       while (_lastChar != EOF && _lastChar != '\n' && _lastChar != '\r')
       {
         _lastChar = getChar();
       }
     }
 
     if (_lastChar == '"')
     {
       _lastChar = getChar();
       _identifier.clear();
       while (_lastChar != EOF && _lastChar != '"')
       {
         _identifier += _lastChar;
         _lastChar = getChar();
       }
 
       // eat the closing "
       _lastChar = getChar();
       return TOK_STRING_LITERAL;
     }
 
     // don't eat the EOF
     if (_lastChar == EOF) return TOK_EOF;
 
     // don't eat the EOL
     if (_lastChar == '\r' || _lastChar == '\n')
     {
        if (_lastChar == '\r') _lastChar = getChar();
        if (_lastChar == '\n') _lastChar = getChar();
        return TOK_EOL;
     }
 
     // return the character as its ascii value
     int thisChar = _lastChar;
     _lastChar = getChar();
     return thisChar;
   }
 
   std::string getIdentifier() const
   {
     return std::string(_identifier.c_str());
   }
 
   int curLine() const
   { return _line; }
 
   int curCol() const
   { return _col; }
 
   int getChar()
   {
     int c = _is.get();
     updateLoc(c);
     return c;
   }
 
 private:
 
   void updateLoc(int c)
   {
     if (c == '\n' || c == '\r')
     {
       ++_line;
       _col = 1;
     }
     else
     {
       ++_col;
     }
   }
 
   ci_string _identifier;
   int _lastChar;
   std::istream& _is;
 
   int _line;
   int _col;
 };
 
 //--------------------------------------
 // Parser
 //--------------------------------------
 
 class CMakeParser
 {
 
 public:
 
   CMakeParser(std::istream& is, std::ostream& os)
     : _os(os), _lexer(is), _curToken(CMakeLexer::TOK_EOF), _lastToken(CMakeLexer::TOK_EOF)
   { }
 
   int curToken()
   {
     return _curToken;
   }
 
   int nextToken()
   {
     _lastToken = _curToken;
     _curToken = _lexer.getToken();
     while (_curToken == CMakeLexer::TOK_EOL)
     {
       // Try to preserve lines in output to allow correct line number referencing by doxygen.
       _os << std::endl;
       _curToken = _lexer.getToken();
     }
     return _curToken;
   }
 
   void handleMacro()
   {
     if(!parseMacro())
     {
       // skip token for error recovery
       nextToken();
     }
   }
 
   void handleFunction()
   {
     if(!parseFunction())
     {
       // skip token for error recovery
       nextToken();
     }
   }
 
   void handleSet()
   {
     // SET(var ...) following a documentation block is assumed to be a variable declaration.
     if (_lastToken != CMakeLexer::TOK_DOXYGEN_COMMENT)
     {
       // No comment block before
       nextToken();
     } else if(!parseSet())
     {
       // skip token for error recovery
       nextToken();
     }
   }
 
   void handleDoxygenComment()
   {
     _os << "///" << _lexer.getIdentifier();
     nextToken();
   }
 
   void handleTopLevelExpression()
   {
     // skip token
     nextToken();
   }
 
 private:
 
   void printError(const char* str)
   {
     std::cerr << "Error: " << str << " (at line " << _lexer.curLine() << ", col " << _lexer.curCol() << ")";
   }
 
   bool parseMacro()
   {
     if (nextToken() != '(')
     {
       printError("Expected '(' after MACRO");
       return false;
     }
 
     nextToken();
     std::string macroName = _lexer.getIdentifier();
     if (curToken() != CMakeLexer::TOK_IDENTIFIER || macroName.empty())
     {
       printError("Expected macro name");
       return false;
     }
 
     _os << macroName << '(';
     if (nextToken() == CMakeLexer::TOK_IDENTIFIER)
     {
       _os << _lexer.getIdentifier();
       while (nextToken() == CMakeLexer::TOK_IDENTIFIER)
       {
         _os << ", " << _lexer.getIdentifier();
       }
     }
 
     if (curToken() != ')')
     {
       printError("Missing expected ')'");
     }
     else
     {
       _os << ");";
     }
 
     // eat the ')'
     nextToken();
     return true;
   }
 
   bool parseSet()
   {
     if (nextToken() != '(')
     {
       printError("Expected '(' after SET");
       return false;
     }
 
     nextToken();
     std::string variableName = _lexer.getIdentifier();
     if (curToken() != CMakeLexer::TOK_IDENTIFIER || variableName.empty())
     {
       printError("Expected variable name");
       return false;
     }
 
     _os << "CMAKE_VARIABLE " << variableName;
 
     nextToken();
     while ((curToken() == CMakeLexer::TOK_IDENTIFIER)
            || (curToken() == CMakeLexer::TOK_STRING_LITERAL)
            || (curToken() == CMakeLexer::TOK_NUMBER_LITERAL))
     {
       nextToken();
     }
 
     if (curToken() != ')')
     {
       printError("Missing expected ')'");
     }
     else
     {
       _os << ";";
     }
 
     // eat the ')'
     nextToken();
     return true;
   }
 
   bool parseFunction()
   {
     if (nextToken() != '(')
     {
       printError("Expected '(' after FUNCTION");
       return false;
     }
 
     nextToken();
     std::string funcName = _lexer.getIdentifier();
     if (curToken() != CMakeLexer::TOK_IDENTIFIER || funcName.empty())
     {
       printError("Expected function name");
       return false;
     }
 
     _os << funcName << '(';
     if (nextToken() == CMakeLexer::TOK_IDENTIFIER)
     {
       _os << _lexer.getIdentifier();
       while (nextToken() == CMakeLexer::TOK_IDENTIFIER)
       {
         _os << ", " << _lexer.getIdentifier();
       }
     }
 
     if (curToken() != ')')
     {
       printError("Missing expected ')'");
     }
     else
     {
       _os << ");";
     }
 
     // eat the ')'
     nextToken();
 
     return true;
   }
 
   std::ostream& _os;
   CMakeLexer _lexer;
   int _curToken;
   int _lastToken;
 };
 
 
 #define STRINGIFY(a) #a
 #define DOUBLESTRINGIFY(a) STRINGIFY(a)
 
 int main(int argc, char** argv)
 {
   assert(argc > 1);
 
   for (int i = 1; i < argc; ++i)
   {
     std::ifstream ifs(argv[i]);
     std::ostream& os = std::cout;
 
     #ifdef USE_NAMESPACE
     os << "namespace " << DOUBLESTRINGIFY(USE_NAMESPACE) << " {\n";
     #endif
 
     CMakeParser parser(ifs, os);
     parser.nextToken();
     while (ifs.good())
     {
       switch (parser.curToken())
       {
       case CMakeLexer::TOK_EOF:
         return ifs.get(); // eat EOF
       case CMakeLexer::TOK_MACRO:
         parser.handleMacro();
         break;
       case CMakeLexer::TOK_FUNCTION:
         parser.handleFunction();
         break;
       case CMakeLexer::TOK_SET:
         parser.handleSet();
         break;
       case CMakeLexer::TOK_DOXYGEN_COMMENT:
         parser.handleDoxygenComment();
         break;
       default:
         parser.handleTopLevelExpression();
         break;
       }
     }
 
     #ifdef USE_NAMESPACE
     os << "}\n";
     #endif
   }
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/CppMicroServices/doc/doxygen/footer.html b/Modules/CppMicroServices/doc/doxygen/footer.html
index ea6b6dac83..fdcb775e7c 100644
--- a/Modules/CppMicroServices/doc/doxygen/footer.html
+++ b/Modules/CppMicroServices/doc/doxygen/footer.html
@@ -1,4 +1,4 @@
 
   <hr class="footer"/>
-  <address class="footer"><small>Generated on $date for $projectname $projectnumber by <a href="http://www.doxygen.org/index.html">Doxygen</a> $doxygenversion
+  <address class="footer"><small>Generated on $date for $projectname $projectnumber by <a href="https://doxygen.nl/index.html">Doxygen</a> $doxygenversion
 </small></address>
diff --git a/Modules/CppMicroServices/third_party/dirent_win32.h b/Modules/CppMicroServices/third_party/dirent_win32.h
index 72a233a652..8aa9178f5f 100644
--- a/Modules/CppMicroServices/third_party/dirent_win32.h
+++ b/Modules/CppMicroServices/third_party/dirent_win32.h
@@ -1,374 +1,373 @@
 /*****************************************************************************
  * dirent.h - dirent API for Microsoft Visual Studio
  *
  * Copyright (C) 2006 Toni Ronkko
  *
  * 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 TONI RONKKO 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.
  *
  * Mar 15, 2011, Toni Ronkko
  * Defined FILE_ATTRIBUTE_DEVICE for MSVC 6.0.
  *
  * Aug 11, 2010, Toni Ronkko
  * Added d_type and d_namlen fields to dirent structure.  The former is
  * especially useful for determining whether directory entry represents a
- * file or a directory.  For more information, see
- * http://www.delorie.com/gnu/docs/glibc/libc_270.html
+ * file or a directory.
  *
  * Aug 11, 2010, Toni Ronkko
  * Improved conformance to the standards.  For example, errno is now set
  * properly on failure and assert() is never used.  Thanks to Peter Brockam
  * for suggestions.
  *
  * Aug 11, 2010, Toni Ronkko
  * Fixed a bug in rewinddir(): when using relative directory names, change
  * of working directory no longer causes rewinddir() to fail.
  *
  * Dec 15, 2009, John Cunningham
  * Added rewinddir member function
  *
  * Jan 18, 2008, Toni Ronkko
  * Using FindFirstFileA and WIN32_FIND_DATAA to avoid converting string
  * between multi-byte and unicode representations.  This makes the
  * code simpler and also allows the code to be compiled under MingW.  Thanks
  * to Azriel Fasten for the suggestion.
  *
  * Mar 4, 2007, Toni Ronkko
  * Bug fix: due to the strncpy_s() function this file only compiled in
  * Visual Studio 2005.  Using the new string functions only when the
  * compiler version allows.
  *
  * Nov  2, 2006, Toni Ronkko
  * Major update: removed support for Watcom C, MS-DOS and Turbo C to
  * simplify the file, updated the code to compile cleanly on Visual
  * Studio 2005 with both unicode and multi-byte character strings,
  * removed rewinddir() as it had a bug.
  *
  * Aug 20, 2006, Toni Ronkko
  * Removed all remarks about MSVC 1.0, which is antiqued now.  Simplified
  * comments by removing SGML tags.
  *
  * May 14 2002, Toni Ronkko
  * Embedded the function definitions directly to the header so that no
  * source modules need to be included in the Visual Studio project.  Removed
  * all the dependencies to other projects so that this very header can be
  * used independently.
  *
  * May 28 1998, Toni Ronkko
  * First version.
  *****************************************************************************/
 #ifndef DIRENT_H
 #define DIRENT_H
 
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
 #include <windows.h>
 #include <string.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <errno.h>
 
 /* Entries missing from MSVC 6.0 */
 #if !defined(FILE_ATTRIBUTE_DEVICE)
 # define FILE_ATTRIBUTE_DEVICE 0x40
 #endif
 
 /* File type and permission flags for stat() */
 #if defined(_MSC_VER)  &&  !defined(S_IREAD)
 # define S_IFMT   _S_IFMT                      /* file type mask */
 # define S_IFDIR  _S_IFDIR                     /* directory */
 # define S_IFCHR  _S_IFCHR                     /* character device */
 # define S_IFFIFO _S_IFFIFO                    /* pipe */
 # define S_IFREG  _S_IFREG                     /* regular file */
 # define S_IREAD  _S_IREAD                     /* read permission */
 # define S_IWRITE _S_IWRITE                    /* write permission */
 # define S_IEXEC  _S_IEXEC                     /* execute permission */
 #endif
 #define S_IFBLK   0                            /* block device */
 #define S_IFLNK   0                            /* link */
 #define S_IFSOCK  0                            /* socket */
 
 #if defined(_MSC_VER)
 # define S_IRUSR  S_IREAD                      /* read, user */
 # define S_IWUSR  S_IWRITE                     /* write, user */
 # define S_IXUSR  0                            /* execute, user */
 # define S_IRGRP  0                            /* read, group */
 # define S_IWGRP  0                            /* write, group */
 # define S_IXGRP  0                            /* execute, group */
 # define S_IROTH  0                            /* read, others */
 # define S_IWOTH  0                            /* write, others */
 # define S_IXOTH  0                            /* execute, others */
 #endif
 
 /* Indicates that d_type field is available in dirent structure */
 #define _DIRENT_HAVE_D_TYPE
 
 /* File type flags for d_type */
 #define DT_UNKNOWN  0
 #define DT_REG      S_IFREG
 #define DT_DIR      S_IFDIR
 #define DT_FIFO     S_IFFIFO
 #define DT_SOCK     S_IFSOCK
 #define DT_CHR      S_IFCHR
 #define DT_BLK      S_IFBLK
 
 /* Macros for converting between st_mode and d_type */
 #define IFTODT(mode) ((mode) & S_IFMT)
 #define DTTOIF(type) (type)
 
 /*
  * File type macros.  Note that block devices, sockets and links cannot be
  * distinguished on Windows and the macros S_ISBLK, S_ISSOCK and S_ISLNK are
  * only defined for compatibility.  These macros should always return false
  * on Windows.
  */
 #define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFFIFO)
 #define S_ISDIR(mode)  (((mode) & S_IFMT) == S_IFDIR)
 #define S_ISREG(mode)  (((mode) & S_IFMT) == S_IFREG)
 #define S_ISLNK(mode)  (((mode) & S_IFMT) == S_IFLNK)
 #define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
 #define S_ISCHR(mode)  (((mode) & S_IFMT) == S_IFCHR)
 #define S_ISBLK(mode)  (((mode) & S_IFMT) == S_IFBLK)
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 
 typedef struct dirent
 {
    char d_name[MAX_PATH + 1];                  /* File name */
    size_t d_namlen;                            /* Length of name without \0 */
    int d_type;                                 /* File type */
 } dirent;
 
 
 typedef struct DIR
 {
    dirent           curentry;                  /* Current directory entry */
    WIN32_FIND_DATAA find_data;                 /* Private file data */
    int              cached;                    /* True if data is valid */
    HANDLE           search_handle;             /* Win32 search handle */
    char             patt[MAX_PATH + 3];        /* Initial directory name */
 } DIR;
 
 
 /* Forward declarations */
 static DIR *opendir(const char *dirname);
 static struct dirent *readdir(DIR *dirp);
 static int closedir(DIR *dirp);
 static void rewinddir(DIR* dirp);
 
 
 /* Use the new safe string functions introduced in Visual Studio 2005 */
 #if defined(_MSC_VER) && _MSC_VER >= 1400
 # define DIRENT_STRNCPY(dest,src,size) strncpy_s((dest),(size),(src),_TRUNCATE)
 #else
 # define DIRENT_STRNCPY(dest,src,size) strncpy((dest),(src),(size))
 #endif
 
 /* Set errno variable */
 #if defined(_MSC_VER)
 #define DIRENT_SET_ERRNO(x) _set_errno (x)
 #else
 #define DIRENT_SET_ERRNO(x) (errno = (x))
 #endif
 
 
 /*****************************************************************************
  * Open directory stream DIRNAME for read and return a pointer to the
  * internal working area that is used to retrieve individual directory
  * entries.
  */
 static DIR *opendir(const char *dirname)
 {
    DIR *dirp;
 
    /* ensure that the resulting search pattern will be a valid file name */
    if (dirname == nullptr) {
       DIRENT_SET_ERRNO (ENOENT);
       return nullptr;
    }
    if (strlen (dirname) + 3 >= MAX_PATH) {
       DIRENT_SET_ERRNO (ENAMETOOLONG);
       return nullptr;
    }
 
    /* construct new DIR structure */
    dirp = (DIR*) malloc (sizeof (struct DIR));
    if (dirp != nullptr) {
       int error;
 
       /*
        * Convert relative directory name to an absolute one.  This
        * allows rewinddir() to function correctly when the current working
        * directory is changed between opendir() and rewinddir().
        */
       if (GetFullPathNameA (dirname, MAX_PATH, dirp->patt, nullptr)) {
          char *p;
 
          /* append the search pattern "\\*\0" to the directory name */
          p = strchr (dirp->patt, '\0');
          if (dirp->patt < p  &&  *(p-1) != '\\'  &&  *(p-1) != ':') {
            *p++ = '\\';
          }
          *p++ = '*';
          *p = '\0';
 
          /* open directory stream and retrieve the first entry */
          dirp->search_handle = FindFirstFileA (dirp->patt, &dirp->find_data);
          if (dirp->search_handle != INVALID_HANDLE_VALUE) {
             /* a directory entry is now waiting in memory */
             dirp->cached = 1;
             error = 0;
          } else {
             /* search pattern is not a directory name? */
             DIRENT_SET_ERRNO (ENOENT);
             error = 1;
          }
       } else {
          /* buffer too small */
          DIRENT_SET_ERRNO (ENOMEM);
          error = 1;
       }
 
       if (error) {
          free (dirp);
          dirp = nullptr;
       }
    }
 
    return dirp;
 }
 
 
 /*****************************************************************************
  * Read a directory entry, and return a pointer to a dirent structure
  * containing the name of the entry in d_name field.  Individual directory
  * entries returned by this very function include regular files,
  * sub-directories, pseudo-directories "." and "..", but also volume labels,
  * hidden files and system files may be returned.
  */
 static struct dirent *readdir(DIR *dirp)
 {
    DWORD attr;
    if (dirp == nullptr) {
       /* directory stream did not open */
       DIRENT_SET_ERRNO (EBADF);
       return nullptr;
    }
 
    /* get next directory entry */
    if (dirp->cached != 0) {
       /* a valid directory entry already in memory */
       dirp->cached = 0;
    } else {
       /* get the next directory entry from stream */
       if (dirp->search_handle == INVALID_HANDLE_VALUE) {
          return nullptr;
       }
       if (FindNextFileA (dirp->search_handle, &dirp->find_data) == FALSE) {
          /* the very last entry has been processed or an error occured */
          FindClose (dirp->search_handle);
          dirp->search_handle = INVALID_HANDLE_VALUE;
          return nullptr;
       }
    }
 
    /* copy as a multibyte character string */
    DIRENT_STRNCPY ( dirp->curentry.d_name,
              dirp->find_data.cFileName,
              sizeof(dirp->curentry.d_name) );
    dirp->curentry.d_name[MAX_PATH] = '\0';
 
    /* compute the length of name */
    dirp->curentry.d_namlen = strlen (dirp->curentry.d_name);
 
    /* determine file type */
    attr = dirp->find_data.dwFileAttributes;
    if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
       dirp->curentry.d_type = DT_CHR;
    } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
       dirp->curentry.d_type = DT_DIR;
    } else {
       dirp->curentry.d_type = DT_REG;
    }
    return &dirp->curentry;
 }
 
 
 /*****************************************************************************
  * Close directory stream opened by opendir() function.  Close of the
  * directory stream invalidates the DIR structure as well as any previously
  * read directory entry.
  */
 static int closedir(DIR *dirp)
 {
    if (dirp == nullptr) {
       /* invalid directory stream */
       DIRENT_SET_ERRNO (EBADF);
       return -1;
    }
 
    /* release search handle */
    if (dirp->search_handle != INVALID_HANDLE_VALUE) {
       FindClose (dirp->search_handle);
       dirp->search_handle = INVALID_HANDLE_VALUE;
    }
 
    /* release directory structure */
    free (dirp);
    return 0;
 }
 
 
 /*****************************************************************************
  * Resets the position of the directory stream to which dirp refers to the
  * beginning of the directory.  It also causes the directory stream to refer
  * to the current state of the corresponding directory, as a call to opendir()
  * would have done.  If dirp does not refer to a directory stream, the effect
  * is undefined.
  */
 static void rewinddir(DIR* dirp)
 {
    if (dirp != nullptr) {
       /* release search handle */
       if (dirp->search_handle != INVALID_HANDLE_VALUE) {
          FindClose (dirp->search_handle);
       }
 
       /* open new search handle and retrieve the first entry */
       dirp->search_handle = FindFirstFileA (dirp->patt, &dirp->find_data);
       if (dirp->search_handle != INVALID_HANDLE_VALUE) {
          /* a directory entry is now waiting in memory */
          dirp->cached = 1;
       } else {
          /* failed to re-open directory: no directory entry in memory */
          dirp->cached = 0;
       }
    }
 }
 
 
 #ifdef __cplusplus
 }
 #endif
 #endif /*DIRENT_H*/
diff --git a/Modules/CppMicroServices/third_party/miniz.c b/Modules/CppMicroServices/third_party/miniz.c
index cdaba92086..044942157c 100644
--- a/Modules/CppMicroServices/third_party/miniz.c
+++ b/Modules/CppMicroServices/third_party/miniz.c
@@ -1,4929 +1,4928 @@
 /* miniz.c v1.15 - public domain deflate/inflate, zlib-subset, ZIP reading/writing/appending, PNG writing
    See "unlicense" statement at the end of this file.
    Rich Geldreich <richgel99@gmail.com>, last updated Oct. 13, 2013
-   Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt and RFC 1951: http://www.ietf.org/rfc/rfc1951.txt
+   Implements RFC 1950: https://www.ietf.org/rfc/rfc1950.txt and RFC 1951: https://www.ietf.org/rfc/rfc1951.txt
 
    Most API's defined in miniz.c are optional. For example, to disable the archive related functions just define
    MINIZ_NO_ARCHIVE_APIS, or to get rid of all stdio usage define MINIZ_NO_STDIO (see the list below for more macros).
 
    * Change History
      10/13/13 v1.15 r4 - Interim bugfix release while I work on the next major release with Zip64 support (almost there!):
        - Critical fix for the MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY bug (thanks kahmyong.moon@hp.com) which could cause locate files to not find files. This bug
         would only have occured in earlier versions if you explicitly used this flag, OR if you used mz_zip_extract_archive_file_to_heap() or mz_zip_add_mem_to_archive_file_in_place()
         (which used this flag). If you can't switch to v1.15 but want to fix this bug, just remove the uses of this flag from both helper funcs (and of course don't use the flag).
        - Bugfix in mz_zip_reader_extract_to_mem_no_alloc() from kymoon when pUser_read_buf is not NULL and compressed size is > uncompressed size
        - Fixing mz_zip_reader_extract_*() funcs so they don't try to extract compressed data from directory entries, to account for weird zipfiles which contain zero-size compressed data on dir entries.
          Hopefully this fix won't cause any issues on weird zip archives, because it assumes the low 16-bits of zip external attributes are DOS attributes (which I believe they always are in practice).
        - Fixing mz_zip_reader_is_file_a_directory() so it doesn't check the internal attributes, just the filename and external attributes
        - mz_zip_reader_init_file() - missing MZ_FCLOSE() call if the seek failed
        - Added cmake support for Linux builds which builds all the examples, tested with clang v3.3 and gcc v4.6.
        - Clang fix for tdefl_write_image_to_png_file_in_memory() from toffaletti
        - Merged MZ_FORCEINLINE fix from hdeanclark
        - Fix <time.h> include before config #ifdef, thanks emil.brink
        - Added tdefl_write_image_to_png_file_in_memory_ex(): supports Y flipping (super useful for OpenGL apps), and explicit control over the compression level (so you can
         set it to 1 for real-time compression).
        - Merged in some compiler fixes from paulharris's github repro.
        - Retested this build under Windows (VS 2010, including static analysis), tcc  0.9.26, gcc v4.6 and clang v3.3.
        - Added example6.c, which dumps an image of the mandelbrot set to a PNG file.
        - Modified example2 to help test the MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY flag more.
        - In r3: Bugfix to mz_zip_writer_add_file() found during merge: Fix possible src file fclose() leak if alignment bytes+local header file write faiiled
        - In r4: Minor bugfix to mz_zip_writer_add_from_zip_reader(): Was pushing the wrong central dir header offset, appears harmless in this release, but it became a problem in the zip64 branch
      5/20/12 v1.14 - MinGW32/64 GCC 4.6.1 compiler fixes: added MZ_FORCEINLINE, #include <time.h> (thanks fermtect).
      5/19/12 v1.13 - From jason@cornsyrup.org and kelwert@mtu.edu - Fix mz_crc32() so it doesn't compute the wrong CRC-32's when mz_ulong is 64-bit.
        - Temporarily/locally slammed in "typedef unsigned long mz_ulong" and re-ran a randomized regression test on ~500k files.
        - Eliminated a bunch of warnings when compiling with GCC 32-bit/64.
        - Ran all examples, miniz.c, and tinfl.c through MSVC 2008's /analyze (static analysis) option and fixed all warnings (except for the silly
         "Use of the comma-operator in a tested expression.." analysis warning, which I purposely use to work around a MSVC compiler warning).
        - Created 32-bit and 64-bit Codeblocks projects/workspace. Built and tested Linux executables. The codeblocks workspace is compatible with Linux+Win32/x64.
        - Added miniz_tester solution/project, which is a useful little app derived from LZHAM's tester app that I use as part of the regression test.
        - Ran miniz.c and tinfl.c through another series of regression testing on ~500,000 files and archives.
        - Modified example5.c so it purposely disables a bunch of high-level functionality (MINIZ_NO_STDIO, etc.). (Thanks to corysama for the MINIZ_NO_STDIO bug report.)
        - Fix ftell() usage in examples so they exit with an error on files which are too large (a limitation of the examples, not miniz itself).
      4/12/12 v1.12 - More comments, added low-level example5.c, fixed a couple minor level_and_flags issues in the archive API's.
       level_and_flags can now be set to MZ_DEFAULT_COMPRESSION. Thanks to Bruce Dawson <bruced@valvesoftware.com> for the feedback/bug report.
      5/28/11 v1.11 - Added statement from unlicense.org
      5/27/11 v1.10 - Substantial compressor optimizations:
       - Level 1 is now ~4x faster than before. The L1 compressor's throughput now varies between 70-110MB/sec. on a
       - Core i7 (actual throughput varies depending on the type of data, and x64 vs. x86).
       - Improved baseline L2-L9 compression perf. Also, greatly improved compression perf. issues on some file types.
       - Refactored the compression code for better readability and maintainability.
       - Added level 10 compression level (L10 has slightly better ratio than level 9, but could have a potentially large
        drop in throughput on some files).
      5/15/11 v1.09 - Initial stable release.
 
    * Low-level Deflate/Inflate implementation notes:
 
      Compression: Use the "tdefl" API's. The compressor supports raw, static, and dynamic blocks, lazy or
      greedy parsing, match length filtering, RLE-only, and Huffman-only streams. It performs and compresses
      approximately as well as zlib.
 
      Decompression: Use the "tinfl" API's. The entire decompressor is implemented as a single function
      coroutine: see tinfl_decompress(). It supports decompression into a 32KB (or larger power of 2) wrapping buffer, or into a memory
      block large enough to hold the entire file.
 
      The low-level tdefl/tinfl API's do not make any use of dynamic memory allocation.
 
    * zlib-style API notes:
 
      miniz.c implements a fairly large subset of zlib. There's enough functionality present for it to be a drop-in
      zlib replacement in many apps:
         The z_stream struct, optional memory allocation callbacks
         deflateInit/deflateInit2/deflate/deflateReset/deflateEnd/deflateBound
         inflateInit/inflateInit2/inflate/inflateEnd
         compress, compress2, compressBound, uncompress
         CRC-32, Adler-32 - Using modern, minimal code size, CPU cache friendly routines.
         Supports raw deflate streams or standard zlib streams with adler-32 checking.
 
      Limitations:
       The callback API's are not implemented yet. No support for gzip headers or zlib static dictionaries.
       I've tried to closely emulate zlib's various flavors of stream flushing and return status codes, but
       there are no guarantees that miniz.c pulls this off perfectly.
 
    * PNG writing: See the tdefl_write_image_to_png_file_in_memory() function, originally written by
      Alex Evans. Supports 1-4 bytes/pixel images.
 
    * ZIP archive API notes:
 
      The ZIP archive API's where designed with simplicity and efficiency in mind, with just enough abstraction to
      get the job done with minimal fuss. There are simple API's to retrieve file information, read files from
      existing archives, create new archives, append new files to existing archives, or clone archive data from
      one archive to another. It supports archives located in memory or the heap, on disk (using stdio.h),
      or you can specify custom file read/write callbacks.
 
      - Archive reading: Just call this function to read a single file from a disk archive:
 
       void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name,
         size_t *pSize, mz_uint zip_flags);
 
      For more complex cases, use the "mz_zip_reader" functions. Upon opening an archive, the entire central
      directory is located and read as-is into memory, and subsequent file access only occurs when reading individual files.
 
      - Archives file scanning: The simple way is to use this function to scan a loaded archive for a specific file:
 
      int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
 
      The locate operation can optionally check file comments too, which (as one example) can be used to identify
      multiple versions of the same file in an archive. This function uses a simple linear search through the central
      directory, so it's not very fast.
 
      Alternately, you can iterate through all the files in an archive (using mz_zip_reader_get_num_files()) and
      retrieve detailed info on each file by calling mz_zip_reader_file_stat().
 
      - Archive creation: Use the "mz_zip_writer" functions. The ZIP writer immediately writes compressed file data
      to disk and builds an exact image of the central directory in memory. The central directory image is written
      all at once at the end of the archive file when the archive is finalized.
 
      The archive writer can optionally align each file's local header and file data to any power of 2 alignment,
      which can be useful when the archive will be read from optical media. Also, the writer supports placing
      arbitrary data blobs at the very beginning of ZIP archives. Archives written using either feature are still
      readable by any ZIP tool.
 
      - Archive appending: The simple way to add a single file to an archive is to call this function:
 
       mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name,
         const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
 
      The archive will be created if it doesn't already exist, otherwise it'll be appended to.
      Note the appending is done in-place and is not an atomic operation, so if something goes wrong
      during the operation it's possible the archive could be left without a central directory (although the local
      file headers and file data will be fine, so the archive will be recoverable).
 
      For more complex archive modification scenarios:
      1. The safest way is to use a mz_zip_reader to read the existing archive, cloning only those bits you want to
      preserve into a new archive using using the mz_zip_writer_add_from_zip_reader() function (which compiles the
      compressed file data as-is). When you're done, delete the old archive and rename the newly written archive, and
      you're done. This is safe but requires a bunch of temporary disk space or heap memory.
 
      2. Or, you can convert an mz_zip_reader in-place to an mz_zip_writer using mz_zip_writer_init_from_reader(),
      append new files as needed, then finalize the archive which will write an updated central directory to the
      original archive. (This is basically what mz_zip_add_mem_to_archive_file_in_place() does.) There's a
      possibility that the archive's central directory could be lost with this method if anything goes wrong, though.
 
      - ZIP archive support limitations:
      No zip64 or spanning support. Extraction functions can only handle unencrypted, stored or deflated files.
      Requires streams capable of seeking.
 
    * This is a header file library, like stb_image.c. To get only a header file, either cut and paste the
      below header, or create miniz.h, #define MINIZ_HEADER_FILE_ONLY, and then include miniz.c from it.
 
    * Important: For best perf. be sure to customize the below macros for your target platform:
      #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
      #define MINIZ_LITTLE_ENDIAN 1
      #define MINIZ_HAS_64BIT_REGISTERS 1
 
    * On platforms using glibc, Be sure to "#define _LARGEFILE64_SOURCE 1" before including miniz.c to ensure miniz
      uses the 64-bit variants: fopen64(), stat64(), etc. Otherwise you won't be able to process large files
      (i.e. 32-bit stat() fails for me on files > 0x7FFFFFFF bytes).
 */
 
 #ifndef MINIZ_HEADER_INCLUDED
 #define MINIZ_HEADER_INCLUDED
 
 #include <stdlib.h>
 
 // Defines to completely disable specific portions of miniz.c:
 // If all macros here are defined the only functionality remaining will be CRC-32, adler-32, tinfl, and tdefl.
 
 // Define MINIZ_NO_STDIO to disable all usage and any functions which rely on stdio for file I/O.
 //#define MINIZ_NO_STDIO
 
 // If MINIZ_NO_TIME is specified then the ZIP archive functions will not be able to get the current time, or
 // get/set file times, and the C run-time funcs that get/set times won't be called.
 // The current downside is the times written to your archives will be from 1979.
 //#define MINIZ_NO_TIME
 
 // Define MINIZ_NO_ARCHIVE_APIS to disable all ZIP archive API's.
 //#define MINIZ_NO_ARCHIVE_APIS
 
 // Define MINIZ_NO_ARCHIVE_APIS to disable all writing related ZIP archive API's.
 //#define MINIZ_NO_ARCHIVE_WRITING_APIS
 
 // Define MINIZ_NO_ZLIB_APIS to remove all ZLIB-style compression/decompression API's.
 //#define MINIZ_NO_ZLIB_APIS
 
 // Define MINIZ_NO_ZLIB_COMPATIBLE_NAME to disable zlib names, to prevent conflicts against stock zlib.
 //#define MINIZ_NO_ZLIB_COMPATIBLE_NAMES
 
 // Define MINIZ_NO_MALLOC to disable all calls to malloc, free, and realloc.
 // Note if MINIZ_NO_MALLOC is defined then the user must always provide custom user alloc/free/realloc
 // callbacks to the zlib and archive API's, and a few stand-alone helper API's which don't provide custom user
 // functions (such as tdefl_compress_mem_to_heap() and tinfl_decompress_mem_to_heap()) won't work.
 //#define MINIZ_NO_MALLOC
 
 #if defined(__TINYC__) && (defined(__linux) || defined(__linux__))
   // TODO: Work around "error: include file 'sys\utime.h' when compiling with tcc on Linux
   #define MINIZ_NO_TIME
 #endif
 
 #if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_ARCHIVE_APIS)
   #include <time.h>
 #endif
 
 #if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || defined(__i386) || defined(__i486__) || defined(__i486) || defined(i386) || defined(__ia64__) || defined(__x86_64__)
 // MINIZ_X86_OR_X64_CPU is only used to help set the below macros.
 #define MINIZ_X86_OR_X64_CPU 1
 #endif
 
 #if (__BYTE_ORDER__==__ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU
 // Set MINIZ_LITTLE_ENDIAN to 1 if the processor is little endian.
 #define MINIZ_LITTLE_ENDIAN 1
 #endif
 
 #if MINIZ_X86_OR_X64_CPU
 // Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient integer loads and stores from unaligned addresses.
 #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
 #endif
 
 #if defined(_M_X64) || defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__) || defined(__ia64__) || defined(__x86_64__)
 // Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers are reasonably fast (and don't involve compiler generated calls to helper functions).
 #define MINIZ_HAS_64BIT_REGISTERS 1
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 // ------------------- zlib-style API Definitions.
 
 // For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits!
 typedef unsigned long mz_ulong;
 
 // mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap.
 void mz_free(void *p);
 
 #define MZ_ADLER32_INIT (1)
 // mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL.
 mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);
 
 #define MZ_CRC32_INIT (0)
 // mz_crc32() returns the initial CRC-32 value to use when called with ptr==NULL.
 mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);
 
 // Compression strategies.
 enum { MZ_DEFAULT_STRATEGY = 0, MZ_FILTERED = 1, MZ_HUFFMAN_ONLY = 2, MZ_RLE = 3, MZ_FIXED = 4 };
 
 // Method
 #define MZ_DEFLATED 8
 
 #ifndef MINIZ_NO_ZLIB_APIS
 
 // Heap allocation callbacks.
 // Note that mz_alloc_func parameter types purpsosely differ from zlib's: items/size is size_t, not unsigned long.
 typedef void *(*mz_alloc_func)(void *opaque, size_t items, size_t size);
 typedef void (*mz_free_func)(void *opaque, void *address);
 typedef void *(*mz_realloc_func)(void *opaque, void *address, size_t items, size_t size);
 
 #define MZ_VERSION          "9.1.15"
 #define MZ_VERNUM           0x91F0
 #define MZ_VER_MAJOR        9
 #define MZ_VER_MINOR        1
 #define MZ_VER_REVISION     15
 #define MZ_VER_SUBREVISION  0
 
 // Flush values. For typical usage you only need MZ_NO_FLUSH and MZ_FINISH. The other values are for advanced use (refer to the zlib docs).
 enum { MZ_NO_FLUSH = 0, MZ_PARTIAL_FLUSH = 1, MZ_SYNC_FLUSH = 2, MZ_FULL_FLUSH = 3, MZ_FINISH = 4, MZ_BLOCK = 5 };
 
 // Return status codes. MZ_PARAM_ERROR is non-standard.
 enum { MZ_OK = 0, MZ_STREAM_END = 1, MZ_NEED_DICT = 2, MZ_ERRNO = -1, MZ_STREAM_ERROR = -2, MZ_DATA_ERROR = -3, MZ_MEM_ERROR = -4, MZ_BUF_ERROR = -5, MZ_VERSION_ERROR = -6, MZ_PARAM_ERROR = -10000 };
 
 // Compression levels: 0-9 are the standard zlib-style levels, 10 is best possible compression (not zlib compatible, and may be very slow), MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL.
 enum { MZ_NO_COMPRESSION = 0, MZ_BEST_SPEED = 1, MZ_BEST_COMPRESSION = 9, MZ_UBER_COMPRESSION = 10, MZ_DEFAULT_LEVEL = 6, MZ_DEFAULT_COMPRESSION = -1 };
 
 // Window bits
 #define MZ_DEFAULT_WINDOW_BITS 15
 
 struct mz_internal_state;
 
 // Compression/decompression stream struct.
 typedef struct mz_stream_s
 {
   const unsigned char *next_in;     // pointer to next byte to read
   unsigned int avail_in;            // number of bytes available at next_in
   mz_ulong total_in;                // total number of bytes consumed so far
 
   unsigned char *next_out;          // pointer to next byte to write
   unsigned int avail_out;           // number of bytes that can be written to next_out
   mz_ulong total_out;               // total number of bytes produced so far
 
   char *msg;                        // error msg (unused)
   struct mz_internal_state *state;  // internal state, allocated by zalloc/zfree
 
   mz_alloc_func zalloc;             // optional heap allocation function (defaults to malloc)
   mz_free_func zfree;               // optional heap free function (defaults to free)
   void *opaque;                     // heap alloc function user pointer
 
   int data_type;                    // data_type (unused)
   mz_ulong adler;                   // adler32 of the source or uncompressed data
   mz_ulong reserved;                // not used
 } mz_stream;
 
 typedef mz_stream *mz_streamp;
 
 // Returns the version string of miniz.c.
 const char *mz_version(void);
 
 // mz_deflateInit() initializes a compressor with default options:
 // Parameters:
 //  pStream must point to an initialized mz_stream struct.
 //  level must be between [MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION].
 //  level 1 enables a specially optimized compression function that's been optimized purely for performance, not ratio.
 //  (This special func. is currently only enabled when MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are defined.)
 // Return values:
 //  MZ_OK on success.
 //  MZ_STREAM_ERROR if the stream is bogus.
 //  MZ_PARAM_ERROR if the input parameters are bogus.
 //  MZ_MEM_ERROR on out of memory.
 int mz_deflateInit(mz_streamp pStream, int level);
 
 // mz_deflateInit2() is like mz_deflate(), except with more control:
 // Additional parameters:
 //   method must be MZ_DEFLATED
 //   window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer)
 //   mem_level must be between [1, 9] (it's checked but ignored by miniz.c)
 int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);
 
 // Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2().
 int mz_deflateReset(mz_streamp pStream);
 
 // mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible.
 // Parameters:
 //   pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
 //   flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH, MZ_FULL_FLUSH, or MZ_FINISH.
 // Return values:
 //   MZ_OK on success (when flushing, or if more input is needed but not available, and/or there's more output to be written but the output buffer is full).
 //   MZ_STREAM_END if all input has been consumed and all output bytes have been written. Don't call mz_deflate() on the stream anymore.
 //   MZ_STREAM_ERROR if the stream is bogus.
 //   MZ_PARAM_ERROR if one of the parameters is invalid.
 //   MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.)
 int mz_deflate(mz_streamp pStream, int flush);
 
 // mz_deflateEnd() deinitializes a compressor:
 // Return values:
 //  MZ_OK on success.
 //  MZ_STREAM_ERROR if the stream is bogus.
 int mz_deflateEnd(mz_streamp pStream);
 
 // mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH.
 mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len);
 
 // Single-call compression functions mz_compress() and mz_compress2():
 // Returns MZ_OK on success, or one of the error codes from mz_deflate() on failure.
 int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
 int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);
 
 // mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress().
 mz_ulong mz_compressBound(mz_ulong source_len);
 
 // Initializes a decompressor.
 int mz_inflateInit(mz_streamp pStream);
 
 // mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer:
 // window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate).
 int mz_inflateInit2(mz_streamp pStream, int window_bits);
 
 // Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible.
 // Parameters:
 //   pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
 //   flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH.
 //   On the first call, if flush is MZ_FINISH it's assumed the input and output buffers are both sized large enough to decompress the entire stream in a single call (this is slightly faster).
 //   MZ_FINISH implies that there are no more source bytes available beside what's already in the input buffer, and that the output buffer is large enough to hold the rest of the decompressed data.
 // Return values:
 //   MZ_OK on success. Either more input is needed but not available, and/or there's more output to be written but the output buffer is full.
 //   MZ_STREAM_END if all needed input has been consumed and all output bytes have been written. For zlib streams, the adler-32 of the decompressed data has also been verified.
 //   MZ_STREAM_ERROR if the stream is bogus.
 //   MZ_DATA_ERROR if the deflate stream is invalid.
 //   MZ_PARAM_ERROR if one of the parameters is invalid.
 //   MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again
 //   with more input data, or with more room in the output buffer (except when using single call decompression, described above).
 int mz_inflate(mz_streamp pStream, int flush);
 
 // Deinitializes a decompressor.
 int mz_inflateEnd(mz_streamp pStream);
 
 // Single-call decompression.
 // Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure.
 int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
 
 // Returns a string description of the specified error code, or NULL if the error code is invalid.
 const char *mz_error(int err);
 
 // Redefine zlib-compatible names to miniz equivalents, so miniz.c can be used as a drop-in replacement for the subset of zlib that miniz.c supports.
 // Define MINIZ_NO_ZLIB_COMPATIBLE_NAMES to disable zlib-compatibility if you use zlib in the same project.
 #ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES
   typedef unsigned char Byte;
   typedef unsigned int uInt;
   typedef mz_ulong uLong;
   typedef Byte Bytef;
   typedef uInt uIntf;
   typedef char charf;
   typedef int intf;
   typedef void *voidpf;
   typedef uLong uLongf;
   typedef void *voidp;
   typedef void *const voidpc;
   #define Z_NULL                0
   #define Z_NO_FLUSH            MZ_NO_FLUSH
   #define Z_PARTIAL_FLUSH       MZ_PARTIAL_FLUSH
   #define Z_SYNC_FLUSH          MZ_SYNC_FLUSH
   #define Z_FULL_FLUSH          MZ_FULL_FLUSH
   #define Z_FINISH              MZ_FINISH
   #define Z_BLOCK               MZ_BLOCK
   #define Z_OK                  MZ_OK
   #define Z_STREAM_END          MZ_STREAM_END
   #define Z_NEED_DICT           MZ_NEED_DICT
   #define Z_ERRNO               MZ_ERRNO
   #define Z_STREAM_ERROR        MZ_STREAM_ERROR
   #define Z_DATA_ERROR          MZ_DATA_ERROR
   #define Z_MEM_ERROR           MZ_MEM_ERROR
   #define Z_BUF_ERROR           MZ_BUF_ERROR
   #define Z_VERSION_ERROR       MZ_VERSION_ERROR
   #define Z_PARAM_ERROR         MZ_PARAM_ERROR
   #define Z_NO_COMPRESSION      MZ_NO_COMPRESSION
   #define Z_BEST_SPEED          MZ_BEST_SPEED
   #define Z_BEST_COMPRESSION    MZ_BEST_COMPRESSION
   #define Z_DEFAULT_COMPRESSION MZ_DEFAULT_COMPRESSION
   #define Z_DEFAULT_STRATEGY    MZ_DEFAULT_STRATEGY
   #define Z_FILTERED            MZ_FILTERED
   #define Z_HUFFMAN_ONLY        MZ_HUFFMAN_ONLY
   #define Z_RLE                 MZ_RLE
   #define Z_FIXED               MZ_FIXED
   #define Z_DEFLATED            MZ_DEFLATED
   #define Z_DEFAULT_WINDOW_BITS MZ_DEFAULT_WINDOW_BITS
   #define alloc_func            mz_alloc_func
   #define free_func             mz_free_func
   #define internal_state        mz_internal_state
   #define z_stream              mz_stream
   #define deflateInit           mz_deflateInit
   #define deflateInit2          mz_deflateInit2
   #define deflateReset          mz_deflateReset
   #define deflate               mz_deflate
   #define deflateEnd            mz_deflateEnd
   #define deflateBound          mz_deflateBound
   #define compress              mz_compress
   #define compress2             mz_compress2
   #define compressBound         mz_compressBound
   #define inflateInit           mz_inflateInit
   #define inflateInit2          mz_inflateInit2
   #define inflate               mz_inflate
   #define inflateEnd            mz_inflateEnd
   #define uncompress            mz_uncompress
   #define crc32                 mz_crc32
   #define adler32               mz_adler32
   #define MAX_WBITS             15
   #define MAX_MEM_LEVEL         9
   #define zError                mz_error
   #define ZLIB_VERSION          MZ_VERSION
   #define ZLIB_VERNUM           MZ_VERNUM
   #define ZLIB_VER_MAJOR        MZ_VER_MAJOR
   #define ZLIB_VER_MINOR        MZ_VER_MINOR
   #define ZLIB_VER_REVISION     MZ_VER_REVISION
   #define ZLIB_VER_SUBREVISION  MZ_VER_SUBREVISION
   #define zlibVersion           mz_version
   #define zlib_version          mz_version()
 #endif // #ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES
 
 #endif // MINIZ_NO_ZLIB_APIS
 
 // ------------------- Types and macros
 
 typedef unsigned char mz_uint8;
 typedef signed short mz_int16;
 typedef unsigned short mz_uint16;
 typedef unsigned int mz_uint32;
 typedef unsigned int mz_uint;
 typedef long long mz_int64;
 typedef unsigned long long mz_uint64;
 typedef int mz_bool;
 
 #define MZ_FALSE (0)
 #define MZ_TRUE (1)
 
 // An attempt to work around MSVC's spammy "warning C4127: conditional expression is constant" message.
 #ifdef _MSC_VER
    #define MZ_MACRO_END while (0, 0)
 #else
    #define MZ_MACRO_END while (0)
 #endif
 
 // ------------------- ZIP archive reading/writing
 
 #ifndef MINIZ_NO_ARCHIVE_APIS
 
 enum
 {
   MZ_ZIP_MAX_IO_BUF_SIZE = 64*1024,
   MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE = 260,
   MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE = 256
 };
 
 typedef struct
 {
   mz_uint32 m_file_index;
   mz_uint32 m_central_dir_ofs;
   mz_uint16 m_version_made_by;
   mz_uint16 m_version_needed;
   mz_uint16 m_bit_flag;
   mz_uint16 m_method;
 #ifndef MINIZ_NO_TIME
   time_t m_time;
 #endif
   mz_uint32 m_crc32;
   mz_uint64 m_comp_size;
   mz_uint64 m_uncomp_size;
   mz_uint16 m_internal_attr;
   mz_uint32 m_external_attr;
   mz_uint64 m_local_header_ofs;
   mz_uint32 m_comment_size;
   char m_filename[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE];
   char m_comment[MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE];
 } mz_zip_archive_file_stat;
 
 typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n);
 typedef size_t (*mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n);
 
 struct mz_zip_internal_state_tag;
 typedef struct mz_zip_internal_state_tag mz_zip_internal_state;
 
 typedef enum
 {
   MZ_ZIP_MODE_INVALID = 0,
   MZ_ZIP_MODE_READING = 1,
   MZ_ZIP_MODE_WRITING = 2,
   MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3
 } mz_zip_mode;
 
 typedef struct mz_zip_archive_tag
 {
   mz_uint64 m_archive_size;
   mz_uint64 m_archive_file_ofs;
   mz_uint64 m_central_directory_file_ofs;
   mz_uint m_total_files;
   mz_zip_mode m_zip_mode;
 
   mz_uint m_file_offset_alignment;
 
   mz_alloc_func m_pAlloc;
   mz_free_func m_pFree;
   mz_realloc_func m_pRealloc;
   void *m_pAlloc_opaque;
 
   mz_file_read_func m_pRead;
   mz_file_write_func m_pWrite;
   void *m_pIO_opaque;
 
   mz_zip_internal_state *m_pState;
 
 } mz_zip_archive;
 
 typedef enum
 {
   MZ_ZIP_FLAG_CASE_SENSITIVE                = 0x0100,
   MZ_ZIP_FLAG_IGNORE_PATH                   = 0x0200,
   MZ_ZIP_FLAG_COMPRESSED_DATA               = 0x0400,
   MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY = 0x0800
 } mz_zip_flags;
 
 // ZIP archive reading
 
 // Inits a ZIP archive reader.
 // These functions read and validate the archive's central directory.
 mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint32 flags);
 mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint32 flags);
 
 #ifndef MINIZ_NO_STDIO
 mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags);
 #endif
 
 // Returns the total number of files in the archive.
 mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip);
 
 // Returns detailed information about an archive file entry.
 mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat);
 
 // Determines if an archive file entry is a directory entry.
 mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index);
 mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index);
 
 // Retrieves the filename of an archive file entry.
 // Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename.
 mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size);
 
 // Attempts to locates a file in the archive's central directory.
 // Valid flags: MZ_ZIP_FLAG_CASE_SENSITIVE, MZ_ZIP_FLAG_IGNORE_PATH
 // Returns -1 if the file cannot be found.
 int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
 
 // Extracts a archive file to a memory buffer using no memory allocation.
 mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
 mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
 
 // Extracts a archive file to a memory buffer.
 mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags);
 mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags);
 
 // Extracts a archive file to a dynamically allocated heap buffer.
 void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags);
 void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags);
 
 // Extracts a archive file using a callback function to output the file's data.
 mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
 mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
 
 #ifndef MINIZ_NO_STDIO
 // Extracts a archive file to a disk file and sets its last accessed and modified times.
 // This function only extracts files, not archive directory records.
 mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags);
 mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags);
 #endif
 
 // Ends archive reading, freeing all allocations, and closing the input archive file if mz_zip_reader_init_file() was used.
 mz_bool mz_zip_reader_end(mz_zip_archive *pZip);
 
 // ZIP archive writing
 
 #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
 
 // Inits a ZIP archive writer.
 mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size);
 mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size);
 
 #ifndef MINIZ_NO_STDIO
 mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning);
 #endif
 
 // Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive.
 // For archives opened using mz_zip_reader_init_file, pFilename must be the archive's filename so it can be reopened for writing. If the file can't be reopened, mz_zip_reader_end() will be called.
 // For archives opened using mz_zip_reader_init_mem, the memory block must be growable using the realloc callback (which defaults to realloc unless you've overridden it).
 // Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL.
 // Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before
 // the archive is finalized the file's central directory will be hosed.
 mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename);
 
 // Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive.
 // To add a directory entry, call this method with an archive name ending in a forwardslash with empty buffer.
 // level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
 mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags);
 mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32);
 
 #ifndef MINIZ_NO_STDIO
 // Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive.
 // level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
 mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
 #endif
 
 // Adds a file to an archive by fully cloning the data from another archive.
 // This function fully clones the source file's compressed data (no recompression), along with its full filename, extra data, and comment fields.
 mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint file_index);
 
 // Finalizes the archive by writing the central directory records followed by the end of central directory record.
 // After an archive is finalized, the only valid call on the mz_zip_archive struct is mz_zip_writer_end().
 // An archive must be manually finalized by calling this function for it to be valid.
 mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip);
 mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **pBuf, size_t *pSize);
 
 // Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used.
 // Note for the archive to be valid, it must have been finalized before ending.
 mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
 
 // Misc. high-level helper functions:
 
 // mz_zip_add_mem_to_archive_file_in_place() efficiently (but not atomically) appends a memory blob to a ZIP archive.
 // level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
 mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
 
 // Reads a single file from an archive into a heap block.
 // Returns NULL on failure.
 void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint zip_flags);
 
 #endif // #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
 
 #endif // #ifndef MINIZ_NO_ARCHIVE_APIS
 
 // ------------------- Low-level Decompression API Definitions
 
 // Decompression flags used by tinfl_decompress().
 // TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the input is a raw deflate stream.
 // TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available beyond the end of the supplied input buffer. If clear, the input buffer contains all remaining input.
 // TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large enough to hold the entire decompressed stream. If clear, the output buffer is at least the size of the dictionary (typically 32KB).
 // TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the decompressed bytes.
 enum
 {
   TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
   TINFL_FLAG_HAS_MORE_INPUT = 2,
   TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
   TINFL_FLAG_COMPUTE_ADLER32 = 8
 };
 
 // High level decompression functions:
 // tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc().
 // On entry:
 //  pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress.
 // On return:
 //  Function returns a pointer to the decompressed data, or NULL on failure.
 //  *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data.
 //  The caller must call mz_free() on the returned block when it's no longer needed.
 void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
 
 // tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory.
 // Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success.
 #define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1))
 size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
 
 // tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer.
 // Returns 1 on success or 0 on failure.
 typedef int (*tinfl_put_buf_func_ptr)(const void* pBuf, int len, void *pUser);
 int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
 
 struct tinfl_decompressor_tag; typedef struct tinfl_decompressor_tag tinfl_decompressor;
 
 // Max size of LZ dictionary.
 #define TINFL_LZ_DICT_SIZE 32768
 
 // Return status.
 typedef enum
 {
   TINFL_STATUS_BAD_PARAM = -3,
   TINFL_STATUS_ADLER32_MISMATCH = -2,
   TINFL_STATUS_FAILED = -1,
   TINFL_STATUS_DONE = 0,
   TINFL_STATUS_NEEDS_MORE_INPUT = 1,
   TINFL_STATUS_HAS_MORE_OUTPUT = 2
 } tinfl_status;
 
 // Initializes the decompressor to its initial state.
 #define tinfl_init(r) do { (r)->m_state = 0; } MZ_MACRO_END
 #define tinfl_get_adler32(r) (r)->m_check_adler32
 
 // Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability.
 // This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output.
 tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags);
 
 // Internal/private bits follow.
 enum
 {
   TINFL_MAX_HUFF_TABLES = 3, TINFL_MAX_HUFF_SYMBOLS_0 = 288, TINFL_MAX_HUFF_SYMBOLS_1 = 32, TINFL_MAX_HUFF_SYMBOLS_2 = 19,
   TINFL_FAST_LOOKUP_BITS = 10, TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS
 };
 
 typedef struct
 {
   mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0];
   mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE], m_tree[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
 } tinfl_huff_table;
 
 #if MINIZ_HAS_64BIT_REGISTERS
   #define TINFL_USE_64BIT_BITBUF 1
 #endif
 
 #if TINFL_USE_64BIT_BITBUF
   typedef mz_uint64 tinfl_bit_buf_t;
   #define TINFL_BITBUF_SIZE (64)
 #else
   typedef mz_uint32 tinfl_bit_buf_t;
   #define TINFL_BITBUF_SIZE (32)
 #endif
 
 struct tinfl_decompressor_tag
 {
   mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES];
   tinfl_bit_buf_t m_bit_buf;
   size_t m_dist_from_out_buf_start;
   tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES];
   mz_uint8 m_raw_header[4], m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + TINFL_MAX_HUFF_SYMBOLS_1 + 137];
 };
 
 // ------------------- Low-level Compression API Definitions
 
 // Set TDEFL_LESS_MEMORY to 1 to use less memory (compression will be slightly slower, and raw/dynamic blocks will be output more frequently).
 #define TDEFL_LESS_MEMORY 0
 
 // tdefl_init() compression flags logically OR'd together (low 12 bits contain the max. number of probes per dictionary search):
 // TDEFL_DEFAULT_MAX_PROBES: The compressor defaults to 128 dictionary probes per dictionary search. 0=Huffman only, 1=Huffman+LZ (fastest/crap compression), 4095=Huffman+LZ (slowest/best compression).
 enum
 {
   TDEFL_HUFFMAN_ONLY = 0, TDEFL_DEFAULT_MAX_PROBES = 128, TDEFL_MAX_PROBES_MASK = 0xFFF
 };
 
 // TDEFL_WRITE_ZLIB_HEADER: If set, the compressor outputs a zlib header before the deflate data, and the Adler-32 of the source data at the end. Otherwise, you'll get raw deflate data.
 // TDEFL_COMPUTE_ADLER32: Always compute the adler-32 of the input data (even when not writing zlib headers).
 // TDEFL_GREEDY_PARSING_FLAG: Set to use faster greedy parsing, instead of more efficient lazy parsing.
 // TDEFL_NONDETERMINISTIC_PARSING_FLAG: Enable to decrease the compressor's initialization time to the minimum, but the output may vary from run to run given the same input (depending on the contents of memory).
 // TDEFL_RLE_MATCHES: Only look for RLE matches (matches with a distance of 1)
 // TDEFL_FILTER_MATCHES: Discards matches <= 5 chars if enabled.
 // TDEFL_FORCE_ALL_STATIC_BLOCKS: Disable usage of optimized Huffman tables.
 // TDEFL_FORCE_ALL_RAW_BLOCKS: Only use raw (uncompressed) deflate blocks.
 // The low 12 bits are reserved to control the max # of hash probes per dictionary lookup (see TDEFL_MAX_PROBES_MASK).
 enum
 {
   TDEFL_WRITE_ZLIB_HEADER             = 0x01000,
   TDEFL_COMPUTE_ADLER32               = 0x02000,
   TDEFL_GREEDY_PARSING_FLAG           = 0x04000,
   TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000,
   TDEFL_RLE_MATCHES                   = 0x10000,
   TDEFL_FILTER_MATCHES                = 0x20000,
   TDEFL_FORCE_ALL_STATIC_BLOCKS       = 0x40000,
   TDEFL_FORCE_ALL_RAW_BLOCKS          = 0x80000
 };
 
 // High level compression functions:
 // tdefl_compress_mem_to_heap() compresses a block in memory to a heap block allocated via malloc().
 // On entry:
 //  pSrc_buf, src_buf_len: Pointer and size of source block to compress.
 //  flags: The max match finder probes (default is 128) logically OR'd against the above flags. Higher probes are slower but improve compression.
 // On return:
 //  Function returns a pointer to the compressed data, or NULL on failure.
 //  *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data.
 //  The caller must free() the returned block when it's no longer needed.
 void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
 
 // tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory.
 // Returns 0 on failure.
 size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
 
 // Compresses an image to a compressed PNG file in memory.
 // On entry:
 //  pImage, w, h, and num_chans describe the image to compress. num_chans may be 1, 2, 3, or 4.
 //  The image pitch in bytes per scanline will be w*num_chans. The leftmost pixel on the top scanline is stored first in memory.
 //  level may range from [0,10], use MZ_NO_COMPRESSION, MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc. or a decent default is MZ_DEFAULT_LEVEL
 //  If flip is true, the image will be flipped on the Y axis (useful for OpenGL apps).
 // On return:
 //  Function returns a pointer to the compressed data, or NULL on failure.
 //  *pLen_out will be set to the size of the PNG image file.
 //  The caller must mz_free() the returned heap block (which will typically be larger than *pLen_out) when it's no longer needed.
 void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip);
 void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out);
 
 // Output stream interface. The compressor uses this interface to write compressed data. It'll typically be called TDEFL_OUT_BUF_SIZE at a time.
 typedef mz_bool (*tdefl_put_buf_func_ptr)(const void* pBuf, int len, void *pUser);
 
 // tdefl_compress_mem_to_output() compresses a block to an output stream. The above helpers use this function internally.
 mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
 
 enum { TDEFL_MAX_HUFF_TABLES = 3, TDEFL_MAX_HUFF_SYMBOLS_0 = 288, TDEFL_MAX_HUFF_SYMBOLS_1 = 32, TDEFL_MAX_HUFF_SYMBOLS_2 = 19, TDEFL_LZ_DICT_SIZE = 32768, TDEFL_LZ_DICT_SIZE_MASK = TDEFL_LZ_DICT_SIZE - 1, TDEFL_MIN_MATCH_LEN = 3, TDEFL_MAX_MATCH_LEN = 258 };
 
 // TDEFL_OUT_BUF_SIZE MUST be large enough to hold a single entire compressed output block (using static/fixed Huffman codes).
 #if TDEFL_LESS_MEMORY
 enum { TDEFL_LZ_CODE_BUF_SIZE = 24 * 1024, TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13 ) / 10, TDEFL_MAX_HUFF_SYMBOLS = 288, TDEFL_LZ_HASH_BITS = 12, TDEFL_LEVEL1_HASH_SIZE_MASK = 4095, TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3, TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS };
 #else
 enum { TDEFL_LZ_CODE_BUF_SIZE = 64 * 1024, TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13 ) / 10, TDEFL_MAX_HUFF_SYMBOLS = 288, TDEFL_LZ_HASH_BITS = 15, TDEFL_LEVEL1_HASH_SIZE_MASK = 4095, TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3, TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS };
 #endif
 
 // The low-level tdefl functions below may be used directly if the above helper functions aren't flexible enough. The low-level functions don't make any heap allocations, unlike the above helper functions.
 typedef enum
 {
   TDEFL_STATUS_BAD_PARAM = -2,
   TDEFL_STATUS_PUT_BUF_FAILED = -1,
   TDEFL_STATUS_OKAY = 0,
   TDEFL_STATUS_DONE = 1,
 } tdefl_status;
 
 // Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums
 typedef enum
 {
   TDEFL_NO_FLUSH = 0,
   TDEFL_SYNC_FLUSH = 2,
   TDEFL_FULL_FLUSH = 3,
   TDEFL_FINISH = 4
 } tdefl_flush;
 
 // tdefl's compression state structure.
 typedef struct
 {
   tdefl_put_buf_func_ptr m_pPut_buf_func;
   void *m_pPut_buf_user;
   mz_uint m_flags, m_max_probes[2];
   int m_greedy_parsing;
   mz_uint m_adler32, m_lookahead_pos, m_lookahead_size, m_dict_size;
   mz_uint8 *m_pLZ_code_buf, *m_pLZ_flags, *m_pOutput_buf, *m_pOutput_buf_end;
   mz_uint m_num_flags_left, m_total_lz_bytes, m_lz_code_buf_dict_pos, m_bits_in, m_bit_buffer;
   mz_uint m_saved_match_dist, m_saved_match_len, m_saved_lit, m_output_flush_ofs, m_output_flush_remaining, m_finished, m_block_index, m_wants_to_finish;
   tdefl_status m_prev_return_status;
   const void *m_pIn_buf;
   void *m_pOut_buf;
   size_t *m_pIn_buf_size, *m_pOut_buf_size;
   tdefl_flush m_flush;
   const mz_uint8 *m_pSrc;
   size_t m_src_buf_left, m_out_buf_ofs;
   mz_uint8 m_dict[TDEFL_LZ_DICT_SIZE + TDEFL_MAX_MATCH_LEN - 1];
   mz_uint16 m_huff_count[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
   mz_uint16 m_huff_codes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
   mz_uint8 m_huff_code_sizes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
   mz_uint8 m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE];
   mz_uint16 m_next[TDEFL_LZ_DICT_SIZE];
   mz_uint16 m_hash[TDEFL_LZ_HASH_SIZE];
   mz_uint8 m_output_buf[TDEFL_OUT_BUF_SIZE];
 } tdefl_compressor;
 
 // Initializes the compressor.
 // There is no corresponding deinit() function because the tdefl API's do not dynamically allocate memory.
 // pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression.
 // If pBut_buf_func is NULL the user should always call the tdefl_compress() API.
 // flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.)
 tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
 
 // Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible.
 tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush);
 
 // tdefl_compress_buffer() is only usable when the tdefl_init() is called with a non-NULL tdefl_put_buf_func_ptr.
 // tdefl_compress_buffer() always consumes the entire input buffer.
 tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush);
 
 tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d);
 mz_uint32 tdefl_get_adler32(tdefl_compressor *d);
 
 // Can't use tdefl_create_comp_flags_from_zip_params if MINIZ_NO_ZLIB_APIS isn't defined, because it uses some of its macros.
 #ifndef MINIZ_NO_ZLIB_APIS
 // Create tdefl_compress() flags given zlib-style compression parameters.
 // level may range from [0,10] (where 10 is absolute max compression, but may be much slower on some files)
 // window_bits may be -15 (raw deflate) or 15 (zlib)
 // strategy may be either MZ_DEFAULT_STRATEGY, MZ_FILTERED, MZ_HUFFMAN_ONLY, MZ_RLE, or MZ_FIXED
 mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy);
 #endif // #ifndef MINIZ_NO_ZLIB_APIS
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MINIZ_HEADER_INCLUDED
 
 // ------------------- End of Header: Implementation follows. (If you only want the header, define MINIZ_HEADER_FILE_ONLY.)
 
 #ifndef MINIZ_HEADER_FILE_ONLY
 
 typedef unsigned char mz_validate_uint16[sizeof(mz_uint16)==2 ? 1 : -1];
 typedef unsigned char mz_validate_uint32[sizeof(mz_uint32)==4 ? 1 : -1];
 typedef unsigned char mz_validate_uint64[sizeof(mz_uint64)==8 ? 1 : -1];
 
 #include <string.h>
 #include <assert.h>
 
 #define MZ_ASSERT(x) assert(x)
 
 #ifdef MINIZ_NO_MALLOC
   #define MZ_MALLOC(x) NULL
   #define MZ_FREE(x) (void)x, ((void)0)
   #define MZ_REALLOC(p, x) NULL
 #else
   #define MZ_MALLOC(x) malloc(x)
   #define MZ_FREE(x) free(x)
   #define MZ_REALLOC(p, x) realloc(p, x)
 #endif
 
 #define MZ_MAX(a,b) (((a)>(b))?(a):(b))
 #define MZ_MIN(a,b) (((a)<(b))?(a):(b))
 #define MZ_CLEAR_OBJ(obj) memset(&(obj), 0, sizeof(obj))
 
 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
   #define MZ_READ_LE16(p) *((const mz_uint16 *)(p))
   #define MZ_READ_LE32(p) *((const mz_uint32 *)(p))
 #else
   #define MZ_READ_LE16(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
   #define MZ_READ_LE32(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
 #endif
 
 #ifdef _MSC_VER
   #define MZ_FORCEINLINE __forceinline
 #elif defined(__GNUC__)
   #define MZ_FORCEINLINE inline __attribute__((__always_inline__))
 #else
   #define MZ_FORCEINLINE inline
 #endif
 
 #ifdef __cplusplus
   extern "C" {
 #endif
 
 // ------------------- zlib-style API's
 
 mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)
 {
   mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16); size_t block_len = buf_len % 5552;
   if (!ptr) return MZ_ADLER32_INIT;
   while (buf_len) {
     for (i = 0; i + 7 < block_len; i += 8, ptr += 8) {
       s1 += ptr[0], s2 += s1; s1 += ptr[1], s2 += s1; s1 += ptr[2], s2 += s1; s1 += ptr[3], s2 += s1;
       s1 += ptr[4], s2 += s1; s1 += ptr[5], s2 += s1; s1 += ptr[6], s2 += s1; s1 += ptr[7], s2 += s1;
     }
     for ( ; i < block_len; ++i) s1 += *ptr++, s2 += s1;
     s1 %= 65521U, s2 %= 65521U; buf_len -= block_len; block_len = 5552;
   }
   return (s2 << 16) + s1;
 }
 
-// Karl Malbrain's compact CRC-32. See "A compact CCITT crc16 and crc32 C implementation that balances processor cache usage against speed": http://www.geocities.com/malbrain/
+// Karl Malbrain's compact CRC-32. See "A compact CCITT crc16 and crc32 C implementation that balances processor cache usage against speed"
 mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
 {
   static const mz_uint32 s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
     0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c };
   mz_uint32 crcu32 = (mz_uint32)crc;
   if (!ptr) return MZ_CRC32_INIT;
   crcu32 = ~crcu32; while (buf_len--) { mz_uint8 b = *ptr++; crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b & 0xF)]; crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b >> 4)]; }
   return ~crcu32;
 }
 
 void mz_free(void *p)
 {
   MZ_FREE(p);
 }
 
 #ifndef MINIZ_NO_ZLIB_APIS
 
 static void *def_alloc_func(void *opaque, size_t items, size_t size) { (void)opaque, (void)items, (void)size; return MZ_MALLOC(items * size); }
 static void def_free_func(void *opaque, void *address) { (void)opaque, (void)address; MZ_FREE(address); }
 static void *def_realloc_func(void *opaque, void *address, size_t items, size_t size) { (void)opaque, (void)address, (void)items, (void)size; return MZ_REALLOC(address, items * size); }
 
 const char *mz_version(void)
 {
   return MZ_VERSION;
 }
 
 int mz_deflateInit(mz_streamp pStream, int level)
 {
   return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY);
 }
 
 int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
 {
   tdefl_compressor *pComp;
   mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy);
 
   if (!pStream) return MZ_STREAM_ERROR;
   if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) return MZ_PARAM_ERROR;
 
   pStream->data_type = 0;
   pStream->adler = MZ_ADLER32_INIT;
   pStream->msg = NULL;
   pStream->reserved = 0;
   pStream->total_in = 0;
   pStream->total_out = 0;
   if (!pStream->zalloc) pStream->zalloc = def_alloc_func;
   if (!pStream->zfree) pStream->zfree = def_free_func;
 
   pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor));
   if (!pComp)
     return MZ_MEM_ERROR;
 
   pStream->state = (struct mz_internal_state *)pComp;
 
   if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY)
   {
     mz_deflateEnd(pStream);
     return MZ_PARAM_ERROR;
   }
 
   return MZ_OK;
 }
 
 int mz_deflateReset(mz_streamp pStream)
 {
   if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree)) return MZ_STREAM_ERROR;
   pStream->total_in = pStream->total_out = 0;
   tdefl_init((tdefl_compressor*)pStream->state, NULL, NULL, ((tdefl_compressor*)pStream->state)->m_flags);
   return MZ_OK;
 }
 
 int mz_deflate(mz_streamp pStream, int flush)
 {
   size_t in_bytes, out_bytes;
   mz_ulong orig_total_in, orig_total_out;
   int mz_status = MZ_OK;
 
   if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) return MZ_STREAM_ERROR;
   if (!pStream->avail_out) return MZ_BUF_ERROR;
 
   if (flush == MZ_PARTIAL_FLUSH) flush = MZ_SYNC_FLUSH;
 
   if (((tdefl_compressor*)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE)
     return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR;
 
   orig_total_in = pStream->total_in; orig_total_out = pStream->total_out;
   for ( ; ; )
   {
     tdefl_status defl_status;
     in_bytes = pStream->avail_in; out_bytes = pStream->avail_out;
 
     defl_status = tdefl_compress((tdefl_compressor*)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush);
     pStream->next_in += (mz_uint)in_bytes; pStream->avail_in -= (mz_uint)in_bytes;
     pStream->total_in += (mz_uint)in_bytes; pStream->adler = tdefl_get_adler32((tdefl_compressor*)pStream->state);
 
     pStream->next_out += (mz_uint)out_bytes; pStream->avail_out -= (mz_uint)out_bytes;
     pStream->total_out += (mz_uint)out_bytes;
 
     if (defl_status < 0)
     {
       mz_status = MZ_STREAM_ERROR;
       break;
     }
     else if (defl_status == TDEFL_STATUS_DONE)
     {
       mz_status = MZ_STREAM_END;
       break;
     }
     else if (!pStream->avail_out)
       break;
     else if ((!pStream->avail_in) && (flush != MZ_FINISH))
     {
       if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out))
         break;
       return MZ_BUF_ERROR; // Can't make forward progress without some input.
     }
   }
   return mz_status;
 }
 
 int mz_deflateEnd(mz_streamp pStream)
 {
   if (!pStream) return MZ_STREAM_ERROR;
   if (pStream->state)
   {
     pStream->zfree(pStream->opaque, pStream->state);
     pStream->state = NULL;
   }
   return MZ_OK;
 }
 
 mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len)
 {
   (void)pStream;
   // This is really over conservative. (And lame, but it's actually pretty tricky to compute a true upper bound given the way tdefl's blocking works.)
   return MZ_MAX(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5);
 }
 
 int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
 {
   int status;
   mz_stream stream;
   memset(&stream, 0, sizeof(stream));
 
   // In case mz_ulong is 64-bits (argh I hate longs).
   if ((source_len | *pDest_len) > 0xFFFFFFFFU) return MZ_PARAM_ERROR;
 
   stream.next_in = pSource;
   stream.avail_in = (mz_uint32)source_len;
   stream.next_out = pDest;
   stream.avail_out = (mz_uint32)*pDest_len;
 
   status = mz_deflateInit(&stream, level);
   if (status != MZ_OK) return status;
 
   status = mz_deflate(&stream, MZ_FINISH);
   if (status != MZ_STREAM_END)
   {
     mz_deflateEnd(&stream);
     return (status == MZ_OK) ? MZ_BUF_ERROR : status;
   }
 
   *pDest_len = stream.total_out;
   return mz_deflateEnd(&stream);
 }
 
 int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
 {
   return mz_compress2(pDest, pDest_len, pSource, source_len, MZ_DEFAULT_COMPRESSION);
 }
 
 mz_ulong mz_compressBound(mz_ulong source_len)
 {
   return mz_deflateBound(NULL, source_len);
 }
 
 typedef struct
 {
   tinfl_decompressor m_decomp;
   mz_uint m_dict_ofs, m_dict_avail, m_first_call, m_has_flushed; int m_window_bits;
   mz_uint8 m_dict[TINFL_LZ_DICT_SIZE];
   tinfl_status m_last_status;
 } inflate_state;
 
 int mz_inflateInit2(mz_streamp pStream, int window_bits)
 {
   inflate_state *pDecomp;
   if (!pStream) return MZ_STREAM_ERROR;
   if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) return MZ_PARAM_ERROR;
 
   pStream->data_type = 0;
   pStream->adler = 0;
   pStream->msg = NULL;
   pStream->total_in = 0;
   pStream->total_out = 0;
   pStream->reserved = 0;
   if (!pStream->zalloc) pStream->zalloc = def_alloc_func;
   if (!pStream->zfree) pStream->zfree = def_free_func;
 
   pDecomp = (inflate_state*)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state));
   if (!pDecomp) return MZ_MEM_ERROR;
 
   pStream->state = (struct mz_internal_state *)pDecomp;
 
   tinfl_init(&pDecomp->m_decomp);
   pDecomp->m_dict_ofs = 0;
   pDecomp->m_dict_avail = 0;
   pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
   pDecomp->m_first_call = 1;
   pDecomp->m_has_flushed = 0;
   pDecomp->m_window_bits = window_bits;
 
   return MZ_OK;
 }
 
 int mz_inflateInit(mz_streamp pStream)
 {
    return mz_inflateInit2(pStream, MZ_DEFAULT_WINDOW_BITS);
 }
 
 int mz_inflate(mz_streamp pStream, int flush)
 {
   inflate_state* pState;
   mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32;
   size_t in_bytes, out_bytes, orig_avail_in;
   tinfl_status status;
 
   if ((!pStream) || (!pStream->state)) return MZ_STREAM_ERROR;
   if (flush == MZ_PARTIAL_FLUSH) flush = MZ_SYNC_FLUSH;
   if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) return MZ_STREAM_ERROR;
 
   pState = (inflate_state*)pStream->state;
   if (pState->m_window_bits > 0) decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER;
   orig_avail_in = pStream->avail_in;
 
   first_call = pState->m_first_call; pState->m_first_call = 0;
   if (pState->m_last_status < 0) return MZ_DATA_ERROR;
 
   if (pState->m_has_flushed && (flush != MZ_FINISH)) return MZ_STREAM_ERROR;
   pState->m_has_flushed |= (flush == MZ_FINISH);
 
   if ((flush == MZ_FINISH) && (first_call))
   {
     // MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file.
     decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF;
     in_bytes = pStream->avail_in; out_bytes = pStream->avail_out;
     status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags);
     pState->m_last_status = status;
     pStream->next_in += (mz_uint)in_bytes; pStream->avail_in -= (mz_uint)in_bytes; pStream->total_in += (mz_uint)in_bytes;
     pStream->adler = tinfl_get_adler32(&pState->m_decomp);
     pStream->next_out += (mz_uint)out_bytes; pStream->avail_out -= (mz_uint)out_bytes; pStream->total_out += (mz_uint)out_bytes;
 
     if (status < 0)
       return MZ_DATA_ERROR;
     else if (status != TINFL_STATUS_DONE)
     {
       pState->m_last_status = TINFL_STATUS_FAILED;
       return MZ_BUF_ERROR;
     }
     return MZ_STREAM_END;
   }
   // flush != MZ_FINISH then we must assume there's more input.
   if (flush != MZ_FINISH) decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT;
 
   if (pState->m_dict_avail)
   {
     n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
     memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
     pStream->next_out += n; pStream->avail_out -= n; pStream->total_out += n;
     pState->m_dict_avail -= n; pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
     return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
   }
 
   for ( ; ; )
   {
     in_bytes = pStream->avail_in;
     out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs;
 
     status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pState->m_dict, pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags);
     pState->m_last_status = status;
 
     pStream->next_in += (mz_uint)in_bytes; pStream->avail_in -= (mz_uint)in_bytes;
     pStream->total_in += (mz_uint)in_bytes; pStream->adler = tinfl_get_adler32(&pState->m_decomp);
 
     pState->m_dict_avail = (mz_uint)out_bytes;
 
     n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
     memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
     pStream->next_out += n; pStream->avail_out -= n; pStream->total_out += n;
     pState->m_dict_avail -= n; pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
 
     if (status < 0)
        return MZ_DATA_ERROR; // Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well).
     else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in))
       return MZ_BUF_ERROR; // Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH.
     else if (flush == MZ_FINISH)
     {
        // The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH.
        if (status == TINFL_STATUS_DONE)
           return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END;
        // status here must be TINFL_STATUS_HAS_MORE_OUTPUT, which means there's at least 1 more byte on the way. If there's no more room left in the output buffer then something is wrong.
        else if (!pStream->avail_out)
           return MZ_BUF_ERROR;
     }
     else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail))
       break;
   }
 
   return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
 }
 
 int mz_inflateEnd(mz_streamp pStream)
 {
   if (!pStream)
     return MZ_STREAM_ERROR;
   if (pStream->state)
   {
     pStream->zfree(pStream->opaque, pStream->state);
     pStream->state = NULL;
   }
   return MZ_OK;
 }
 
 int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
 {
   mz_stream stream;
   int status;
   memset(&stream, 0, sizeof(stream));
 
   // In case mz_ulong is 64-bits (argh I hate longs).
   if ((source_len | *pDest_len) > 0xFFFFFFFFU) return MZ_PARAM_ERROR;
 
   stream.next_in = pSource;
   stream.avail_in = (mz_uint32)source_len;
   stream.next_out = pDest;
   stream.avail_out = (mz_uint32)*pDest_len;
 
   status = mz_inflateInit(&stream);
   if (status != MZ_OK)
     return status;
 
   status = mz_inflate(&stream, MZ_FINISH);
   if (status != MZ_STREAM_END)
   {
     mz_inflateEnd(&stream);
     return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status;
   }
   *pDest_len = stream.total_out;
 
   return mz_inflateEnd(&stream);
 }
 
 const char *mz_error(int err)
 {
   static struct { int m_err; const char *m_pDesc; } s_error_descs[] =
   {
     { MZ_OK, "" }, { MZ_STREAM_END, "stream end" }, { MZ_NEED_DICT, "need dictionary" }, { MZ_ERRNO, "file error" }, { MZ_STREAM_ERROR, "stream error" },
     { MZ_DATA_ERROR, "data error" }, { MZ_MEM_ERROR, "out of memory" }, { MZ_BUF_ERROR, "buf error" }, { MZ_VERSION_ERROR, "version error" }, { MZ_PARAM_ERROR, "parameter error" }
   };
   mz_uint i; for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i) if (s_error_descs[i].m_err == err) return s_error_descs[i].m_pDesc;
   return NULL;
 }
 
 #endif //MINIZ_NO_ZLIB_APIS
 
 // ------------------- Low-level Decompression (completely independent from all compression API's)
 
 #define TINFL_MEMCPY(d, s, l) memcpy(d, s, l)
 #define TINFL_MEMSET(p, c, l) memset(p, c, l)
 
 #define TINFL_CR_BEGIN switch(r->m_state) { case 0:
 #define TINFL_CR_RETURN(state_index, result) do { status = result; r->m_state = state_index; goto common_exit; case state_index:; } MZ_MACRO_END
 #define TINFL_CR_RETURN_FOREVER(state_index, result) do { for ( ; ; ) { TINFL_CR_RETURN(state_index, result); } } MZ_MACRO_END
 #define TINFL_CR_FINISH }
 
 // TODO: If the caller has indicated that there's no more input, and we attempt to read beyond the input buf, then something is wrong with the input because the inflator never
 // reads ahead more than it needs to. Currently TINFL_GET_BYTE() pads the end of the stream with 0's in this scenario.
 #define TINFL_GET_BYTE(state_index, c) do { \
   if (pIn_buf_cur >= pIn_buf_end) { \
     for ( ; ; ) { \
       if (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) { \
         TINFL_CR_RETURN(state_index, TINFL_STATUS_NEEDS_MORE_INPUT); \
         if (pIn_buf_cur < pIn_buf_end) { \
           c = *pIn_buf_cur++; \
           break; \
         } \
       } else { \
         c = 0; \
         break; \
       } \
     } \
   } else c = *pIn_buf_cur++; } MZ_MACRO_END
 
 #define TINFL_NEED_BITS(state_index, n) do { mz_uint c; TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; } while (num_bits < (mz_uint)(n))
 #define TINFL_SKIP_BITS(state_index, n) do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END
 #define TINFL_GET_BITS(state_index, b, n) do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } b = bit_buf & ((1 << (n)) - 1); bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END
 
 // TINFL_HUFF_BITBUF_FILL() is only used rarely, when the number of bytes remaining in the input buffer falls below 2.
 // It reads just enough bytes from the input stream that are needed to decode the next Huffman code (and absolutely no more). It works by trying to fully decode a
 // Huffman code by using whatever bits are currently present in the bit buffer. If this fails, it reads another byte, and tries again until it succeeds or until the
 // bit buffer contains >=15 bits (deflate's max. Huffman code size).
 #define TINFL_HUFF_BITBUF_FILL(state_index, pHuff) \
   do { \
     temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \
     if (temp >= 0) { \
       code_len = temp >> 9; \
       if ((code_len) && (num_bits >= code_len)) \
       break; \
     } else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \
        code_len = TINFL_FAST_LOOKUP_BITS; \
        do { \
           temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \
        } while ((temp < 0) && (num_bits >= (code_len + 1))); if (temp >= 0) break; \
     } TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; \
   } while (num_bits < 15);
 
 // TINFL_HUFF_DECODE() decodes the next Huffman coded symbol. It's more complex than you would initially expect because the zlib API expects the decompressor to never read
 // beyond the final byte of the deflate stream. (In other words, when this macro wants to read another byte from the input, it REALLY needs another byte in order to fully
 // decode the next Huffman code.) Handling this properly is particularly important on raw deflate (non-zlib) streams, which aren't followed by a byte aligned adler-32.
 // The slow path is only executed at the very end of the input buffer.
 #define TINFL_HUFF_DECODE(state_index, sym, pHuff) do { \
   int temp; mz_uint code_len, c; \
   if (num_bits < 15) { \
     if ((pIn_buf_end - pIn_buf_cur) < 2) { \
        TINFL_HUFF_BITBUF_FILL(state_index, pHuff); \
     } else { \
        bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); pIn_buf_cur += 2; num_bits += 16; \
     } \
   } \
   if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \
     code_len = temp >> 9, temp &= 511; \
   else { \
     code_len = TINFL_FAST_LOOKUP_BITS; do { temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; } while (temp < 0); \
   } sym = temp; bit_buf >>= code_len; num_bits -= code_len; } MZ_MACRO_END
 
 tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags)
 {
   static const int s_length_base[31] = { 3,4,5,6,7,8,9,10,11,13, 15,17,19,23,27,31,35,43,51,59, 67,83,99,115,131,163,195,227,258,0,0 };
   static const int s_length_extra[31]= { 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
   static const int s_dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
   static const int s_dist_extra[32] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
   static const mz_uint8 s_length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
   static const int s_min_table_sizes[3] = { 257, 1, 4 };
 
   tinfl_status status = TINFL_STATUS_FAILED; mz_uint32 num_bits, dist, counter, num_extra; tinfl_bit_buf_t bit_buf;
   const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size;
   mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next + *pOut_buf_size;
   size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start;
 
   // Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter).
   if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) { *pIn_buf_size = *pOut_buf_size = 0; return TINFL_STATUS_BAD_PARAM; }
 
   num_bits = r->m_num_bits; bit_buf = r->m_bit_buf; dist = r->m_dist; counter = r->m_counter; num_extra = r->m_num_extra; dist_from_out_buf_start = r->m_dist_from_out_buf_start;
   TINFL_CR_BEGIN
 
   bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; r->m_z_adler32 = r->m_check_adler32 = 1;
   if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
   {
     TINFL_GET_BYTE(1, r->m_zhdr0); TINFL_GET_BYTE(2, r->m_zhdr1);
     counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8));
     if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)(1U << (8U + (r->m_zhdr0 >> 4)))));
     if (counter) { TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED); }
   }
 
   do
   {
     TINFL_GET_BITS(3, r->m_final, 3); r->m_type = r->m_final >> 1;
     if (r->m_type == 0)
     {
       TINFL_SKIP_BITS(5, num_bits & 7);
       for (counter = 0; counter < 4; ++counter) { if (num_bits) TINFL_GET_BITS(6, r->m_raw_header[counter], 8); else TINFL_GET_BYTE(7, r->m_raw_header[counter]); }
       if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) { TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED); }
       while ((counter) && (num_bits))
       {
         TINFL_GET_BITS(51, dist, 8);
         while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); }
         *pOut_buf_cur++ = (mz_uint8)dist;
         counter--;
       }
       while (counter)
       {
         size_t n; while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); }
         while (pIn_buf_cur >= pIn_buf_end)
         {
           if (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)
           {
             TINFL_CR_RETURN(38, TINFL_STATUS_NEEDS_MORE_INPUT);
           }
           else
           {
             TINFL_CR_RETURN_FOREVER(40, TINFL_STATUS_FAILED);
           }
         }
         n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter);
         TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); pIn_buf_cur += n; pOut_buf_cur += n; counter -= (mz_uint)n;
       }
     }
     else if (r->m_type == 3)
     {
       TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED);
     }
     else
     {
       if (r->m_type == 1)
       {
         mz_uint8 *p = r->m_tables[0].m_code_size; mz_uint i;
         r->m_table_sizes[0] = 288; r->m_table_sizes[1] = 32; TINFL_MEMSET(r->m_tables[1].m_code_size, 5, 32);
         for ( i = 0; i <= 143; ++i) *p++ = 8; for ( ; i <= 255; ++i) *p++ = 9; for ( ; i <= 279; ++i) *p++ = 7; for ( ; i <= 287; ++i) *p++ = 8;
       }
       else
       {
         for (counter = 0; counter < 3; counter++) { TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); r->m_table_sizes[counter] += s_min_table_sizes[counter]; }
         MZ_CLEAR_OBJ(r->m_tables[2].m_code_size); for (counter = 0; counter < r->m_table_sizes[2]; counter++) { mz_uint s; TINFL_GET_BITS(14, s, 3); r->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (mz_uint8)s; }
         r->m_table_sizes[2] = 19;
       }
       for ( ; (int)r->m_type >= 0; r->m_type--)
       {
         int tree_next, tree_cur; tinfl_huff_table *pTable;
         mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16]; pTable = &r->m_tables[r->m_type]; MZ_CLEAR_OBJ(total_syms); MZ_CLEAR_OBJ(pTable->m_look_up); MZ_CLEAR_OBJ(pTable->m_tree);
         for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) total_syms[pTable->m_code_size[i]]++;
         used_syms = 0, total = 0; next_code[0] = next_code[1] = 0;
         for (i = 1; i <= 15; ++i) { used_syms += total_syms[i]; next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); }
         if ((65536 != total) && (used_syms > 1))
         {
           TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED);
         }
         for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index)
         {
           mz_uint rev_code = 0, l, cur_code, code_size = pTable->m_code_size[sym_index]; if (!code_size) continue;
           cur_code = next_code[code_size]++; for (l = code_size; l > 0; l--, cur_code >>= 1) rev_code = (rev_code << 1) | (cur_code & 1);
           if (code_size <= TINFL_FAST_LOOKUP_BITS) { mz_int16 k = (mz_int16)((code_size << 9) | sym_index); while (rev_code < TINFL_FAST_LOOKUP_SIZE) { pTable->m_look_up[rev_code] = k; rev_code += (1 << code_size); } continue; }
           if (0 == (tree_cur = pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) { pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next; tree_cur = tree_next; tree_next -= 2; }
           rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1);
           for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--)
           {
             tree_cur -= ((rev_code >>= 1) & 1);
             if (!pTable->m_tree[-tree_cur - 1]) { pTable->m_tree[-tree_cur - 1] = (mz_int16)tree_next; tree_cur = tree_next; tree_next -= 2; } else tree_cur = pTable->m_tree[-tree_cur - 1];
           }
           tree_cur -= ((rev_code >>= 1) & 1); pTable->m_tree[-tree_cur - 1] = (mz_int16)sym_index;
         }
         if (r->m_type == 2)
         {
           for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]); )
           {
             mz_uint s; TINFL_HUFF_DECODE(16, dist, &r->m_tables[2]); if (dist < 16) { r->m_len_codes[counter++] = (mz_uint8)dist; continue; }
             if ((dist == 16) && (!counter))
             {
               TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED);
             }
             num_extra = "\02\03\07"[dist - 16]; TINFL_GET_BITS(18, s, num_extra); s += "\03\03\013"[dist - 16];
             TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); counter += s;
           }
           if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter)
           {
             TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED);
           }
           TINFL_MEMCPY(r->m_tables[0].m_code_size, r->m_len_codes, r->m_table_sizes[0]); TINFL_MEMCPY(r->m_tables[1].m_code_size, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]);
         }
       }
       for ( ; ; )
       {
         mz_uint8 *pSrc;
         for ( ; ; )
         {
           if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
           {
             TINFL_HUFF_DECODE(23, counter, &r->m_tables[0]);
             if (counter >= 256)
               break;
             while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); }
             *pOut_buf_cur++ = (mz_uint8)counter;
           }
           else
           {
             int sym2; mz_uint code_len;
 #if TINFL_USE_64BIT_BITBUF
             if (num_bits < 30) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); pIn_buf_cur += 4; num_bits += 32; }
 #else
             if (num_bits < 15) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); pIn_buf_cur += 2; num_bits += 16; }
 #endif
             if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
               code_len = sym2 >> 9;
             else
             {
               code_len = TINFL_FAST_LOOKUP_BITS; do { sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; } while (sym2 < 0);
             }
             counter = sym2; bit_buf >>= code_len; num_bits -= code_len;
             if (counter & 256)
               break;
 
 #if !TINFL_USE_64BIT_BITBUF
             if (num_bits < 15) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); pIn_buf_cur += 2; num_bits += 16; }
 #endif
             if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
               code_len = sym2 >> 9;
             else
             {
               code_len = TINFL_FAST_LOOKUP_BITS; do { sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; } while (sym2 < 0);
             }
             bit_buf >>= code_len; num_bits -= code_len;
 
             pOut_buf_cur[0] = (mz_uint8)counter;
             if (sym2 & 256)
             {
               pOut_buf_cur++;
               counter = sym2;
               break;
             }
             pOut_buf_cur[1] = (mz_uint8)sym2;
             pOut_buf_cur += 2;
           }
         }
         if ((counter &= 511) == 256) break;
 
         num_extra = s_length_extra[counter - 257]; counter = s_length_base[counter - 257];
         if (num_extra) { mz_uint extra_bits; TINFL_GET_BITS(25, extra_bits, num_extra); counter += extra_bits; }
 
         TINFL_HUFF_DECODE(26, dist, &r->m_tables[1]);
         num_extra = s_dist_extra[dist]; dist = s_dist_base[dist];
         if (num_extra) { mz_uint extra_bits; TINFL_GET_BITS(27, extra_bits, num_extra); dist += extra_bits; }
 
         dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
         if ((dist > dist_from_out_buf_start) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
         {
           TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED);
         }
 
         pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);
 
         if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)
         {
           while (counter--)
           {
             while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); }
             *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];
           }
           continue;
         }
 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
         else if ((counter >= 9) && (counter <= dist))
         {
           const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
           do
           {
             ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
             ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
             pOut_buf_cur += 8;
           } while ((pSrc += 8) < pSrc_end);
           if ((counter &= 7) < 3)
           {
             if (counter)
             {
               pOut_buf_cur[0] = pSrc[0];
               if (counter > 1)
                 pOut_buf_cur[1] = pSrc[1];
               pOut_buf_cur += counter;
             }
             continue;
           }
         }
 #endif
         do
         {
           pOut_buf_cur[0] = pSrc[0];
           pOut_buf_cur[1] = pSrc[1];
           pOut_buf_cur[2] = pSrc[2];
           pOut_buf_cur += 3; pSrc += 3;
         } while ((int)(counter -= 3) > 2);
         if ((int)counter > 0)
         {
           pOut_buf_cur[0] = pSrc[0];
           if ((int)counter > 1)
             pOut_buf_cur[1] = pSrc[1];
           pOut_buf_cur += counter;
         }
       }
     }
   } while (!(r->m_final & 1));
   if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
   {
     TINFL_SKIP_BITS(32, num_bits & 7); for (counter = 0; counter < 4; ++counter) { mz_uint s; if (num_bits) TINFL_GET_BITS(41, s, 8); else TINFL_GET_BYTE(42, s); r->m_z_adler32 = (r->m_z_adler32 << 8) | s; }
   }
   TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE);
   TINFL_CR_FINISH
 
 common_exit:
   r->m_num_bits = num_bits; r->m_bit_buf = bit_buf; r->m_dist = dist; r->m_counter = counter; r->m_num_extra = num_extra; r->m_dist_from_out_buf_start = dist_from_out_buf_start;
   *pIn_buf_size = pIn_buf_cur - pIn_buf_next; *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
   if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0))
   {
     const mz_uint8 *ptr = pOut_buf_next; size_t buf_len = *pOut_buf_size;
     mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16; size_t block_len = buf_len % 5552;
     while (buf_len)
     {
       for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
       {
         s1 += ptr[0], s2 += s1; s1 += ptr[1], s2 += s1; s1 += ptr[2], s2 += s1; s1 += ptr[3], s2 += s1;
         s1 += ptr[4], s2 += s1; s1 += ptr[5], s2 += s1; s1 += ptr[6], s2 += s1; s1 += ptr[7], s2 += s1;
       }
       for ( ; i < block_len; ++i) s1 += *ptr++, s2 += s1;
       s1 %= 65521U, s2 %= 65521U; buf_len -= block_len; block_len = 5552;
     }
     r->m_check_adler32 = (s2 << 16) + s1; if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) status = TINFL_STATUS_ADLER32_MISMATCH;
   }
   return status;
 }
 
 // Higher level helper functions.
 void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
 {
   tinfl_decompressor decomp; void *pBuf = NULL, *pNew_buf; size_t src_buf_ofs = 0, out_buf_capacity = 0;
   *pOut_len = 0;
   tinfl_init(&decomp);
   for ( ; ; )
   {
     size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
     tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8*)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8*)pBuf, pBuf ? (mz_uint8*)pBuf + *pOut_len : NULL, &dst_buf_size,
       (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
     if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
     {
       MZ_FREE(pBuf); *pOut_len = 0; return NULL;
     }
     src_buf_ofs += src_buf_size;
     *pOut_len += dst_buf_size;
     if (status == TINFL_STATUS_DONE) break;
     new_out_buf_capacity = out_buf_capacity * 2; if (new_out_buf_capacity < 128) new_out_buf_capacity = 128;
     pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
     if (!pNew_buf)
     {
       MZ_FREE(pBuf); *pOut_len = 0; return NULL;
     }
     pBuf = pNew_buf; out_buf_capacity = new_out_buf_capacity;
   }
   return pBuf;
 }
 
 size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
 {
   tinfl_decompressor decomp; tinfl_status status; tinfl_init(&decomp);
   status = tinfl_decompress(&decomp, (const mz_uint8*)pSrc_buf, &src_buf_len, (mz_uint8*)pOut_buf, (mz_uint8*)pOut_buf, &out_buf_len, (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
   return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len;
 }
 
 int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
 {
   int result = 0;
   tinfl_decompressor decomp;
   mz_uint8 *pDict = (mz_uint8*)MZ_MALLOC(TINFL_LZ_DICT_SIZE); size_t in_buf_ofs = 0, dict_ofs = 0;
   if (!pDict)
     return TINFL_STATUS_FAILED;
   tinfl_init(&decomp);
   for ( ; ; )
   {
     size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
     tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8*)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
       (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
     in_buf_ofs += in_buf_size;
     if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
       break;
     if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
     {
       result = (status == TINFL_STATUS_DONE);
       break;
     }
     dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
   }
   MZ_FREE(pDict);
   *pIn_buf_size = in_buf_ofs;
   return result;
 }
 
 // ------------------- Low-level Compression (independent from all decompression API's)
 
 // Purposely making these tables static for faster init and thread safety.
 static const mz_uint16 s_tdefl_len_sym[256] = {
   257,258,259,260,261,262,263,264,265,265,266,266,267,267,268,268,269,269,269,269,270,270,270,270,271,271,271,271,272,272,272,272,
   273,273,273,273,273,273,273,273,274,274,274,274,274,274,274,274,275,275,275,275,275,275,275,275,276,276,276,276,276,276,276,276,
   277,277,277,277,277,277,277,277,277,277,277,277,277,277,277,277,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,
   279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,280,280,280,280,280,280,280,280,280,280,280,280,280,280,280,280,
   281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,
   282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,
   283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,
   284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,285 };
 
 static const mz_uint8 s_tdefl_len_extra[256] = {
   0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
   4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0 };
 
 static const mz_uint8 s_tdefl_small_dist_sym[512] = {
   0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,
   11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,
   13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,14,14,14,
   14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
   14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
   15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,16,16,16,16,16,16,16,16,16,16,16,16,16,
   16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
   16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
   16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
   17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
   17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
   17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17 };
 
 static const mz_uint8 s_tdefl_small_dist_extra[512] = {
   0,0,0,0,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,
   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
   7,7,7,7,7,7,7,7 };
 
 static const mz_uint8 s_tdefl_large_dist_sym[128] = {
   0,0,18,19,20,20,21,21,22,22,22,22,23,23,23,23,24,24,24,24,24,24,24,24,25,25,25,25,25,25,25,25,26,26,26,26,26,26,26,26,26,26,26,26,
   26,26,26,26,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,
   28,28,28,28,28,28,28,28,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29 };
 
 static const mz_uint8 s_tdefl_large_dist_extra[128] = {
   0,0,8,8,9,9,9,9,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
   12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
   13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13 };
 
 // Radix sorts tdefl_sym_freq[] array by 16-bit key m_key. Returns ptr to sorted values.
 typedef struct { mz_uint16 m_key, m_sym_index; } tdefl_sym_freq;
 static tdefl_sym_freq* tdefl_radix_sort_syms(mz_uint num_syms, tdefl_sym_freq* pSyms0, tdefl_sym_freq* pSyms1)
 {
   mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2]; tdefl_sym_freq* pCur_syms = pSyms0, *pNew_syms = pSyms1; MZ_CLEAR_OBJ(hist);
   for (i = 0; i < num_syms; i++) { mz_uint freq = pSyms0[i].m_key; hist[freq & 0xFF]++; hist[256 + ((freq >> 8) & 0xFF)]++; }
   while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) total_passes--;
   for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8)
   {
     const mz_uint32* pHist = &hist[pass << 8];
     mz_uint offsets[256], cur_ofs = 0;
     for (i = 0; i < 256; i++) { offsets[i] = cur_ofs; cur_ofs += pHist[i]; }
     for (i = 0; i < num_syms; i++) pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i];
     { tdefl_sym_freq* t = pCur_syms; pCur_syms = pNew_syms; pNew_syms = t; }
   }
   return pCur_syms;
 }
 
 // tdefl_calculate_minimum_redundancy() originally written by: Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996.
 static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n)
 {
   int root, leaf, next, avbl, used, dpth;
   if (n==0) return; else if (n==1) { A[0].m_key = 1; return; }
   A[0].m_key += A[1].m_key; root = 0; leaf = 2;
   for (next=1; next < n-1; next++)
   {
     if (leaf>=n || A[root].m_key<A[leaf].m_key) { A[next].m_key = A[root].m_key; A[root++].m_key = (mz_uint16)next; } else A[next].m_key = A[leaf++].m_key;
     if (leaf>=n || (root<next && A[root].m_key<A[leaf].m_key)) { A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key); A[root++].m_key = (mz_uint16)next; } else A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key);
   }
   A[n-2].m_key = 0; for (next=n-3; next>=0; next--) A[next].m_key = A[A[next].m_key].m_key+1;
   avbl = 1; used = dpth = 0; root = n-2; next = n-1;
   while (avbl>0)
   {
     while (root>=0 && (int)A[root].m_key==dpth) { used++; root--; }
     while (avbl>used) { A[next--].m_key = (mz_uint16)(dpth); avbl--; }
     avbl = 2*used; dpth++; used = 0;
   }
 }
 
 // Limits canonical Huffman code table's max code size.
 enum { TDEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32 };
 static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
 {
   int i; mz_uint32 total = 0; if (code_list_len <= 1) return;
   for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) pNum_codes[max_code_size] += pNum_codes[i];
   for (i = max_code_size; i > 0; i--) total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i));
   while (total != (1UL << max_code_size))
   {
     pNum_codes[max_code_size]--;
     for (i = max_code_size - 1; i > 0; i--) if (pNum_codes[i]) { pNum_codes[i]--; pNum_codes[i + 1] += 2; break; }
     total--;
   }
 }
 
 static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, int table_len, int code_size_limit, int static_table)
 {
   int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE]; mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1]; MZ_CLEAR_OBJ(num_codes);
   if (static_table)
   {
     for (i = 0; i < table_len; i++) num_codes[d->m_huff_code_sizes[table_num][i]]++;
   }
   else
   {
     tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], *pSyms;
     int num_used_syms = 0;
     const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0];
     for (i = 0; i < table_len; i++) if (pSym_count[i]) { syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i]; syms0[num_used_syms++].m_sym_index = (mz_uint16)i; }
 
     pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1); tdefl_calculate_minimum_redundancy(pSyms, num_used_syms);
 
     for (i = 0; i < num_used_syms; i++) num_codes[pSyms[i].m_key]++;
 
     tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit);
 
     MZ_CLEAR_OBJ(d->m_huff_code_sizes[table_num]); MZ_CLEAR_OBJ(d->m_huff_codes[table_num]);
     for (i = 1, j = num_used_syms; i <= code_size_limit; i++)
       for (l = num_codes[i]; l > 0; l--) d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i);
   }
 
   next_code[1] = 0; for (j = 0, i = 2; i <= code_size_limit; i++) next_code[i] = j = ((j + num_codes[i - 1]) << 1);
 
   for (i = 0; i < table_len; i++)
   {
     mz_uint rev_code = 0, code, code_size; if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) continue;
     code = next_code[code_size]++; for (l = code_size; l > 0; l--, code >>= 1) rev_code = (rev_code << 1) | (code & 1);
     d->m_huff_codes[table_num][i] = (mz_uint16)rev_code;
   }
 }
 
 #define TDEFL_PUT_BITS(b, l) do { \
   mz_uint bits = b; mz_uint len = l; MZ_ASSERT(bits <= ((1U << len) - 1U)); \
   d->m_bit_buffer |= (bits << d->m_bits_in); d->m_bits_in += len; \
   while (d->m_bits_in >= 8) { \
     if (d->m_pOutput_buf < d->m_pOutput_buf_end) \
       *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \
       d->m_bit_buffer >>= 8; \
       d->m_bits_in -= 8; \
   } \
 } MZ_MACRO_END
 
 #define TDEFL_RLE_PREV_CODE_SIZE() { if (rle_repeat_count) { \
   if (rle_repeat_count < 3) { \
     d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \
     while (rle_repeat_count--) packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \
   } else { \
     d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); packed_code_sizes[num_packed_code_sizes++] = 16; packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \
 } rle_repeat_count = 0; } }
 
 #define TDEFL_RLE_ZERO_CODE_SIZE() { if (rle_z_count) { \
   if (rle_z_count < 3) { \
     d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); while (rle_z_count--) packed_code_sizes[num_packed_code_sizes++] = 0; \
   } else if (rle_z_count <= 10) { \
     d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); packed_code_sizes[num_packed_code_sizes++] = 17; packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \
   } else { \
     d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); packed_code_sizes[num_packed_code_sizes++] = 18; packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \
 } rle_z_count = 0; } }
 
 static mz_uint8 s_tdefl_packed_code_size_syms_swizzle[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
 
 static void tdefl_start_dynamic_block(tdefl_compressor *d)
 {
   int num_lit_codes, num_dist_codes, num_bit_lengths; mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index;
   mz_uint8 code_sizes_to_pack[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], packed_code_sizes[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], prev_code_size = 0xFF;
 
   d->m_huff_count[0][256] = 1;
 
   tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE);
   tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE);
 
   for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) if (d->m_huff_code_sizes[0][num_lit_codes - 1]) break;
   for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) if (d->m_huff_code_sizes[1][num_dist_codes - 1]) break;
 
   memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes);
   memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes);
   total_code_sizes_to_pack = num_lit_codes + num_dist_codes; num_packed_code_sizes = 0; rle_z_count = 0; rle_repeat_count = 0;
 
   memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2);
   for (i = 0; i < total_code_sizes_to_pack; i++)
   {
     mz_uint8 code_size = code_sizes_to_pack[i];
     if (!code_size)
     {
       TDEFL_RLE_PREV_CODE_SIZE();
       if (++rle_z_count == 138) { TDEFL_RLE_ZERO_CODE_SIZE(); }
     }
     else
     {
       TDEFL_RLE_ZERO_CODE_SIZE();
       if (code_size != prev_code_size)
       {
         TDEFL_RLE_PREV_CODE_SIZE();
         d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1); packed_code_sizes[num_packed_code_sizes++] = code_size;
       }
       else if (++rle_repeat_count == 6)
       {
         TDEFL_RLE_PREV_CODE_SIZE();
       }
     }
     prev_code_size = code_size;
   }
   if (rle_repeat_count) { TDEFL_RLE_PREV_CODE_SIZE(); } else { TDEFL_RLE_ZERO_CODE_SIZE(); }
 
   tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE);
 
   TDEFL_PUT_BITS(2, 2);
 
   TDEFL_PUT_BITS(num_lit_codes - 257, 5);
   TDEFL_PUT_BITS(num_dist_codes - 1, 5);
 
   for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) break;
   num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1)); TDEFL_PUT_BITS(num_bit_lengths - 4, 4);
   for (i = 0; (int)i < num_bit_lengths; i++) TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3);
 
   for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes; )
   {
     mz_uint code = packed_code_sizes[packed_code_sizes_index++]; MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2);
     TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]);
     if (code >= 16) TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]);
   }
 }
 
 static void tdefl_start_static_block(tdefl_compressor *d)
 {
   mz_uint i;
   mz_uint8 *p = &d->m_huff_code_sizes[0][0];
 
   for (i = 0; i <= 143; ++i) *p++ = 8;
   for ( ; i <= 255; ++i) *p++ = 9;
   for ( ; i <= 279; ++i) *p++ = 7;
   for ( ; i <= 287; ++i) *p++ = 8;
 
   memset(d->m_huff_code_sizes[1], 5, 32);
 
   tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE);
   tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE);
 
   TDEFL_PUT_BITS(1, 2);
 }
 
 static const mz_uint mz_bitmasks[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
 
 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS
 static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
 {
   mz_uint flags;
   mz_uint8 *pLZ_codes;
   mz_uint8 *pOutput_buf = d->m_pOutput_buf;
   mz_uint8 *pLZ_code_buf_end = d->m_pLZ_code_buf;
   mz_uint64 bit_buffer = d->m_bit_buffer;
   mz_uint bits_in = d->m_bits_in;
 
 #define TDEFL_PUT_BITS_FAST(b, l) { bit_buffer |= (((mz_uint64)(b)) << bits_in); bits_in += (l); }
 
   flags = 1;
   for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < pLZ_code_buf_end; flags >>= 1)
   {
     if (flags == 1)
       flags = *pLZ_codes++ | 0x100;
 
     if (flags & 1)
     {
       mz_uint s0, s1, n0, n1, sym, num_extra_bits;
       mz_uint match_len = pLZ_codes[0], match_dist = *(const mz_uint16 *)(pLZ_codes + 1); pLZ_codes += 3;
 
       MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
       TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
       TDEFL_PUT_BITS_FAST(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
 
       // This sequence coaxes MSVC into using cmov's vs. jmp's.
       s0 = s_tdefl_small_dist_sym[match_dist & 511];
       n0 = s_tdefl_small_dist_extra[match_dist & 511];
       s1 = s_tdefl_large_dist_sym[match_dist >> 8];
       n1 = s_tdefl_large_dist_extra[match_dist >> 8];
       sym = (match_dist < 512) ? s0 : s1;
       num_extra_bits = (match_dist < 512) ? n0 : n1;
 
       MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
       TDEFL_PUT_BITS_FAST(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
       TDEFL_PUT_BITS_FAST(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
     }
     else
     {
       mz_uint lit = *pLZ_codes++;
       MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
       TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
 
       if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
       {
         flags >>= 1;
         lit = *pLZ_codes++;
         MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
         TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
 
         if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
         {
           flags >>= 1;
           lit = *pLZ_codes++;
           MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
           TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
         }
       }
     }
 
     if (pOutput_buf >= d->m_pOutput_buf_end)
       return MZ_FALSE;
 
     *(mz_uint64*)pOutput_buf = bit_buffer;
     pOutput_buf += (bits_in >> 3);
     bit_buffer >>= (bits_in & ~7);
     bits_in &= 7;
   }
 
 #undef TDEFL_PUT_BITS_FAST
 
   d->m_pOutput_buf = pOutput_buf;
   d->m_bits_in = 0;
   d->m_bit_buffer = 0;
 
   while (bits_in)
   {
     mz_uint32 n = MZ_MIN(bits_in, 16);
     TDEFL_PUT_BITS((mz_uint)bit_buffer & mz_bitmasks[n], n);
     bit_buffer >>= n;
     bits_in -= n;
   }
 
   TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
 
   return (d->m_pOutput_buf < d->m_pOutput_buf_end);
 }
 #else
 static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
 {
   mz_uint flags;
   mz_uint8 *pLZ_codes;
 
   flags = 1;
   for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1)
   {
     if (flags == 1)
       flags = *pLZ_codes++ | 0x100;
     if (flags & 1)
     {
       mz_uint sym, num_extra_bits;
       mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8)); pLZ_codes += 3;
 
       MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
       TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
       TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
 
       if (match_dist < 512)
       {
         sym = s_tdefl_small_dist_sym[match_dist]; num_extra_bits = s_tdefl_small_dist_extra[match_dist];
       }
       else
       {
         sym = s_tdefl_large_dist_sym[match_dist >> 8]; num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8];
       }
       MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
       TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
       TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
     }
     else
     {
       mz_uint lit = *pLZ_codes++;
       MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
       TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
     }
   }
 
   TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
 
   return (d->m_pOutput_buf < d->m_pOutput_buf_end);
 }
 #endif // MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS
 
 static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block)
 {
   if (static_block)
     tdefl_start_static_block(d);
   else
     tdefl_start_dynamic_block(d);
   return tdefl_compress_lz_codes(d);
 }
 
 static int tdefl_flush_block(tdefl_compressor *d, int flush)
 {
   mz_uint saved_bit_buf, saved_bits_in;
   mz_uint8 *pSaved_output_buf;
   mz_bool comp_block_succeeded = MZ_FALSE;
   int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size;
   mz_uint8 *pOutput_buf_start = ((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) : d->m_output_buf;
 
   d->m_pOutput_buf = pOutput_buf_start;
   d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16;
 
   MZ_ASSERT(!d->m_output_flush_remaining);
   d->m_output_flush_ofs = 0;
   d->m_output_flush_remaining = 0;
 
   *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left);
   d->m_pLZ_code_buf -= (d->m_num_flags_left == 8);
 
   if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index))
   {
     TDEFL_PUT_BITS(0x78, 8); TDEFL_PUT_BITS(0x01, 8);
   }
 
   TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1);
 
   pSaved_output_buf = d->m_pOutput_buf; saved_bit_buf = d->m_bit_buffer; saved_bits_in = d->m_bits_in;
 
   if (!use_raw_block)
     comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48));
 
   // If the block gets expanded, forget the current contents of the output buffer and send a raw block instead.
   if ( ((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) &&
        ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size) )
   {
     mz_uint i; d->m_pOutput_buf = pSaved_output_buf; d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
     TDEFL_PUT_BITS(0, 2);
     if (d->m_bits_in) { TDEFL_PUT_BITS(0, 8 - d->m_bits_in); }
     for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF)
     {
       TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16);
     }
     for (i = 0; i < d->m_total_lz_bytes; ++i)
     {
       TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8);
     }
   }
   // Check for the extremely unlikely (if not impossible) case of the compressed block not fitting into the output buffer when using dynamic codes.
   else if (!comp_block_succeeded)
   {
     d->m_pOutput_buf = pSaved_output_buf; d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
     tdefl_compress_block(d, MZ_TRUE);
   }
 
   if (flush)
   {
     if (flush == TDEFL_FINISH)
     {
       if (d->m_bits_in) { TDEFL_PUT_BITS(0, 8 - d->m_bits_in); }
       if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) { mz_uint i, a = d->m_adler32; for (i = 0; i < 4; i++) { TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); a <<= 8; } }
     }
     else
     {
       mz_uint i, z = 0; TDEFL_PUT_BITS(0, 3); if (d->m_bits_in) { TDEFL_PUT_BITS(0, 8 - d->m_bits_in); } for (i = 2; i; --i, z ^= 0xFFFF) { TDEFL_PUT_BITS(z & 0xFFFF, 16); }
     }
   }
 
   MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end);
 
   memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
   memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
 
   d->m_pLZ_code_buf = d->m_lz_code_buf + 1; d->m_pLZ_flags = d->m_lz_code_buf; d->m_num_flags_left = 8; d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes; d->m_total_lz_bytes = 0; d->m_block_index++;
 
   if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0)
   {
     if (d->m_pPut_buf_func)
     {
       *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
       if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user))
         return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED);
     }
     else if (pOutput_buf_start == d->m_output_buf)
     {
       int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs));
       memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy);
       d->m_out_buf_ofs += bytes_to_copy;
       if ((n -= bytes_to_copy) != 0)
       {
         d->m_output_flush_ofs = bytes_to_copy;
         d->m_output_flush_remaining = n;
       }
     }
     else
     {
       d->m_out_buf_ofs += n;
     }
   }
 
   return d->m_output_flush_remaining;
 }
 
 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
 #define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16*)(p)
 static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
 {
   mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
   mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
   const mz_uint16 *s = (const mz_uint16*)(d->m_dict + pos), *p, *q;
   mz_uint16 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]), s01 = TDEFL_READ_UNALIGNED_WORD(s);
   MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); if (max_match_len <= match_len) return;
   for ( ; ; )
   {
     for ( ; ; )
     {
       if (--num_probes_left == 0) return;
       #define TDEFL_PROBE \
         next_probe_pos = d->m_next[probe_pos]; \
         if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) return; \
         probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \
         if (TDEFL_READ_UNALIGNED_WORD(&d->m_dict[probe_pos + match_len - 1]) == c01) break;
       TDEFL_PROBE; TDEFL_PROBE; TDEFL_PROBE;
     }
     if (!dist) break; q = (const mz_uint16*)(d->m_dict + probe_pos); if (TDEFL_READ_UNALIGNED_WORD(q) != s01) continue; p = s; probe_len = 32;
     do { } while ( (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) &&
                    (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (--probe_len > 0) );
     if (!probe_len)
     {
       *pMatch_dist = dist; *pMatch_len = MZ_MIN(max_match_len, TDEFL_MAX_MATCH_LEN); break;
     }
     else if ((probe_len = ((mz_uint)(p - s) * 2) + (mz_uint)(*(const mz_uint8*)p == *(const mz_uint8*)q)) > match_len)
     {
       *pMatch_dist = dist; if ((*pMatch_len = match_len = MZ_MIN(max_match_len, probe_len)) == max_match_len) break;
       c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]);
     }
   }
 }
 #else
 static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
 {
   mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
   mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
   const mz_uint8 *s = d->m_dict + pos, *p, *q;
   mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1];
   MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); if (max_match_len <= match_len) return;
   for ( ; ; )
   {
     for ( ; ; )
     {
       if (--num_probes_left == 0) return;
       #define TDEFL_PROBE \
         next_probe_pos = d->m_next[probe_pos]; \
         if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) return; \
         probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \
         if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) break;
       TDEFL_PROBE; TDEFL_PROBE; TDEFL_PROBE;
     }
     if (!dist) break; p = s; q = d->m_dict + probe_pos; for (probe_len = 0; probe_len < max_match_len; probe_len++) if (*p++ != *q++) break;
     if (probe_len > match_len)
     {
       *pMatch_dist = dist; if ((*pMatch_len = match_len = probe_len) == max_match_len) return;
       c0 = d->m_dict[pos + match_len]; c1 = d->m_dict[pos + match_len - 1];
     }
   }
 }
 #endif // #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
 
 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
 static mz_bool tdefl_compress_fast(tdefl_compressor *d)
 {
   // Faster, minimally featured LZRW1-style match+parse loop with better register utilization. Intended for applications where raw throughput is valued more highly than ratio.
   mz_uint lookahead_pos = d->m_lookahead_pos, lookahead_size = d->m_lookahead_size, dict_size = d->m_dict_size, total_lz_bytes = d->m_total_lz_bytes, num_flags_left = d->m_num_flags_left;
   mz_uint8 *pLZ_code_buf = d->m_pLZ_code_buf, *pLZ_flags = d->m_pLZ_flags;
   mz_uint cur_pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
 
   while ((d->m_src_buf_left) || ((d->m_flush) && (lookahead_size)))
   {
     const mz_uint TDEFL_COMP_FAST_LOOKAHEAD_SIZE = 4096;
     mz_uint dst_pos = (lookahead_pos + lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
     mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(d->m_src_buf_left, TDEFL_COMP_FAST_LOOKAHEAD_SIZE - lookahead_size);
     d->m_src_buf_left -= num_bytes_to_process;
     lookahead_size += num_bytes_to_process;
 
     while (num_bytes_to_process)
     {
       mz_uint32 n = MZ_MIN(TDEFL_LZ_DICT_SIZE - dst_pos, num_bytes_to_process);
       memcpy(d->m_dict + dst_pos, d->m_pSrc, n);
       if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
         memcpy(d->m_dict + TDEFL_LZ_DICT_SIZE + dst_pos, d->m_pSrc, MZ_MIN(n, (TDEFL_MAX_MATCH_LEN - 1) - dst_pos));
       d->m_pSrc += n;
       dst_pos = (dst_pos + n) & TDEFL_LZ_DICT_SIZE_MASK;
       num_bytes_to_process -= n;
     }
 
     dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - lookahead_size, dict_size);
     if ((!d->m_flush) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE)) break;
 
     while (lookahead_size >= 4)
     {
       mz_uint cur_match_dist, cur_match_len = 1;
       mz_uint8 *pCur_dict = d->m_dict + cur_pos;
       mz_uint first_trigram = (*(const mz_uint32 *)pCur_dict) & 0xFFFFFF;
       mz_uint hash = (first_trigram ^ (first_trigram >> (24 - (TDEFL_LZ_HASH_BITS - 8)))) & TDEFL_LEVEL1_HASH_SIZE_MASK;
       mz_uint probe_pos = d->m_hash[hash];
       d->m_hash[hash] = (mz_uint16)lookahead_pos;
 
       if (((cur_match_dist = (mz_uint16)(lookahead_pos - probe_pos)) <= dict_size) && ((*(const mz_uint32 *)(d->m_dict + (probe_pos &= TDEFL_LZ_DICT_SIZE_MASK)) & 0xFFFFFF) == first_trigram))
       {
         const mz_uint16 *p = (const mz_uint16 *)pCur_dict;
         const mz_uint16 *q = (const mz_uint16 *)(d->m_dict + probe_pos);
         mz_uint32 probe_len = 32;
         do { } while ( (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) &&
           (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (--probe_len > 0) );
         cur_match_len = ((mz_uint)(p - (const mz_uint16 *)pCur_dict) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q);
         if (!probe_len)
           cur_match_len = cur_match_dist ? TDEFL_MAX_MATCH_LEN : 0;
 
         if ((cur_match_len < TDEFL_MIN_MATCH_LEN) || ((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U*1024U)))
         {
           cur_match_len = 1;
           *pLZ_code_buf++ = (mz_uint8)first_trigram;
           *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
           d->m_huff_count[0][(mz_uint8)first_trigram]++;
         }
         else
         {
           mz_uint32 s0, s1;
           cur_match_len = MZ_MIN(cur_match_len, lookahead_size);
 
           MZ_ASSERT((cur_match_len >= TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 1) && (cur_match_dist <= TDEFL_LZ_DICT_SIZE));
 
           cur_match_dist--;
 
           pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN);
           *(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist;
           pLZ_code_buf += 3;
           *pLZ_flags = (mz_uint8)((*pLZ_flags >> 1) | 0x80);
 
           s0 = s_tdefl_small_dist_sym[cur_match_dist & 511];
           s1 = s_tdefl_large_dist_sym[cur_match_dist >> 8];
           d->m_huff_count[1][(cur_match_dist < 512) ? s0 : s1]++;
 
           d->m_huff_count[0][s_tdefl_len_sym[cur_match_len - TDEFL_MIN_MATCH_LEN]]++;
         }
       }
       else
       {
         *pLZ_code_buf++ = (mz_uint8)first_trigram;
         *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
         d->m_huff_count[0][(mz_uint8)first_trigram]++;
       }
 
       if (--num_flags_left == 0) { num_flags_left = 8; pLZ_flags = pLZ_code_buf++; }
 
       total_lz_bytes += cur_match_len;
       lookahead_pos += cur_match_len;
       dict_size = MZ_MIN(dict_size + cur_match_len, TDEFL_LZ_DICT_SIZE);
       cur_pos = (cur_pos + cur_match_len) & TDEFL_LZ_DICT_SIZE_MASK;
       MZ_ASSERT(lookahead_size >= cur_match_len);
       lookahead_size -= cur_match_len;
 
       if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
       {
         int n;
         d->m_lookahead_pos = lookahead_pos; d->m_lookahead_size = lookahead_size; d->m_dict_size = dict_size;
         d->m_total_lz_bytes = total_lz_bytes; d->m_pLZ_code_buf = pLZ_code_buf; d->m_pLZ_flags = pLZ_flags; d->m_num_flags_left = num_flags_left;
         if ((n = tdefl_flush_block(d, 0)) != 0)
           return (n < 0) ? MZ_FALSE : MZ_TRUE;
         total_lz_bytes = d->m_total_lz_bytes; pLZ_code_buf = d->m_pLZ_code_buf; pLZ_flags = d->m_pLZ_flags; num_flags_left = d->m_num_flags_left;
       }
     }
 
     while (lookahead_size)
     {
       mz_uint8 lit = d->m_dict[cur_pos];
 
       total_lz_bytes++;
       *pLZ_code_buf++ = lit;
       *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
       if (--num_flags_left == 0) { num_flags_left = 8; pLZ_flags = pLZ_code_buf++; }
 
       d->m_huff_count[0][lit]++;
 
       lookahead_pos++;
       dict_size = MZ_MIN(dict_size + 1, TDEFL_LZ_DICT_SIZE);
       cur_pos = (cur_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK;
       lookahead_size--;
 
       if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
       {
         int n;
         d->m_lookahead_pos = lookahead_pos; d->m_lookahead_size = lookahead_size; d->m_dict_size = dict_size;
         d->m_total_lz_bytes = total_lz_bytes; d->m_pLZ_code_buf = pLZ_code_buf; d->m_pLZ_flags = pLZ_flags; d->m_num_flags_left = num_flags_left;
         if ((n = tdefl_flush_block(d, 0)) != 0)
           return (n < 0) ? MZ_FALSE : MZ_TRUE;
         total_lz_bytes = d->m_total_lz_bytes; pLZ_code_buf = d->m_pLZ_code_buf; pLZ_flags = d->m_pLZ_flags; num_flags_left = d->m_num_flags_left;
       }
     }
   }
 
   d->m_lookahead_pos = lookahead_pos; d->m_lookahead_size = lookahead_size; d->m_dict_size = dict_size;
   d->m_total_lz_bytes = total_lz_bytes; d->m_pLZ_code_buf = pLZ_code_buf; d->m_pLZ_flags = pLZ_flags; d->m_num_flags_left = num_flags_left;
   return MZ_TRUE;
 }
 #endif // MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
 
 static MZ_FORCEINLINE void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit)
 {
   d->m_total_lz_bytes++;
   *d->m_pLZ_code_buf++ = lit;
   *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); if (--d->m_num_flags_left == 0) { d->m_num_flags_left = 8; d->m_pLZ_flags = d->m_pLZ_code_buf++; }
   d->m_huff_count[0][lit]++;
 }
 
 static MZ_FORCEINLINE void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist)
 {
   mz_uint32 s0, s1;
 
   MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE));
 
   d->m_total_lz_bytes += match_len;
 
   d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN);
 
   match_dist -= 1;
   d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF);
   d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); d->m_pLZ_code_buf += 3;
 
   *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); if (--d->m_num_flags_left == 0) { d->m_num_flags_left = 8; d->m_pLZ_flags = d->m_pLZ_code_buf++; }
 
   s0 = s_tdefl_small_dist_sym[match_dist & 511]; s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127];
   d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++;
 
   if (match_len >= TDEFL_MIN_MATCH_LEN) d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++;
 }
 
 static mz_bool tdefl_compress_normal(tdefl_compressor *d)
 {
   const mz_uint8 *pSrc = d->m_pSrc; size_t src_buf_left = d->m_src_buf_left;
   tdefl_flush flush = d->m_flush;
 
   while ((src_buf_left) || ((flush) && (d->m_lookahead_size)))
   {
     mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos;
     // Update dictionary and hash chains. Keeps the lookahead size equal to TDEFL_MAX_MATCH_LEN.
     if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1))
     {
       mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK, ins_pos = d->m_lookahead_pos + d->m_lookahead_size - 2;
       mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK];
       mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size);
       const mz_uint8 *pSrc_end = pSrc + num_bytes_to_process;
       src_buf_left -= num_bytes_to_process;
       d->m_lookahead_size += num_bytes_to_process;
       while (pSrc != pSrc_end)
       {
         mz_uint8 c = *pSrc++; d->m_dict[dst_pos] = c; if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
         hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
         d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; d->m_hash[hash] = (mz_uint16)(ins_pos);
         dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; ins_pos++;
       }
     }
     else
     {
       while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
       {
         mz_uint8 c = *pSrc++;
         mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
         src_buf_left--;
         d->m_dict[dst_pos] = c;
         if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
           d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
         if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN)
         {
           mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2;
           mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << (TDEFL_LZ_HASH_SHIFT * 2)) ^ (d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
           d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; d->m_hash[hash] = (mz_uint16)(ins_pos);
         }
       }
     }
     d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size);
     if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
       break;
 
     // Simple lazy/greedy parsing state machine.
     len_to_move = 1; cur_match_dist = 0; cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
     if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS))
     {
       if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))
       {
         mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK];
         cur_match_len = 0; while (cur_match_len < d->m_lookahead_size) { if (d->m_dict[cur_pos + cur_match_len] != c) break; cur_match_len++; }
         if (cur_match_len < TDEFL_MIN_MATCH_LEN) cur_match_len = 0; else cur_match_dist = 1;
       }
     }
     else
     {
       tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len);
     }
     if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U*1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5)))
     {
       cur_match_dist = cur_match_len = 0;
     }
     if (d->m_saved_match_len)
     {
       if (cur_match_len > d->m_saved_match_len)
       {
         tdefl_record_literal(d, (mz_uint8)d->m_saved_lit);
         if (cur_match_len >= 128)
         {
           tdefl_record_match(d, cur_match_len, cur_match_dist);
           d->m_saved_match_len = 0; len_to_move = cur_match_len;
         }
         else
         {
           d->m_saved_lit = d->m_dict[cur_pos]; d->m_saved_match_dist = cur_match_dist; d->m_saved_match_len = cur_match_len;
         }
       }
       else
       {
         tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist);
         len_to_move = d->m_saved_match_len - 1; d->m_saved_match_len = 0;
       }
     }
     else if (!cur_match_dist)
       tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]);
     else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128))
     {
       tdefl_record_match(d, cur_match_len, cur_match_dist);
       len_to_move = cur_match_len;
     }
     else
     {
       d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]; d->m_saved_match_dist = cur_match_dist; d->m_saved_match_len = cur_match_len;
     }
     // Move the lookahead forward by len_to_move bytes.
     d->m_lookahead_pos += len_to_move;
     MZ_ASSERT(d->m_lookahead_size >= len_to_move);
     d->m_lookahead_size -= len_to_move;
     d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, TDEFL_LZ_DICT_SIZE);
     // Check if it's time to flush the current LZ codes to the internal output buffer.
     if ( (d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) ||
          ( (d->m_total_lz_bytes > 31*1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) )
     {
       int n;
       d->m_pSrc = pSrc; d->m_src_buf_left = src_buf_left;
       if ((n = tdefl_flush_block(d, 0)) != 0)
         return (n < 0) ? MZ_FALSE : MZ_TRUE;
     }
   }
 
   d->m_pSrc = pSrc; d->m_src_buf_left = src_buf_left;
   return MZ_TRUE;
 }
 
 static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)
 {
   if (d->m_pIn_buf_size)
   {
     *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
   }
 
   if (d->m_pOut_buf_size)
   {
     size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining);
     memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n);
     d->m_output_flush_ofs += (mz_uint)n;
     d->m_output_flush_remaining -= (mz_uint)n;
     d->m_out_buf_ofs += n;
 
     *d->m_pOut_buf_size = d->m_out_buf_ofs;
   }
 
   return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY;
 }
 
 tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush)
 {
   if (!d)
   {
     if (pIn_buf_size) *pIn_buf_size = 0;
     if (pOut_buf_size) *pOut_buf_size = 0;
     return TDEFL_STATUS_BAD_PARAM;
   }
 
   d->m_pIn_buf = pIn_buf; d->m_pIn_buf_size = pIn_buf_size;
   d->m_pOut_buf = pOut_buf; d->m_pOut_buf_size = pOut_buf_size;
   d->m_pSrc = (const mz_uint8 *)(pIn_buf); d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0;
   d->m_out_buf_ofs = 0;
   d->m_flush = flush;
 
   if ( ((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) ||
         (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf) )
   {
     if (pIn_buf_size) *pIn_buf_size = 0;
     if (pOut_buf_size) *pOut_buf_size = 0;
     return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM);
   }
   d->m_wants_to_finish |= (flush == TDEFL_FINISH);
 
   if ((d->m_output_flush_remaining) || (d->m_finished))
     return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
 
 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
   if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) &&
       ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) &&
       ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0))
   {
     if (!tdefl_compress_fast(d))
       return d->m_prev_return_status;
   }
   else
 #endif // #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
   {
     if (!tdefl_compress_normal(d))
       return d->m_prev_return_status;
   }
 
   if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf))
     d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf);
 
   if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining))
   {
     if (tdefl_flush_block(d, flush) < 0)
       return d->m_prev_return_status;
     d->m_finished = (flush == TDEFL_FINISH);
     if (flush == TDEFL_FULL_FLUSH) { MZ_CLEAR_OBJ(d->m_hash); MZ_CLEAR_OBJ(d->m_next); d->m_dict_size = 0; }
   }
 
   return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
 }
 
 tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)
 {
   MZ_ASSERT(d->m_pPut_buf_func); return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush);
 }
 
 tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
 {
   d->m_pPut_buf_func = pPut_buf_func; d->m_pPut_buf_user = pPut_buf_user;
   d->m_flags = (mz_uint)(flags); d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0;
   d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3;
   if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) MZ_CLEAR_OBJ(d->m_hash);
   d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0;
   d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0;
   d->m_pLZ_code_buf = d->m_lz_code_buf + 1; d->m_pLZ_flags = d->m_lz_code_buf; d->m_num_flags_left = 8;
   d->m_pOutput_buf = d->m_output_buf; d->m_pOutput_buf_end = d->m_output_buf; d->m_prev_return_status = TDEFL_STATUS_OKAY;
   d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; d->m_adler32 = 1;
   d->m_pIn_buf = NULL; d->m_pOut_buf = NULL;
   d->m_pIn_buf_size = NULL; d->m_pOut_buf_size = NULL;
   d->m_flush = TDEFL_NO_FLUSH; d->m_pSrc = NULL; d->m_src_buf_left = 0; d->m_out_buf_ofs = 0;
   memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
   memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
   return TDEFL_STATUS_OKAY;
 }
 
 tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d)
 {
   return d->m_prev_return_status;
 }
 
 mz_uint32 tdefl_get_adler32(tdefl_compressor *d)
 {
   return d->m_adler32;
 }
 
 mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
 {
   tdefl_compressor *pComp; mz_bool succeeded; if (((buf_len) && (!pBuf)) || (!pPut_buf_func)) return MZ_FALSE;
   pComp = (tdefl_compressor*)MZ_MALLOC(sizeof(tdefl_compressor)); if (!pComp) return MZ_FALSE;
   succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
   succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
   MZ_FREE(pComp); return succeeded;
 }
 
 typedef struct
 {
   size_t m_size, m_capacity;
   mz_uint8 *m_pBuf;
   mz_bool m_expandable;
 } tdefl_output_buffer;
 
 static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
 {
   tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
   size_t new_size = p->m_size + len;
   if (new_size > p->m_capacity)
   {
     size_t new_capacity = p->m_capacity; mz_uint8 *pNew_buf; if (!p->m_expandable) return MZ_FALSE;
     do { new_capacity = MZ_MAX(128U, new_capacity << 1U); } while (new_size > new_capacity);
     pNew_buf = (mz_uint8*)MZ_REALLOC(p->m_pBuf, new_capacity); if (!pNew_buf) return MZ_FALSE;
     p->m_pBuf = pNew_buf; p->m_capacity = new_capacity;
   }
   memcpy((mz_uint8*)p->m_pBuf + p->m_size, pBuf, len); p->m_size = new_size;
   return MZ_TRUE;
 }
 
 void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
 {
   tdefl_output_buffer out_buf; MZ_CLEAR_OBJ(out_buf);
   if (!pOut_len) return MZ_FALSE; else *pOut_len = 0;
   out_buf.m_expandable = MZ_TRUE;
   if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) return NULL;
   *pOut_len = out_buf.m_size; return out_buf.m_pBuf;
 }
 
 size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
 {
   tdefl_output_buffer out_buf; MZ_CLEAR_OBJ(out_buf);
   if (!pOut_buf) return 0;
   out_buf.m_pBuf = (mz_uint8*)pOut_buf; out_buf.m_capacity = out_buf_len;
   if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) return 0;
   return out_buf.m_size;
 }
 
 #ifndef MINIZ_NO_ZLIB_APIS
 static const mz_uint s_tdefl_num_probes[11] = { 0, 1, 6, 32,  16, 32, 128, 256,  512, 768, 1500 };
 
 // level may actually range from [0,10] (10 is a "hidden" max level, where we want a bit more compression and it's fine if throughput to fall off a cliff on some files).
 mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)
 {
   mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
   if (window_bits > 0) comp_flags |= TDEFL_WRITE_ZLIB_HEADER;
 
   if (!level) comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
   else if (strategy == MZ_FILTERED) comp_flags |= TDEFL_FILTER_MATCHES;
   else if (strategy == MZ_HUFFMAN_ONLY) comp_flags &= ~TDEFL_MAX_PROBES_MASK;
   else if (strategy == MZ_FIXED) comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS;
   else if (strategy == MZ_RLE) comp_flags |= TDEFL_RLE_MATCHES;
 
   return comp_flags;
 }
 #endif //MINIZ_NO_ZLIB_APIS
 
 #ifdef _MSC_VER
 #pragma warning (push)
 #pragma warning (disable:4204) // nonstandard extension used : non-constant aggregate initializer (also supported by GNU C and C99, so no big deal)
 #endif
 
-// Simple PNG writer function by Alex Evans, 2011. Released into the public domain: https://gist.github.com/908299, more context at
-// http://altdevblogaday.org/2011/04/06/a-smaller-jpg-encoder/.
+// Simple PNG writer function by Alex Evans, 2011. Released into the public domain: https://gist.github.com/908299
 // This is actually a modification of Alex's original code so PNG files generated by this function pass pngcheck.
 void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip)
 {
   // Using a local copy of this array here in case MINIZ_NO_ZLIB_APIS was defined.
   static const mz_uint s_tdefl_png_num_probes[11] = { 0, 1, 6, 32,  16, 32, 128, 256,  512, 768, 1500 };
   tdefl_compressor *pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor)); tdefl_output_buffer out_buf; int i, bpl = w * num_chans, y, z; mz_uint32 c; *pLen_out = 0;
   if (!pComp) return NULL;
   MZ_CLEAR_OBJ(out_buf); out_buf.m_expandable = MZ_TRUE; out_buf.m_capacity = 57+MZ_MAX(64, (1+bpl)*h); if (NULL == (out_buf.m_pBuf = (mz_uint8*)MZ_MALLOC(out_buf.m_capacity))) { MZ_FREE(pComp); return NULL; }
   // write dummy header
   for (z = 41; z; --z) tdefl_output_buffer_putter(&z, 1, &out_buf);
   // compress image data
   tdefl_init(pComp, tdefl_output_buffer_putter, &out_buf, s_tdefl_png_num_probes[MZ_MIN(10, level)] | TDEFL_WRITE_ZLIB_HEADER);
   for (y = 0; y < h; ++y) { tdefl_compress_buffer(pComp, &z, 1, TDEFL_NO_FLUSH); tdefl_compress_buffer(pComp, (mz_uint8*)pImage + (flip ? (h - 1 - y) : y) * bpl, bpl, TDEFL_NO_FLUSH); }
   if (tdefl_compress_buffer(pComp, NULL, 0, TDEFL_FINISH) != TDEFL_STATUS_DONE) { MZ_FREE(pComp); MZ_FREE(out_buf.m_pBuf); return NULL; }
   // write real header
   *pLen_out = out_buf.m_size-41;
   {
     static const mz_uint8 chans[] = {0x00, 0x00, 0x04, 0x02, 0x06};
     mz_uint8 pnghdr[41]={0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
       0,0,(mz_uint8)(w>>8),(mz_uint8)w,0,0,(mz_uint8)(h>>8),(mz_uint8)h,8,chans[num_chans],0,0,0,0,0,0,0,
       (mz_uint8)(*pLen_out>>24),(mz_uint8)(*pLen_out>>16),(mz_uint8)(*pLen_out>>8),(mz_uint8)*pLen_out,0x49,0x44,0x41,0x54};
     c=(mz_uint32)mz_crc32(MZ_CRC32_INIT,pnghdr+12,17); for (i=0; i<4; ++i, c<<=8) ((mz_uint8*)(pnghdr+29))[i]=(mz_uint8)(c>>24);
     memcpy(out_buf.m_pBuf, pnghdr, 41);
   }
   // write footer (IDAT CRC-32, followed by IEND chunk)
   if (!tdefl_output_buffer_putter("\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16, &out_buf)) { *pLen_out = 0; MZ_FREE(pComp); MZ_FREE(out_buf.m_pBuf); return NULL; }
   c = (mz_uint32)mz_crc32(MZ_CRC32_INIT,out_buf.m_pBuf+41-4, *pLen_out+4); for (i=0; i<4; ++i, c<<=8) (out_buf.m_pBuf+out_buf.m_size-16)[i] = (mz_uint8)(c >> 24);
   // compute final size of file, grab compressed data buffer and return
   *pLen_out += 57; MZ_FREE(pComp); return out_buf.m_pBuf;
 }
 void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out)
 {
   // Level 6 corresponds to TDEFL_DEFAULT_MAX_PROBES or MZ_DEFAULT_LEVEL (but we can't depend on MZ_DEFAULT_LEVEL being available in case the zlib API's where #defined out)
   return tdefl_write_image_to_png_file_in_memory_ex(pImage, w, h, num_chans, pLen_out, 6, MZ_FALSE);
 }
 
 #ifdef _MSC_VER
 #pragma warning (pop)
 #endif
 
 // ------------------- .ZIP archive reading
 
 #ifndef MINIZ_NO_ARCHIVE_APIS
 
 #ifdef MINIZ_NO_STDIO
   #define MZ_FILE void *
 #else
   #include <stdio.h>
   #include <sys/stat.h>
 
   #if defined(_MSC_VER) || defined(__MINGW64__)
     static FILE *mz_fopen(const char *pFilename, const char *pMode)
     {
       FILE* pFile = NULL;
       fopen_s(&pFile, pFilename, pMode);
       return pFile;
     }
     static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream)
     {
       FILE* pFile = NULL;
       if (freopen_s(&pFile, pPath, pMode, pStream))
         return NULL;
       return pFile;
     }
     #ifndef MINIZ_NO_TIME
       #include <sys/utime.h>
     #endif
     #define MZ_FILE FILE
     #define MZ_FOPEN mz_fopen
     #define MZ_FCLOSE fclose
     #define MZ_FREAD fread
     #define MZ_FWRITE fwrite
     #define MZ_FTELL64 _ftelli64
     #define MZ_FSEEK64 _fseeki64
     #define MZ_FILE_STAT_STRUCT _stat
     #define MZ_FILE_STAT _stat
     #define MZ_FFLUSH fflush
     #define MZ_FREOPEN mz_freopen
     #define MZ_DELETE_FILE remove
   #elif defined(__MINGW32__)
     #ifndef MINIZ_NO_TIME
       #include <sys/utime.h>
     #endif
     #define MZ_FILE FILE
     #define MZ_FOPEN(f, m) fopen(f, m)
     #define MZ_FCLOSE fclose
     #define MZ_FREAD fread
     #define MZ_FWRITE fwrite
     #define MZ_FTELL64 ftello64
     #define MZ_FSEEK64 fseeko64
     #define MZ_FILE_STAT_STRUCT _stat
     #define MZ_FILE_STAT _stat
     #define MZ_FFLUSH fflush
     #define MZ_FREOPEN(f, m, s) freopen(f, m, s)
     #define MZ_DELETE_FILE remove
   #elif defined(__TINYC__)
     #ifndef MINIZ_NO_TIME
       #include <sys/utime.h>
     #endif
     #define MZ_FILE FILE
     #define MZ_FOPEN(f, m) fopen(f, m)
     #define MZ_FCLOSE fclose
     #define MZ_FREAD fread
     #define MZ_FWRITE fwrite
     #define MZ_FTELL64 ftell
     #define MZ_FSEEK64 fseek
     #define MZ_FILE_STAT_STRUCT stat
     #define MZ_FILE_STAT stat
     #define MZ_FFLUSH fflush
     #define MZ_FREOPEN(f, m, s) freopen(f, m, s)
     #define MZ_DELETE_FILE remove
   #elif defined(__GNUC__) && _LARGEFILE64_SOURCE
     #ifndef MINIZ_NO_TIME
       #include <utime.h>
     #endif
     #define MZ_FILE FILE
     #define MZ_FOPEN(f, m) fopen64(f, m)
     #define MZ_FCLOSE fclose
     #define MZ_FREAD fread
     #define MZ_FWRITE fwrite
     #define MZ_FTELL64 ftello64
     #define MZ_FSEEK64 fseeko64
     #define MZ_FILE_STAT_STRUCT stat64
     #define MZ_FILE_STAT stat64
     #define MZ_FFLUSH fflush
     #define MZ_FREOPEN(p, m, s) freopen64(p, m, s)
     #define MZ_DELETE_FILE remove
   #else
     #ifndef MINIZ_NO_TIME
       #include <utime.h>
     #endif
     #define MZ_FILE FILE
     #define MZ_FOPEN(f, m) fopen(f, m)
     #define MZ_FCLOSE fclose
     #define MZ_FREAD fread
     #define MZ_FWRITE fwrite
     #define MZ_FTELL64 ftello
     #define MZ_FSEEK64 fseeko
     #define MZ_FILE_STAT_STRUCT stat
     #define MZ_FILE_STAT stat
     #define MZ_FFLUSH fflush
     #define MZ_FREOPEN(f, m, s) freopen(f, m, s)
     #define MZ_DELETE_FILE remove
   #endif // #ifdef _MSC_VER
 #endif // #ifdef MINIZ_NO_STDIO
 
 #define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))
 
 // Various ZIP archive enums. To completely avoid cross platform compiler alignment and platform endian issues, miniz.c doesn't use structs for any of this stuff.
 enum
 {
   // ZIP archive identifiers and record sizes
   MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06054b50, MZ_ZIP_CENTRAL_DIR_HEADER_SIG = 0x02014b50, MZ_ZIP_LOCAL_DIR_HEADER_SIG = 0x04034b50,
   MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22,
   // Central directory header record offsets
   MZ_ZIP_CDH_SIG_OFS = 0, MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4, MZ_ZIP_CDH_VERSION_NEEDED_OFS = 6, MZ_ZIP_CDH_BIT_FLAG_OFS = 8,
   MZ_ZIP_CDH_METHOD_OFS = 10, MZ_ZIP_CDH_FILE_TIME_OFS = 12, MZ_ZIP_CDH_FILE_DATE_OFS = 14, MZ_ZIP_CDH_CRC32_OFS = 16,
   MZ_ZIP_CDH_COMPRESSED_SIZE_OFS = 20, MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS = 24, MZ_ZIP_CDH_FILENAME_LEN_OFS = 28, MZ_ZIP_CDH_EXTRA_LEN_OFS = 30,
   MZ_ZIP_CDH_COMMENT_LEN_OFS = 32, MZ_ZIP_CDH_DISK_START_OFS = 34, MZ_ZIP_CDH_INTERNAL_ATTR_OFS = 36, MZ_ZIP_CDH_EXTERNAL_ATTR_OFS = 38, MZ_ZIP_CDH_LOCAL_HEADER_OFS = 42,
   // Local directory header offsets
   MZ_ZIP_LDH_SIG_OFS = 0, MZ_ZIP_LDH_VERSION_NEEDED_OFS = 4, MZ_ZIP_LDH_BIT_FLAG_OFS = 6, MZ_ZIP_LDH_METHOD_OFS = 8, MZ_ZIP_LDH_FILE_TIME_OFS = 10,
   MZ_ZIP_LDH_FILE_DATE_OFS = 12, MZ_ZIP_LDH_CRC32_OFS = 14, MZ_ZIP_LDH_COMPRESSED_SIZE_OFS = 18, MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS = 22,
   MZ_ZIP_LDH_FILENAME_LEN_OFS = 26, MZ_ZIP_LDH_EXTRA_LEN_OFS = 28,
   // End of central directory offsets
   MZ_ZIP_ECDH_SIG_OFS = 0, MZ_ZIP_ECDH_NUM_THIS_DISK_OFS = 4, MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS = 6, MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 8,
   MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS = 10, MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12, MZ_ZIP_ECDH_CDIR_OFS_OFS = 16, MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20,
 };
 
 typedef struct
 {
   void *m_p;
   size_t m_size, m_capacity;
   mz_uint m_element_size;
 } mz_zip_array;
 
 struct mz_zip_internal_state_tag
 {
   mz_zip_array m_central_dir;
   mz_zip_array m_central_dir_offsets;
   mz_zip_array m_sorted_central_dir_offsets;
   MZ_FILE *m_pFile;
   void *m_pMem;
   size_t m_mem_size;
   size_t m_mem_capacity;
 };
 
 #define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size) (array_ptr)->m_element_size = element_size
 #define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[index]
 
 static MZ_FORCEINLINE void mz_zip_array_clear(mz_zip_archive *pZip, mz_zip_array *pArray)
 {
   pZip->m_pFree(pZip->m_pAlloc_opaque, pArray->m_p);
   memset(pArray, 0, sizeof(mz_zip_array));
 }
 
 static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)
 {
   void *pNew_p; size_t new_capacity = min_new_capacity; MZ_ASSERT(pArray->m_element_size); if (pArray->m_capacity >= min_new_capacity) return MZ_TRUE;
   if (growing) { new_capacity = MZ_MAX(1, pArray->m_capacity); while (new_capacity < min_new_capacity) new_capacity *= 2; }
   if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, pArray->m_element_size, new_capacity))) return MZ_FALSE;
   pArray->m_p = pNew_p; pArray->m_capacity = new_capacity;
   return MZ_TRUE;
 }
 
 static MZ_FORCEINLINE mz_bool mz_zip_array_reserve(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_capacity, mz_uint growing)
 {
   if (new_capacity > pArray->m_capacity) { if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing)) return MZ_FALSE; }
   return MZ_TRUE;
 }
 
 static MZ_FORCEINLINE mz_bool mz_zip_array_resize(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing)
 {
   if (new_size > pArray->m_capacity) { if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) return MZ_FALSE; }
   pArray->m_size = new_size;
   return MZ_TRUE;
 }
 
 static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, mz_zip_array *pArray, size_t n)
 {
   return mz_zip_array_reserve(pZip, pArray, pArray->m_size + n, MZ_TRUE);
 }
 
 static MZ_FORCEINLINE mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n)
 {
   size_t orig_size = pArray->m_size; if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) return MZ_FALSE;
   memcpy((mz_uint8*)pArray->m_p + orig_size * pArray->m_element_size, pElements, n * pArray->m_element_size);
   return MZ_TRUE;
 }
 
 #ifndef MINIZ_NO_TIME
 static time_t mz_zip_dos_to_time_t(int dos_time, int dos_date)
 {
   struct tm tm;
   memset(&tm, 0, sizeof(tm)); tm.tm_isdst = -1;
   tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900; tm.tm_mon = ((dos_date >> 5) & 15) - 1; tm.tm_mday = dos_date & 31;
   tm.tm_hour = (dos_time >> 11) & 31; tm.tm_min = (dos_time >> 5) & 63; tm.tm_sec = (dos_time << 1) & 62;
   return mktime(&tm);
 }
 
 static void mz_zip_time_to_dos_time(time_t time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)
 {
 #ifdef _MSC_VER
   struct tm tm_struct;
   struct tm *tm = &tm_struct;
   errno_t err = localtime_s(tm, &time);
   if (err)
   {
     *pDOS_date = 0; *pDOS_time = 0;
     return;
   }
 #else
   struct tm *tm = localtime(&time);
 #endif
   *pDOS_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + ((tm->tm_sec) >> 1));
   *pDOS_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday);
 }
 #endif
 
 #ifndef MINIZ_NO_STDIO
 static mz_bool mz_zip_get_file_modified_time(const char *pFilename, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)
 {
 #ifdef MINIZ_NO_TIME
   (void)pFilename; *pDOS_date = *pDOS_time = 0;
 #else
   struct MZ_FILE_STAT_STRUCT file_stat;
   // On Linux with x86 glibc, this call will fail on large files (>= 0x80000000 bytes) unless you compiled with _LARGEFILE64_SOURCE. Argh.
   if (MZ_FILE_STAT(pFilename, &file_stat) != 0)
     return MZ_FALSE;
   mz_zip_time_to_dos_time(file_stat.st_mtime, pDOS_time, pDOS_date);
 #endif // #ifdef MINIZ_NO_TIME
   return MZ_TRUE;
 }
 
 #ifndef MINIZ_NO_TIME
 static mz_bool mz_zip_set_file_times(const char *pFilename, time_t access_time, time_t modified_time)
 {
   struct utimbuf t; t.actime = access_time; t.modtime = modified_time;
   return !utime(pFilename, &t);
 }
 #endif // #ifndef MINIZ_NO_TIME
 #endif // #ifndef MINIZ_NO_STDIO
 
 static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint32 flags)
 {
   (void)flags;
   if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
     return MZ_FALSE;
 
   if (!pZip->m_pAlloc) pZip->m_pAlloc = def_alloc_func;
   if (!pZip->m_pFree) pZip->m_pFree = def_free_func;
   if (!pZip->m_pRealloc) pZip->m_pRealloc = def_realloc_func;
 
   pZip->m_zip_mode = MZ_ZIP_MODE_READING;
   pZip->m_archive_size = 0;
   pZip->m_central_directory_file_ofs = 0;
   pZip->m_total_files = 0;
 
   if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
     return MZ_FALSE;
   memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
   MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
   MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
   MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
   return MZ_TRUE;
 }
 
 static MZ_FORCEINLINE mz_bool mz_zip_reader_filename_less(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, mz_uint r_index)
 {
   const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, l_index)), *pE;
   const mz_uint8 *pR = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, r_index));
   mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS), r_len = MZ_READ_LE16(pR + MZ_ZIP_CDH_FILENAME_LEN_OFS);
   mz_uint8 l = 0, r = 0;
   pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; pR += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
   pE = pL + MZ_MIN(l_len, r_len);
   while (pL < pE)
   {
     if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
       break;
     pL++; pR++;
   }
   return (pL == pE) ? (l_len < r_len) : (l < r);
 }
 
 #define MZ_SWAP_UINT32(a, b) do { mz_uint32 t = a; a = b; b = t; } MZ_MACRO_END
 
 // Heap sort of lowercased filenames, used to help accelerate plain central directory searches by mz_zip_reader_locate_file(). (Could also use qsort(), but it could allocate memory.)
 static void mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip)
 {
   mz_zip_internal_state *pState = pZip->m_pState;
   const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;
   const mz_zip_array *pCentral_dir = &pState->m_central_dir;
   mz_uint32 *pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0);
   const int size = pZip->m_total_files;
   int start = (size - 2) >> 1, end;
   while (start >= 0)
   {
     int child, root = start;
     for ( ; ; )
     {
       if ((child = (root << 1) + 1) >= size)
         break;
       child += (((child + 1) < size) && (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1])));
       if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))
         break;
       MZ_SWAP_UINT32(pIndices[root], pIndices[child]); root = child;
     }
     start--;
   }
 
   end = size - 1;
   while (end > 0)
   {
     int child, root = 0;
     MZ_SWAP_UINT32(pIndices[end], pIndices[0]);
     for ( ; ; )
     {
       if ((child = (root << 1) + 1) >= end)
         break;
       child += (((child + 1) < end) && mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1]));
       if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))
         break;
       MZ_SWAP_UINT32(pIndices[root], pIndices[child]); root = child;
     }
     end--;
   }
 }
 
 static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint32 flags)
 {
   mz_uint cdir_size, num_this_disk, cdir_disk_index;
   mz_uint64 cdir_ofs;
   mz_int64 cur_file_ofs;
   const mz_uint8 *p;
   mz_uint32 buf_u32[4096 / sizeof(mz_uint32)]; mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
   mz_bool sort_central_dir = ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);
   mz_bool zip_signature_found = 0;
   // Basic sanity checks - reject files which are too small, and check the first 4 bytes of the file to make sure a local header is there.
   if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
     return MZ_FALSE;
   // Find the end of central directory record by scanning the file from the end towards the beginning.
   cur_file_ofs = MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0);
   for ( ; ; )
   {
     int i, n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs);
     if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n)
       return MZ_FALSE;
     for (i = n - 4; i >= 0; --i)
     {
       if (MZ_READ_LE32(pBuf + i) == MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)
       {
         // Read and verify the end of central directory record.
         if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs + i, pBuf, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
           continue;
         if ((MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) ||
         ((pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS)) != MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS)))
           continue;
         zip_signature_found = 1;
         break;
       }
     }
 
     if (zip_signature_found)
     {
       cur_file_ofs += i;
       break;
     }
     if ((!cur_file_ofs) || (cur_file_ofs < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE))
       return MZ_FALSE;
 
     cur_file_ofs = MZ_MAX(cur_file_ofs - (mz_int64)(sizeof(buf_u32) - 3), 0);
   }
 
   num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS);
   cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS);
   if (((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1)))
     return MZ_FALSE;
 
   if ((cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS)) < pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)
     return MZ_FALSE;
 
   cdir_ofs = cur_file_ofs - cdir_size;
   if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size)
     return MZ_FALSE;
 
   pZip->m_central_directory_file_ofs = cdir_ofs;
 
   pZip->m_archive_file_ofs = cdir_ofs - MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);
   if (pZip->m_archive_file_ofs > pZip->m_archive_size)
     return MZ_FALSE;
 
   if (pZip->m_total_files)
   {
      mz_uint i, n;
 
     // Read the entire central directory into a heap block, and allocate another heap block to hold the unsorted central dir file record offsets, and another to hold the sorted indices.
     if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, MZ_FALSE)) ||
         (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, pZip->m_total_files, MZ_FALSE)))
       return MZ_FALSE;
 
     if (sort_central_dir)
     {
       if (!mz_zip_array_resize(pZip, &pZip->m_pState->m_sorted_central_dir_offsets, pZip->m_total_files, MZ_FALSE))
         return MZ_FALSE;
     }
 
     if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, pZip->m_pState->m_central_dir.m_p, cdir_size) != cdir_size)
       return MZ_FALSE;
 
     // Now create an index into the central directory file records, do some basic sanity checking on each record, and check for zip64 entries (which are not yet supported).
     p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p;
     for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i)
     {
       mz_uint total_header_size, comp_size, decomp_size, disk_index;
       if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG))
         return MZ_FALSE;
       MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, i) = (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p);
       if (sort_central_dir)
         MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets, mz_uint32, i) = i;
       comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
       decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
       if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size) || (decomp_size == 0xFFFFFFFF) || (comp_size == 0xFFFFFFFF))
         return MZ_FALSE;
       disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS);
       if ((disk_index != num_this_disk) && (disk_index != 1))
         return MZ_FALSE;
       if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)
         return MZ_FALSE;
       if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) > n)
         return MZ_FALSE;
       n -= total_header_size; p += total_header_size;
     }
   }
 
   if (sort_central_dir)
     mz_zip_reader_sort_central_dir_offsets_by_filename(pZip);
 
   return MZ_TRUE;
 }
 
 mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint32 flags)
 {
   if ((!pZip) || (!pZip->m_pRead))
     return MZ_FALSE;
   if (!mz_zip_reader_init_internal(pZip, flags))
     return MZ_FALSE;
   pZip->m_archive_size = size;
   if (!mz_zip_reader_read_central_dir(pZip, flags))
   {
     mz_zip_reader_end(pZip);
     return MZ_FALSE;
   }
   return MZ_TRUE;
 }
 
 static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
 {
   mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
   size_t s = (file_ofs >= pZip->m_archive_size) ? 0 : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
   memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);
   return s;
 }
 
 mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint32 flags)
 {
   if (!mz_zip_reader_init_internal(pZip, flags))
     return MZ_FALSE;
   pZip->m_archive_size = size;
   pZip->m_pRead = mz_zip_mem_read_func;
   pZip->m_pIO_opaque = pZip;
 #ifdef __cplusplus
   pZip->m_pState->m_pMem = const_cast<void *>(pMem);
 #else
   pZip->m_pState->m_pMem = (void *)pMem;
 #endif
   pZip->m_pState->m_mem_size = size;
   if (!mz_zip_reader_read_central_dir(pZip, flags))
   {
     mz_zip_reader_end(pZip);
     return MZ_FALSE;
   }
   return MZ_TRUE;
 }
 
 #ifndef MINIZ_NO_STDIO
 static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
 {
   mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
   mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
   if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))
     return 0;
   return MZ_FREAD(pBuf, 1, n, pZip->m_pState->m_pFile);
 }
 
 mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags)
 {
   mz_uint64 file_size;
   MZ_FILE *pFile = MZ_FOPEN(pFilename, "rb");
   if (!pFile)
     return MZ_FALSE;
   if (MZ_FSEEK64(pFile, 0, SEEK_END))
   {
     MZ_FCLOSE(pFile);
     return MZ_FALSE;
   }
   file_size = MZ_FTELL64(pFile);
   if (!mz_zip_reader_init_internal(pZip, flags))
   {
     MZ_FCLOSE(pFile);
     return MZ_FALSE;
   }
   pZip->m_pRead = mz_zip_file_read_func;
   pZip->m_pIO_opaque = pZip;
   pZip->m_pState->m_pFile = pFile;
   pZip->m_archive_size = file_size;
   if (!mz_zip_reader_read_central_dir(pZip, flags))
   {
     mz_zip_reader_end(pZip);
     return MZ_FALSE;
   }
   return MZ_TRUE;
 }
 #endif // #ifndef MINIZ_NO_STDIO
 
 mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip)
 {
   return pZip ? pZip->m_total_files : 0;
 }
 
 static MZ_FORCEINLINE const mz_uint8 *mz_zip_reader_get_cdh(mz_zip_archive *pZip, mz_uint file_index)
 {
   if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
     return NULL;
   return &MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index));
 }
 
 mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index)
 {
   mz_uint m_bit_flag;
   const mz_uint8 *p = mz_zip_reader_get_cdh(pZip, file_index);
   if (!p)
     return MZ_FALSE;
   m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
   return (m_bit_flag & 1);
 }
 
 mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index)
 {
   mz_uint filename_len, external_attr;
   const mz_uint8 *p = mz_zip_reader_get_cdh(pZip, file_index);
   if (!p)
     return MZ_FALSE;
 
   // First see if the filename ends with a '/' character.
   filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
   if (filename_len)
   {
     if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/')
       return MZ_TRUE;
   }
 
   // Bugfix: This code was also checking if the internal attribute was non-zero, which wasn't correct.
   // Most/all zip writers (hopefully) set DOS file/directory attributes in the low 16-bits, so check for the DOS directory flag and ignore the source OS ID in the created by field.
   // FIXME: Remove this check? Is it necessary - we already check the filename.
   external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
   if ((external_attr & 0x10) != 0)
     return MZ_TRUE;
 
   return MZ_FALSE;
 }
 
 mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat)
 {
   mz_uint n;
   const mz_uint8 *p = mz_zip_reader_get_cdh(pZip, file_index);
   if ((!p) || (!pStat))
     return MZ_FALSE;
 
   // Unpack the central directory record.
   pStat->m_file_index = file_index;
   pStat->m_central_dir_ofs = MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index);
   pStat->m_version_made_by = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS);
   pStat->m_version_needed = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_NEEDED_OFS);
   pStat->m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
   pStat->m_method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
 #ifndef MINIZ_NO_TIME
   pStat->m_time = mz_zip_dos_to_time_t(MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_TIME_OFS), MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_DATE_OFS));
 #endif
   pStat->m_crc32 = MZ_READ_LE32(p + MZ_ZIP_CDH_CRC32_OFS);
   pStat->m_comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
   pStat->m_uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
   pStat->m_internal_attr = MZ_READ_LE16(p + MZ_ZIP_CDH_INTERNAL_ATTR_OFS);
   pStat->m_external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
   pStat->m_local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
 
   // Copy as much of the filename and comment as possible.
   n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE - 1);
   memcpy(pStat->m_filename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n); pStat->m_filename[n] = '\0';
 
   n = MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS); n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE - 1);
   pStat->m_comment_size = n;
   memcpy(pStat->m_comment, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS), n); pStat->m_comment[n] = '\0';
 
   return MZ_TRUE;
 }
 
 mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size)
 {
   mz_uint n;
   const mz_uint8 *p = mz_zip_reader_get_cdh(pZip, file_index);
   if (!p) { if (filename_buf_size) pFilename[0] = '\0'; return 0; }
   n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
   if (filename_buf_size)
   {
     n = MZ_MIN(n, filename_buf_size - 1);
     memcpy(pFilename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
     pFilename[n] = '\0';
   }
   return n + 1;
 }
 
 static MZ_FORCEINLINE mz_bool mz_zip_reader_string_equal(const char *pA, const char *pB, mz_uint len, mz_uint flags)
 {
   mz_uint i;
   if (flags & MZ_ZIP_FLAG_CASE_SENSITIVE)
     return 0 == memcmp(pA, pB, len);
   for (i = 0; i < len; ++i)
     if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i]))
       return MZ_FALSE;
   return MZ_TRUE;
 }
 
 static MZ_FORCEINLINE int mz_zip_reader_filename_compare(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, const char *pR, mz_uint r_len)
 {
   const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, l_index)), *pE;
   mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS);
   mz_uint8 l = 0, r = 0;
   pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
   pE = pL + MZ_MIN(l_len, r_len);
   while (pL < pE)
   {
     if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
       break;
     pL++; pR++;
   }
   return (pL == pE) ? (int)(l_len - r_len) : (l - r);
 }
 
 static int mz_zip_reader_locate_file_binary_search(mz_zip_archive *pZip, const char *pFilename)
 {
   mz_zip_internal_state *pState = pZip->m_pState;
   const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;
   const mz_zip_array *pCentral_dir = &pState->m_central_dir;
   mz_uint32 *pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0);
   const int size = pZip->m_total_files;
   const mz_uint filename_len = (mz_uint)strlen(pFilename);
   int l = 0, h = size - 1;
   while (l <= h)
   {
     int m = (l + h) >> 1, file_index = pIndices[m], comp = mz_zip_reader_filename_compare(pCentral_dir, pCentral_dir_offsets, file_index, pFilename, filename_len);
     if (!comp)
       return file_index;
     else if (comp < 0)
       l = m + 1;
     else
       h = m - 1;
   }
   return -1;
 }
 
 int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags)
 {
   mz_uint file_index; size_t name_len, comment_len;
   if ((!pZip) || (!pZip->m_pState) || (!pName) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
     return -1;
   if (((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size))
     return mz_zip_reader_locate_file_binary_search(pZip, pName);
   name_len = strlen(pName); if (name_len > 0xFFFF) return -1;
   comment_len = pComment ? strlen(pComment) : 0; if (comment_len > 0xFFFF) return -1;
   for (file_index = 0; file_index < pZip->m_total_files; file_index++)
   {
     const mz_uint8 *pHeader = &MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index));
     mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
     const char *pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
     if (filename_len < name_len)
       continue;
     if (comment_len)
     {
       mz_uint file_extra_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_EXTRA_LEN_OFS), file_comment_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_COMMENT_LEN_OFS);
       const char *pFile_comment = pFilename + filename_len + file_extra_len;
       if ((file_comment_len != comment_len) || (!mz_zip_reader_string_equal(pComment, pFile_comment, file_comment_len, flags)))
         continue;
     }
     if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len))
     {
       int ofs = filename_len - 1;
       do
       {
         if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':'))
           break;
       } while (--ofs >= 0);
       ofs++;
       pFilename += ofs; filename_len -= ofs;
     }
     if ((filename_len == name_len) && (mz_zip_reader_string_equal(pName, pFilename, filename_len, flags)))
       return file_index;
   }
   return -1;
 }
 
 mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
 {
   int status = TINFL_STATUS_DONE;
   mz_uint64 needed_size, cur_file_ofs, comp_remaining, out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail;
   mz_zip_archive_file_stat file_stat;
   void *pRead_buf;
   mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
   tinfl_decompressor inflator;
 
   if ((buf_size) && (!pBuf))
     return MZ_FALSE;
 
   if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
     return MZ_FALSE;
 
   // Empty file, or a directory (but not always a directory - I've seen odd zips with directories that have compressed data which inflates to 0 bytes)
   if (!file_stat.m_comp_size)
     return MZ_TRUE;
 
   // Entry is a subdirectory (I've seen old zips with dir entries which have compressed deflate data which inflates to 0 bytes, but these entries claim to uncompress to 512 bytes in the headers).
   // I'm torn how to handle this case - should it fail instead?
   if (mz_zip_reader_is_file_a_directory(pZip, file_index))
     return MZ_TRUE;
 
   // Encryption and patch files are not supported.
   if (file_stat.m_bit_flag & (1 | 32))
     return MZ_FALSE;
 
   // This function only supports stored and deflate.
   if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
     return MZ_FALSE;
 
   // Ensure supplied output buffer is large enough.
   needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size;
   if (buf_size < needed_size)
     return MZ_FALSE;
 
   // Read and parse the local directory entry.
   cur_file_ofs = pZip->m_archive_file_ofs + file_stat.m_local_header_ofs;
   if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
     return MZ_FALSE;
   if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
     return MZ_FALSE;
 
   cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
   if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
     return MZ_FALSE;
 
   if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
   {
     // The file is stored or the caller has requested the compressed data.
     if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, (size_t)needed_size) != needed_size)
       return MZ_FALSE;
     return ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) != 0) || (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) == file_stat.m_crc32);
   }
 
   // Decompress the file either directly from memory or from a file input buffer.
   tinfl_init(&inflator);
 
   if (pZip->m_pState->m_pMem)
   {
     // Read directly from the archive in memory.
     pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
     read_buf_size = read_buf_avail = file_stat.m_comp_size;
     comp_remaining = 0;
   }
   else if (pUser_read_buf)
   {
     // Use a user provided read buffer.
     if (!user_read_buf_size)
       return MZ_FALSE;
     pRead_buf = (mz_uint8 *)pUser_read_buf;
     read_buf_size = user_read_buf_size;
     read_buf_avail = 0;
     comp_remaining = file_stat.m_comp_size;
   }
   else
   {
     // Temporarily allocate a read buffer.
     read_buf_size = MZ_MIN(file_stat.m_comp_size, MZ_ZIP_MAX_IO_BUF_SIZE);
 #ifdef _MSC_VER
     if (((0, sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
 #else
     if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
 #endif
       return MZ_FALSE;
     if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
       return MZ_FALSE;
     read_buf_avail = 0;
     comp_remaining = file_stat.m_comp_size;
   }
 
   do
   {
     size_t in_buf_size, out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs);
     if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
     {
       read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
       if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
       {
         status = TINFL_STATUS_FAILED;
         break;
       }
       cur_file_ofs += read_buf_avail;
       comp_remaining -= read_buf_avail;
       read_buf_ofs = 0;
     }
     in_buf_size = (size_t)read_buf_avail;
     status = tinfl_decompress(&inflator, (mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pBuf, (mz_uint8 *)pBuf + out_buf_ofs, &out_buf_size, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF | (comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0));
     read_buf_avail -= in_buf_size;
     read_buf_ofs += in_buf_size;
     out_buf_ofs += out_buf_size;
   } while (status == TINFL_STATUS_NEEDS_MORE_INPUT);
 
   if (status == TINFL_STATUS_DONE)
   {
     // Make sure the entire file was decompressed, and check its CRC.
     if ((out_buf_ofs != file_stat.m_uncomp_size) || (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32))
       status = TINFL_STATUS_FAILED;
   }
 
   if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf))
     pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
 
   return status == TINFL_STATUS_DONE;
 }
 
 mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
 {
   int file_index = mz_zip_reader_locate_file(pZip, pFilename, NULL, flags);
   if (file_index < 0)
     return MZ_FALSE;
   return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size);
 }
 
 mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags)
 {
   return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, flags, NULL, 0);
 }
 
 mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags)
 {
   return mz_zip_reader_extract_file_to_mem_no_alloc(pZip, pFilename, pBuf, buf_size, flags, NULL, 0);
 }
 
 void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)
 {
   mz_uint64 comp_size, uncomp_size, alloc_size;
   const mz_uint8 *p = mz_zip_reader_get_cdh(pZip, file_index);
   void *pBuf;
 
   if (pSize)
     *pSize = 0;
   if (!p)
     return NULL;
 
   comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
   uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
 
   alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? comp_size : uncomp_size;
 #ifdef _MSC_VER
   if (((0, sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
 #else
   if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
 #endif
     return NULL;
   if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size)))
     return NULL;
 
   if (!mz_zip_reader_extract_to_mem(pZip, file_index, pBuf, (size_t)alloc_size, flags))
   {
     pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
     return NULL;
   }
 
   if (pSize) *pSize = (size_t)alloc_size;
   return pBuf;
 }
 
 void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags)
 {
   int file_index = mz_zip_reader_locate_file(pZip, pFilename, NULL, flags);
   if (file_index < 0)
   {
     if (pSize) *pSize = 0;
     return MZ_FALSE;
   }
   return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
 }
 
 mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
 {
   int status = TINFL_STATUS_DONE; mz_uint file_crc32 = MZ_CRC32_INIT;
   mz_uint64 read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, out_buf_ofs = 0, cur_file_ofs;
   mz_zip_archive_file_stat file_stat;
   void *pRead_buf = NULL; void *pWrite_buf = NULL;
   mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
 
   if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
     return MZ_FALSE;
 
   // Empty file, or a directory (but not always a directory - I've seen odd zips with directories that have compressed data which inflates to 0 bytes)
   if (!file_stat.m_comp_size)
     return MZ_TRUE;
 
   // Entry is a subdirectory (I've seen old zips with dir entries which have compressed deflate data which inflates to 0 bytes, but these entries claim to uncompress to 512 bytes in the headers).
   // I'm torn how to handle this case - should it fail instead?
   if (mz_zip_reader_is_file_a_directory(pZip, file_index))
     return MZ_TRUE;
 
   // Encryption and patch files are not supported.
   if (file_stat.m_bit_flag & (1 | 32))
     return MZ_FALSE;
 
   // This function only supports stored and deflate.
   if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
     return MZ_FALSE;
 
   // Read and parse the local directory entry.
   cur_file_ofs = file_stat.m_local_header_ofs;
   if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
     return MZ_FALSE;
   if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
     return MZ_FALSE;
 
   cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
   if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
     return MZ_FALSE;
 
   // Decompress the file either directly from memory or from a file input buffer.
   if (pZip->m_pState->m_pMem)
   {
     pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
     read_buf_size = read_buf_avail = file_stat.m_comp_size;
     comp_remaining = 0;
   }
   else
   {
     read_buf_size = MZ_MIN(file_stat.m_comp_size, MZ_ZIP_MAX_IO_BUF_SIZE);
     if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
       return MZ_FALSE;
     read_buf_avail = 0;
     comp_remaining = file_stat.m_comp_size;
   }
 
   if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
   {
     // The file is stored or the caller has requested the compressed data.
     if (pZip->m_pState->m_pMem)
     {
 #ifdef _MSC_VER
       if (((0, sizeof(size_t) == sizeof(mz_uint32))) && (file_stat.m_comp_size > 0xFFFFFFFF))
 #else
       if (((sizeof(size_t) == sizeof(mz_uint32))) && (file_stat.m_comp_size > 0xFFFFFFFF))
 #endif
         return MZ_FALSE;
       if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)file_stat.m_comp_size) != file_stat.m_comp_size)
         status = TINFL_STATUS_FAILED;
       else if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
         file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)file_stat.m_comp_size);
       cur_file_ofs += file_stat.m_comp_size;
       out_buf_ofs += file_stat.m_comp_size;
       comp_remaining = 0;
     }
     else
     {
       while (comp_remaining)
       {
         read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
         if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
         {
           status = TINFL_STATUS_FAILED;
           break;
         }
 
         if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
           file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)read_buf_avail);
 
         if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
         {
           status = TINFL_STATUS_FAILED;
           break;
         }
         cur_file_ofs += read_buf_avail;
         out_buf_ofs += read_buf_avail;
         comp_remaining -= read_buf_avail;
       }
     }
   }
   else
   {
     tinfl_decompressor inflator;
     tinfl_init(&inflator);
 
     if (NULL == (pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
       status = TINFL_STATUS_FAILED;
     else
     {
       do
       {
         mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pWrite_buf + (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
         size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
         if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
         {
           read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
           if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
           {
             status = TINFL_STATUS_FAILED;
             break;
           }
           cur_file_ofs += read_buf_avail;
           comp_remaining -= read_buf_avail;
           read_buf_ofs = 0;
         }
 
         in_buf_size = (size_t)read_buf_avail;
         status = tinfl_decompress(&inflator, (const mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pWrite_buf, pWrite_buf_cur, &out_buf_size, comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0);
         read_buf_avail -= in_buf_size;
         read_buf_ofs += in_buf_size;
 
         if (out_buf_size)
         {
           if (pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size)
           {
             status = TINFL_STATUS_FAILED;
             break;
           }
           file_crc32 = (mz_uint32)mz_crc32(file_crc32, pWrite_buf_cur, out_buf_size);
           if ((out_buf_ofs += out_buf_size) > file_stat.m_uncomp_size)
           {
             status = TINFL_STATUS_FAILED;
             break;
           }
         }
       } while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || (status == TINFL_STATUS_HAS_MORE_OUTPUT));
     }
   }
 
   if ((status == TINFL_STATUS_DONE) && (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
   {
     // Make sure the entire file was decompressed, and check its CRC.
     if ((out_buf_ofs != file_stat.m_uncomp_size) || (file_crc32 != file_stat.m_crc32))
       status = TINFL_STATUS_FAILED;
   }
 
   if (!pZip->m_pState->m_pMem)
     pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
   if (pWrite_buf)
     pZip->m_pFree(pZip->m_pAlloc_opaque, pWrite_buf);
 
   return status == TINFL_STATUS_DONE;
 }
 
 mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
 {
   int file_index = mz_zip_reader_locate_file(pZip, pFilename, NULL, flags);
   if (file_index < 0)
     return MZ_FALSE;
   return mz_zip_reader_extract_to_callback(pZip, file_index, pCallback, pOpaque, flags);
 }
 
 #ifndef MINIZ_NO_STDIO
 static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs, const void *pBuf, size_t n)
 {
   (void)ofs; return MZ_FWRITE(pBuf, 1, n, (MZ_FILE*)pOpaque);
 }
 
 mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
 {
   mz_bool status;
   mz_zip_archive_file_stat file_stat;
   MZ_FILE *pFile;
   if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
     return MZ_FALSE;
   pFile = MZ_FOPEN(pDst_filename, "wb");
   if (!pFile)
     return MZ_FALSE;
   status = mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
   if (MZ_FCLOSE(pFile) == EOF)
     return MZ_FALSE;
 #ifndef MINIZ_NO_TIME
   if (status)
     mz_zip_set_file_times(pDst_filename, file_stat.m_time, file_stat.m_time);
 #endif
   return status;
 }
 #endif // #ifndef MINIZ_NO_STDIO
 
 mz_bool mz_zip_reader_end(mz_zip_archive *pZip)
 {
   if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
     return MZ_FALSE;
 
   if (pZip->m_pState)
   {
     mz_zip_internal_state *pState = pZip->m_pState; pZip->m_pState = NULL;
     mz_zip_array_clear(pZip, &pState->m_central_dir);
     mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
     mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);
 
 #ifndef MINIZ_NO_STDIO
     if (pState->m_pFile)
     {
       MZ_FCLOSE(pState->m_pFile);
       pState->m_pFile = NULL;
     }
 #endif // #ifndef MINIZ_NO_STDIO
 
     pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
   }
   pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;
 
   return MZ_TRUE;
 }
 
 #ifndef MINIZ_NO_STDIO
 mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags)
 {
   int file_index = mz_zip_reader_locate_file(pZip, pArchive_filename, NULL, flags);
   if (file_index < 0)
     return MZ_FALSE;
   return mz_zip_reader_extract_to_file(pZip, file_index, pDst_filename, flags);
 }
 #endif
 
 // ------------------- .ZIP archive writing
 
 #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
 
 static void mz_write_le16(mz_uint8 *p, mz_uint16 v) { p[0] = (mz_uint8)v; p[1] = (mz_uint8)(v >> 8); }
 static void mz_write_le32(mz_uint8 *p, mz_uint32 v) { p[0] = (mz_uint8)v; p[1] = (mz_uint8)(v >> 8); p[2] = (mz_uint8)(v >> 16); p[3] = (mz_uint8)(v >> 24); }
 #define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v))
 #define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v))
 
 mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size)
 {
   if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
     return MZ_FALSE;
 
   if (pZip->m_file_offset_alignment)
   {
     // Ensure user specified file offset alignment is a power of 2.
     if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1))
       return MZ_FALSE;
   }
 
   if (!pZip->m_pAlloc) pZip->m_pAlloc = def_alloc_func;
   if (!pZip->m_pFree) pZip->m_pFree = def_free_func;
   if (!pZip->m_pRealloc) pZip->m_pRealloc = def_realloc_func;
 
   pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
   pZip->m_archive_size = existing_size;
   pZip->m_central_directory_file_ofs = 0;
   pZip->m_total_files = 0;
 
   if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
     return MZ_FALSE;
   memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
   MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
   MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
   MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
   return MZ_TRUE;
 }
 
 static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
 {
   mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
   mz_zip_internal_state *pState = pZip->m_pState;
   mz_uint64 new_size = MZ_MAX(file_ofs + n, pState->m_mem_size);
 #ifdef _MSC_VER
   if ((!n) || ((0, sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF)))
 #else
   if ((!n) || ((sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF)))
 #endif
     return 0;
   if (new_size > pState->m_mem_capacity)
   {
     void *pNew_block;
     size_t new_capacity = MZ_MAX(64, pState->m_mem_capacity); while (new_capacity < new_size) new_capacity *= 2;
     if (NULL == (pNew_block = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pState->m_pMem, 1, new_capacity)))
       return 0;
     pState->m_pMem = pNew_block; pState->m_mem_capacity = new_capacity;
   }
   memcpy((mz_uint8 *)pState->m_pMem + file_ofs, pBuf, n);
   pState->m_mem_size = (size_t)new_size;
   return n;
 }
 
 mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size)
 {
   pZip->m_pWrite = mz_zip_heap_write_func;
   pZip->m_pIO_opaque = pZip;
   if (!mz_zip_writer_init(pZip, size_to_reserve_at_beginning))
     return MZ_FALSE;
   if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning)))
   {
     if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, initial_allocation_size)))
     {
       mz_zip_writer_end(pZip);
       return MZ_FALSE;
     }
     pZip->m_pState->m_mem_capacity = initial_allocation_size;
   }
   return MZ_TRUE;
 }
 
 #ifndef MINIZ_NO_STDIO
 static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
 {
   mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
   mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
   if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))
     return 0;
   return MZ_FWRITE(pBuf, 1, n, pZip->m_pState->m_pFile);
 }
 
 mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning)
 {
   MZ_FILE *pFile;
   pZip->m_pWrite = mz_zip_file_write_func;
   pZip->m_pIO_opaque = pZip;
   if (!mz_zip_writer_init(pZip, size_to_reserve_at_beginning))
     return MZ_FALSE;
   if (NULL == (pFile = MZ_FOPEN(pFilename, "wb")))
   {
     mz_zip_writer_end(pZip);
     return MZ_FALSE;
   }
   pZip->m_pState->m_pFile = pFile;
   if (size_to_reserve_at_beginning)
   {
     mz_uint64 cur_ofs = 0; char buf[4096]; MZ_CLEAR_OBJ(buf);
     do
     {
       size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning);
       if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_ofs, buf, n) != n)
       {
         mz_zip_writer_end(pZip);
         return MZ_FALSE;
       }
       cur_ofs += n; size_to_reserve_at_beginning -= n;
     } while (size_to_reserve_at_beginning);
   }
   return MZ_TRUE;
 }
 #endif // #ifndef MINIZ_NO_STDIO
 
 mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename)
 {
   mz_zip_internal_state *pState;
   if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
     return MZ_FALSE;
   // No sense in trying to write to an archive that's already at the support max size
   if ((pZip->m_total_files == 0xFFFF) || ((pZip->m_archive_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) > 0xFFFFFFFF))
     return MZ_FALSE;
 
   pState = pZip->m_pState;
 
   if (pState->m_pFile)
   {
 #ifdef MINIZ_NO_STDIO
     pFilename; return MZ_FALSE;
 #else
     // Archive is being read from stdio - try to reopen as writable.
     if (pZip->m_pIO_opaque != pZip)
       return MZ_FALSE;
     if (!pFilename)
       return MZ_FALSE;
     pZip->m_pWrite = mz_zip_file_write_func;
     if (NULL == (pState->m_pFile = MZ_FREOPEN(pFilename, "r+b", pState->m_pFile)))
     {
       // The mz_zip_archive is now in a bogus state because pState->m_pFile is NULL, so just close it.
       mz_zip_reader_end(pZip);
       return MZ_FALSE;
     }
 #endif // #ifdef MINIZ_NO_STDIO
   }
   else if (pState->m_pMem)
   {
     // Archive lives in a memory block. Assume it's from the heap that we can resize using the realloc callback.
     if (pZip->m_pIO_opaque != pZip)
       return MZ_FALSE;
     pState->m_mem_capacity = pState->m_mem_size;
     pZip->m_pWrite = mz_zip_heap_write_func;
   }
   // Archive is being read via a user provided read function - make sure the user has specified a write function too.
   else if (!pZip->m_pWrite)
     return MZ_FALSE;
 
   // Start writing new files at the archive's current central directory location.
   pZip->m_archive_size = pZip->m_central_directory_file_ofs;
   pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
   pZip->m_central_directory_file_ofs = 0;
 
   return MZ_TRUE;
 }
 
 mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags)
 {
   return mz_zip_writer_add_mem_ex(pZip, pArchive_name, pBuf, buf_size, NULL, 0, level_and_flags, 0, 0);
 }
 
 typedef struct
 {
   mz_zip_archive *m_pZip;
   mz_uint64 m_cur_archive_file_ofs;
   mz_uint64 m_comp_size;
 } mz_zip_writer_add_state;
 
 static mz_bool mz_zip_writer_add_put_buf_callback(const void* pBuf, int len, void *pUser)
 {
   mz_zip_writer_add_state *pState = (mz_zip_writer_add_state *)pUser;
   if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque, pState->m_cur_archive_file_ofs, pBuf, len) != len)
     return MZ_FALSE;
   pState->m_cur_archive_file_ofs += len;
   pState->m_comp_size += len;
   return MZ_TRUE;
 }
 
 static mz_bool mz_zip_writer_create_local_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date)
 {
   (void)pZip;
   memset(pDst, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE);
   MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_SIG_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG);
   MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_VERSION_NEEDED_OFS, method ? 20 : 0);
   MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_BIT_FLAG_OFS, bit_flags);
   MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_METHOD_OFS, method);
   MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_TIME_OFS, dos_time);
   MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_DATE_OFS, dos_date);
   MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_CRC32_OFS, uncomp_crc32);
   MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, comp_size);
   MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, uncomp_size);
   MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILENAME_LEN_OFS, filename_size);
   MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_EXTRA_LEN_OFS, extra_size);
   return MZ_TRUE;
 }
 
 static mz_bool mz_zip_writer_create_central_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint16 comment_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date, mz_uint64 local_header_ofs, mz_uint32 ext_attributes)
 {
   (void)pZip;
   memset(pDst, 0, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
   MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG);
   MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_NEEDED_OFS, method ? 20 : 0);
   MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_BIT_FLAG_OFS, bit_flags);
   MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_METHOD_OFS, method);
   MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_TIME_OFS, dos_time);
   MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_DATE_OFS, dos_date);
   MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_CRC32_OFS, uncomp_crc32);
   MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, comp_size);
   MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, uncomp_size);
   MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILENAME_LEN_OFS, filename_size);
   MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_EXTRA_LEN_OFS, extra_size);
   MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_COMMENT_LEN_OFS, comment_size);
   MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS, ext_attributes);
   MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_LOCAL_HEADER_OFS, local_header_ofs);
   return MZ_TRUE;
 }
 
 static mz_bool mz_zip_writer_add_to_central_dir(mz_zip_archive *pZip, const char *pFilename, mz_uint16 filename_size, const void *pExtra, mz_uint16 extra_size, const void *pComment, mz_uint16 comment_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date, mz_uint64 local_header_ofs, mz_uint32 ext_attributes)
 {
   mz_zip_internal_state *pState = pZip->m_pState;
   mz_uint32 central_dir_ofs = (mz_uint32)pState->m_central_dir.m_size;
   size_t orig_central_dir_size = pState->m_central_dir.m_size;
   mz_uint8 central_dir_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
 
   // No zip64 support yet
   if ((local_header_ofs > 0xFFFFFFFF) || (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + extra_size + comment_size) > 0xFFFFFFFF))
     return MZ_FALSE;
 
   if (!mz_zip_writer_create_central_dir_header(pZip, central_dir_header, filename_size, extra_size, comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_header_ofs, ext_attributes))
     return MZ_FALSE;
 
   if ((!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_dir_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) ||
       (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pFilename, filename_size)) ||
       (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pExtra, extra_size)) ||
       (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pComment, comment_size)) ||
       (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &central_dir_ofs, 1)))
   {
     // Try to push the central directory array back into its original state.
     mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
     return MZ_FALSE;
   }
 
   return MZ_TRUE;
 }
 
 static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name)
 {
   // Basic ZIP archive filename validity checks: Valid filenames cannot start with a forward slash, cannot contain a drive letter, and cannot use DOS-style backward slashes.
   if (*pArchive_name == '/')
     return MZ_FALSE;
   while (*pArchive_name)
   {
     if ((*pArchive_name == '\\') || (*pArchive_name == ':'))
       return MZ_FALSE;
     pArchive_name++;
   }
   return MZ_TRUE;
 }
 
 static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip)
 {
   mz_uint32 n;
   if (!pZip->m_file_offset_alignment)
     return 0;
   n = (mz_uint32)(pZip->m_archive_size & (pZip->m_file_offset_alignment - 1));
   return (pZip->m_file_offset_alignment - n) & (pZip->m_file_offset_alignment - 1);
 }
 
 static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)
 {
   char buf[4096];
   memset(buf, 0, MZ_MIN(sizeof(buf), n));
   while (n)
   {
     mz_uint32 s = MZ_MIN(sizeof(buf), n);
     if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s)
       return MZ_FALSE;
     cur_file_ofs += s; n -= s;
   }
   return MZ_TRUE;
 }
 
 mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32)
 {
   mz_uint16 method = 0, dos_time = 0, dos_date = 0;
   mz_uint level, ext_attributes = 0, num_alignment_padding_bytes;
   mz_uint64 local_dir_header_ofs = pZip->m_archive_size, cur_archive_file_ofs = pZip->m_archive_size, comp_size = 0;
   size_t archive_name_size;
   mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
   tdefl_compressor *pComp = NULL;
   mz_bool store_data_uncompressed;
   mz_zip_internal_state *pState;
 
   if ((int)level_and_flags < 0)
     level_and_flags = MZ_DEFAULT_LEVEL;
   level = level_and_flags & 0xF;
   store_data_uncompressed = ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA));
 
   if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (pZip->m_total_files == 0xFFFF) || (level > MZ_UBER_COMPRESSION))
     return MZ_FALSE;
 
   pState = pZip->m_pState;
 
   if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size))
     return MZ_FALSE;
   // No zip64 support yet
   if ((buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF))
     return MZ_FALSE;
   if (!mz_zip_writer_validate_archive_name(pArchive_name))
     return MZ_FALSE;
 
 #ifndef MINIZ_NO_TIME
   {
     time_t cur_time; time(&cur_time);
     mz_zip_time_to_dos_time(cur_time, &dos_time, &dos_date);
   }
 #endif // #ifndef MINIZ_NO_TIME
 
   archive_name_size = strlen(pArchive_name);
   if (archive_name_size > 0xFFFF)
     return MZ_FALSE;
 
   num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
 
   // no zip64 support yet
   if ((pZip->m_total_files == 0xFFFF) || ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + comment_size + archive_name_size) > 0xFFFFFFFF))
     return MZ_FALSE;
 
   if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/'))
   {
     // Set DOS Subdirectory attribute bit.
     ext_attributes |= 0x10;
     // Subdirectories cannot contain data.
     if ((buf_size) || (uncomp_size))
       return MZ_FALSE;
   }
 
   // Try to do any allocations before writing to the archive, so if an allocation fails the file remains unmodified. (A good idea if we're doing an in-place modification.)
   if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size)) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1)))
     return MZ_FALSE;
 
   if ((!store_data_uncompressed) && (buf_size))
   {
     if (NULL == (pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor))))
       return MZ_FALSE;
   }
 
   if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes + sizeof(local_dir_header)))
   {
     pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
     return MZ_FALSE;
   }
   local_dir_header_ofs += num_alignment_padding_bytes;
   if (pZip->m_file_offset_alignment) { MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0); }
   cur_archive_file_ofs += num_alignment_padding_bytes + sizeof(local_dir_header);
 
   MZ_CLEAR_OBJ(local_dir_header);
   if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
   {
     pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
     return MZ_FALSE;
   }
   cur_archive_file_ofs += archive_name_size;
 
   if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
   {
     uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8*)pBuf, buf_size);
     uncomp_size = buf_size;
     if (uncomp_size <= 3)
     {
       level = 0;
       store_data_uncompressed = MZ_TRUE;
     }
   }
 
   if (store_data_uncompressed)
   {
     if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pBuf, buf_size) != buf_size)
     {
       pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
       return MZ_FALSE;
     }
 
     cur_archive_file_ofs += buf_size;
     comp_size = buf_size;
 
     if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)
       method = MZ_DEFLATED;
   }
   else if (buf_size)
   {
     mz_zip_writer_add_state state;
 
     state.m_pZip = pZip;
     state.m_cur_archive_file_ofs = cur_archive_file_ofs;
     state.m_comp_size = 0;
 
     if ((tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY) ||
         (tdefl_compress_buffer(pComp, pBuf, buf_size, TDEFL_FINISH) != TDEFL_STATUS_DONE))
     {
       pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
       return MZ_FALSE;
     }
 
     comp_size = state.m_comp_size;
     cur_archive_file_ofs = state.m_cur_archive_file_ofs;
 
     method = MZ_DEFLATED;
   }
 
   pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
   pComp = NULL;
 
   // no zip64 support yet
   if ((comp_size > 0xFFFFFFFF) || (cur_archive_file_ofs > 0xFFFFFFFF))
     return MZ_FALSE;
 
   if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, 0, uncomp_size, comp_size, uncomp_crc32, method, 0, dos_time, dos_date))
     return MZ_FALSE;
 
   if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
     return MZ_FALSE;
 
   if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, NULL, 0, pComment, comment_size, uncomp_size, comp_size, uncomp_crc32, method, 0, dos_time, dos_date, local_dir_header_ofs, ext_attributes))
     return MZ_FALSE;
 
   pZip->m_total_files++;
   pZip->m_archive_size = cur_archive_file_ofs;
 
   return MZ_TRUE;
 }
 
 #ifndef MINIZ_NO_STDIO
 mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
 {
   mz_uint uncomp_crc32 = MZ_CRC32_INIT, level, num_alignment_padding_bytes;
   mz_uint16 method = 0, dos_time = 0, dos_date = 0, ext_attributes = 0;
   mz_uint64 local_dir_header_ofs = pZip->m_archive_size, cur_archive_file_ofs = pZip->m_archive_size, uncomp_size = 0, comp_size = 0;
   size_t archive_name_size;
   mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
   MZ_FILE *pSrc_file = NULL;
 
   if ((int)level_and_flags < 0)
     level_and_flags = MZ_DEFAULT_LEVEL;
   level = level_and_flags & 0xF;
 
   if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
     return MZ_FALSE;
   if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)
     return MZ_FALSE;
   if (!mz_zip_writer_validate_archive_name(pArchive_name))
     return MZ_FALSE;
 
   archive_name_size = strlen(pArchive_name);
   if (archive_name_size > 0xFFFF)
     return MZ_FALSE;
 
   num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
 
   // no zip64 support yet
   if ((pZip->m_total_files == 0xFFFF) || ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + comment_size + archive_name_size) > 0xFFFFFFFF))
     return MZ_FALSE;
 
   if (!mz_zip_get_file_modified_time(pSrc_filename, &dos_time, &dos_date))
     return MZ_FALSE;
 
   pSrc_file = MZ_FOPEN(pSrc_filename, "rb");
   if (!pSrc_file)
     return MZ_FALSE;
   MZ_FSEEK64(pSrc_file, 0, SEEK_END);
   uncomp_size = MZ_FTELL64(pSrc_file);
   MZ_FSEEK64(pSrc_file, 0, SEEK_SET);
 
   if (uncomp_size > 0xFFFFFFFF)
   {
     // No zip64 support yet
     MZ_FCLOSE(pSrc_file);
     return MZ_FALSE;
   }
   if (uncomp_size <= 3)
     level = 0;
 
   if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes + sizeof(local_dir_header)))
   {
     MZ_FCLOSE(pSrc_file);
     return MZ_FALSE;
   }
   local_dir_header_ofs += num_alignment_padding_bytes;
   if (pZip->m_file_offset_alignment) { MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0); }
   cur_archive_file_ofs += num_alignment_padding_bytes + sizeof(local_dir_header);
 
   MZ_CLEAR_OBJ(local_dir_header);
   if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
   {
     MZ_FCLOSE(pSrc_file);
     return MZ_FALSE;
   }
   cur_archive_file_ofs += archive_name_size;
 
   if (uncomp_size)
   {
     mz_uint64 uncomp_remaining = uncomp_size;
     void *pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, MZ_ZIP_MAX_IO_BUF_SIZE);
     if (!pRead_buf)
     {
       MZ_FCLOSE(pSrc_file);
       return MZ_FALSE;
     }
 
     if (!level)
     {
       while (uncomp_remaining)
       {
         mz_uint n = (mz_uint)MZ_MIN(MZ_ZIP_MAX_IO_BUF_SIZE, uncomp_remaining);
         if ((MZ_FREAD(pRead_buf, 1, n, pSrc_file) != n) || (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pRead_buf, n) != n))
         {
           pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
           MZ_FCLOSE(pSrc_file);
           return MZ_FALSE;
         }
         uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
         uncomp_remaining -= n;
         cur_archive_file_ofs += n;
       }
       comp_size = uncomp_size;
     }
     else
     {
       mz_bool result = MZ_FALSE;
       mz_zip_writer_add_state state;
       tdefl_compressor *pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor));
       if (!pComp)
       {
         pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
         MZ_FCLOSE(pSrc_file);
         return MZ_FALSE;
       }
 
       state.m_pZip = pZip;
       state.m_cur_archive_file_ofs = cur_archive_file_ofs;
       state.m_comp_size = 0;
 
       if (tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY)
       {
         pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
         pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
         MZ_FCLOSE(pSrc_file);
         return MZ_FALSE;
       }
 
       for ( ; ; )
       {
         size_t in_buf_size = (mz_uint32)MZ_MIN(uncomp_remaining, MZ_ZIP_MAX_IO_BUF_SIZE);
         tdefl_status status;
 
         if (MZ_FREAD(pRead_buf, 1, in_buf_size, pSrc_file) != in_buf_size)
           break;
 
         uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, in_buf_size);
         uncomp_remaining -= in_buf_size;
 
         status = tdefl_compress_buffer(pComp, pRead_buf, in_buf_size, uncomp_remaining ? TDEFL_NO_FLUSH : TDEFL_FINISH);
         if (status == TDEFL_STATUS_DONE)
         {
           result = MZ_TRUE;
           break;
         }
         else if (status != TDEFL_STATUS_OKAY)
           break;
       }
 
       pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
 
       if (!result)
       {
         pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
         MZ_FCLOSE(pSrc_file);
         return MZ_FALSE;
       }
 
       comp_size = state.m_comp_size;
       cur_archive_file_ofs = state.m_cur_archive_file_ofs;
 
       method = MZ_DEFLATED;
     }
 
     pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
   }
 
   MZ_FCLOSE(pSrc_file); pSrc_file = NULL;
 
   // no zip64 support yet
   if ((comp_size > 0xFFFFFFFF) || (cur_archive_file_ofs > 0xFFFFFFFF))
     return MZ_FALSE;
 
   if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, 0, uncomp_size, comp_size, uncomp_crc32, method, 0, dos_time, dos_date))
     return MZ_FALSE;
 
   if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
     return MZ_FALSE;
 
   if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, NULL, 0, pComment, comment_size, uncomp_size, comp_size, uncomp_crc32, method, 0, dos_time, dos_date, local_dir_header_ofs, ext_attributes))
     return MZ_FALSE;
 
   pZip->m_total_files++;
   pZip->m_archive_size = cur_archive_file_ofs;
 
   return MZ_TRUE;
 }
 #endif // #ifndef MINIZ_NO_STDIO
 
 mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint file_index)
 {
   mz_uint n, bit_flags, num_alignment_padding_bytes;
   mz_uint64 comp_bytes_remaining, local_dir_header_ofs;
   mz_uint64 cur_src_file_ofs, cur_dst_file_ofs;
   mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
   mz_uint8 central_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
   size_t orig_central_dir_size;
   mz_zip_internal_state *pState;
   void *pBuf; const mz_uint8 *pSrc_central_header;
 
   if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING))
     return MZ_FALSE;
   if (NULL == (pSrc_central_header = mz_zip_reader_get_cdh(pSource_zip, file_index)))
     return MZ_FALSE;
   pState = pZip->m_pState;
 
   num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
 
   // no zip64 support yet
   if ((pZip->m_total_files == 0xFFFF) || ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) > 0xFFFFFFFF))
     return MZ_FALSE;
 
   cur_src_file_ofs = pSource_zip->m_archive_file_ofs + MZ_READ_LE32(pSrc_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
   cur_dst_file_ofs = pZip->m_archive_size;
 
   if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
     return MZ_FALSE;
   if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
     return MZ_FALSE;
   cur_src_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
 
   if (!mz_zip_writer_write_zeros(pZip, cur_dst_file_ofs, num_alignment_padding_bytes))
     return MZ_FALSE;
   cur_dst_file_ofs += num_alignment_padding_bytes;
   local_dir_header_ofs = cur_dst_file_ofs;
   if (pZip->m_file_offset_alignment) { MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0); }
 
   if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
     return MZ_FALSE;
   cur_dst_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
 
   n = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
   comp_bytes_remaining = n + MZ_READ_LE32(pSrc_central_header + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
 
   if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)MZ_MAX(sizeof(mz_uint32) * 4, MZ_MIN(MZ_ZIP_MAX_IO_BUF_SIZE, comp_bytes_remaining)))))
     return MZ_FALSE;
 
   while (comp_bytes_remaining)
   {
     n = (mz_uint)MZ_MIN(MZ_ZIP_MAX_IO_BUF_SIZE, comp_bytes_remaining);
     if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, n) != n)
     {
       pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
       return MZ_FALSE;
     }
     cur_src_file_ofs += n;
 
     if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
     {
       pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
       return MZ_FALSE;
     }
     cur_dst_file_ofs += n;
 
     comp_bytes_remaining -= n;
   }
 
   bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
   if (bit_flags & 8)
   {
     // Copy data descriptor
     if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, sizeof(mz_uint32) * 4) != sizeof(mz_uint32) * 4)
     {
       pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
       return MZ_FALSE;
     }
 
     n = sizeof(mz_uint32) * ((MZ_READ_LE32(pBuf) == 0x08074b50) ? 4 : 3);
     if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
     {
       pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
       return MZ_FALSE;
     }
 
     cur_src_file_ofs += n;
     cur_dst_file_ofs += n;
   }
   pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
 
   // no zip64 support yet
   if (cur_dst_file_ofs > 0xFFFFFFFF)
     return MZ_FALSE;
 
   orig_central_dir_size = pState->m_central_dir.m_size;
 
   memcpy(central_header, pSrc_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
   MZ_WRITE_LE32(central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, local_dir_header_ofs);
   if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
     return MZ_FALSE;
 
   n = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS) + MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_COMMENT_LEN_OFS);
   if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n))
   {
     mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
     return MZ_FALSE;
   }
 
   if (pState->m_central_dir.m_size > 0xFFFFFFFF)
     return MZ_FALSE;
   n = (mz_uint32)orig_central_dir_size;
   if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1))
   {
     mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
     return MZ_FALSE;
   }
 
   pZip->m_total_files++;
   pZip->m_archive_size = cur_dst_file_ofs;
 
   return MZ_TRUE;
 }
 
 mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip)
 {
   mz_zip_internal_state *pState;
   mz_uint64 central_dir_ofs, central_dir_size;
   mz_uint8 hdr[MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE];
 
   if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING))
     return MZ_FALSE;
 
   pState = pZip->m_pState;
 
   // no zip64 support yet
   if ((pZip->m_total_files > 0xFFFF) || ((pZip->m_archive_size + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) > 0xFFFFFFFF))
     return MZ_FALSE;
 
   central_dir_ofs = 0;
   central_dir_size = 0;
   if (pZip->m_total_files)
   {
     // Write central directory
     central_dir_ofs = pZip->m_archive_size;
     central_dir_size = pState->m_central_dir.m_size;
     pZip->m_central_directory_file_ofs = central_dir_ofs;
     if (pZip->m_pWrite(pZip->m_pIO_opaque, central_dir_ofs, pState->m_central_dir.m_p, (size_t)central_dir_size) != central_dir_size)
       return MZ_FALSE;
     pZip->m_archive_size += central_dir_size;
   }
 
   // Write end of central directory record
   MZ_CLEAR_OBJ(hdr);
   MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_SIG_OFS, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG);
   MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, pZip->m_total_files);
   MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, pZip->m_total_files);
   MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_SIZE_OFS, central_dir_size);
   MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_OFS_OFS, central_dir_ofs);
 
   if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, sizeof(hdr)) != sizeof(hdr))
     return MZ_FALSE;
 #ifndef MINIZ_NO_STDIO
   if ((pState->m_pFile) && (MZ_FFLUSH(pState->m_pFile) == EOF))
     return MZ_FALSE;
 #endif // #ifndef MINIZ_NO_STDIO
 
   pZip->m_archive_size += sizeof(hdr);
 
   pZip->m_zip_mode = MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED;
   return MZ_TRUE;
 }
 
 mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **pBuf, size_t *pSize)
 {
   if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pSize))
     return MZ_FALSE;
   if (pZip->m_pWrite != mz_zip_heap_write_func)
     return MZ_FALSE;
   if (!mz_zip_writer_finalize_archive(pZip))
     return MZ_FALSE;
 
   *pBuf = pZip->m_pState->m_pMem;
   *pSize = pZip->m_pState->m_mem_size;
   pZip->m_pState->m_pMem = NULL;
   pZip->m_pState->m_mem_size = pZip->m_pState->m_mem_capacity = 0;
   return MZ_TRUE;
 }
 
 mz_bool mz_zip_writer_end(mz_zip_archive *pZip)
 {
   mz_zip_internal_state *pState;
   mz_bool status = MZ_TRUE;
   if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)))
     return MZ_FALSE;
 
   pState = pZip->m_pState;
   pZip->m_pState = NULL;
   mz_zip_array_clear(pZip, &pState->m_central_dir);
   mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
   mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);
 
 #ifndef MINIZ_NO_STDIO
   if (pState->m_pFile)
   {
     MZ_FCLOSE(pState->m_pFile);
     pState->m_pFile = NULL;
   }
 #endif // #ifndef MINIZ_NO_STDIO
 
   if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem))
   {
     pZip->m_pFree(pZip->m_pAlloc_opaque, pState->m_pMem);
     pState->m_pMem = NULL;
   }
 
   pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
   pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;
   return status;
 }
 
 #ifndef MINIZ_NO_STDIO
 mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
 {
   mz_bool status, created_new_archive = MZ_FALSE;
   mz_zip_archive zip_archive;
   struct MZ_FILE_STAT_STRUCT file_stat;
   MZ_CLEAR_OBJ(zip_archive);
   if ((int)level_and_flags < 0)
      level_and_flags = MZ_DEFAULT_LEVEL;
   if ((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || ((comment_size) && (!pComment)) || ((level_and_flags & 0xF) > MZ_UBER_COMPRESSION))
     return MZ_FALSE;
   if (!mz_zip_writer_validate_archive_name(pArchive_name))
     return MZ_FALSE;
   if (MZ_FILE_STAT(pZip_filename, &file_stat) != 0)
   {
     // Create a new archive.
     if (!mz_zip_writer_init_file(&zip_archive, pZip_filename, 0))
       return MZ_FALSE;
     created_new_archive = MZ_TRUE;
   }
   else
   {
     // Append to an existing archive.
     if (!mz_zip_reader_init_file(&zip_archive, pZip_filename, level_and_flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY))
       return MZ_FALSE;
     if (!mz_zip_writer_init_from_reader(&zip_archive, pZip_filename))
     {
       mz_zip_reader_end(&zip_archive);
       return MZ_FALSE;
     }
   }
   status = mz_zip_writer_add_mem_ex(&zip_archive, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, 0, 0);
   // Always finalize, even if adding failed for some reason, so we have a valid central directory. (This may not always succeed, but we can try.)
   if (!mz_zip_writer_finalize_archive(&zip_archive))
     status = MZ_FALSE;
   if (!mz_zip_writer_end(&zip_archive))
     status = MZ_FALSE;
   if ((!status) && (created_new_archive))
   {
     // It's a new archive and something went wrong, so just delete it.
     int ignoredStatus = MZ_DELETE_FILE(pZip_filename);
     (void)ignoredStatus;
   }
   return status;
 }
 
 void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags)
 {
   int file_index;
   mz_zip_archive zip_archive;
   void *p = NULL;
 
   if (pSize)
     *pSize = 0;
 
   if ((!pZip_filename) || (!pArchive_name))
     return NULL;
 
   MZ_CLEAR_OBJ(zip_archive);
   if (!mz_zip_reader_init_file(&zip_archive, pZip_filename, flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY))
     return NULL;
 
   if ((file_index = mz_zip_reader_locate_file(&zip_archive, pArchive_name, NULL, flags)) >= 0)
     p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, pSize, flags);
 
   mz_zip_reader_end(&zip_archive);
   return p;
 }
 
 #endif // #ifndef MINIZ_NO_STDIO
 
 #endif // #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
 
 #endif // #ifndef MINIZ_NO_ARCHIVE_APIS
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MINIZ_HEADER_FILE_ONLY
 
 /*
   This is free and unencumbered software released into the public domain.
 
   Anyone is free to copy, modify, publish, use, compile, sell, or
   distribute this software, either in source code form or as a compiled
   binary, for any purpose, commercial or non-commercial, and by any
   means.
 
   In jurisdictions that recognize copyright laws, the author or authors
   of this software dedicate any and all copyright interest in the
   software to the public domain. We make this dedication for the benefit
   of the public at large and to the detriment of our heirs and
   successors. We intend this dedication to be an overt act of
   relinquishment in perpetuity of all present and future rights to this
   software under copyright law.
 
   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 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.
 
-  For more information, please refer to <http://unlicense.org/>
+  For more information, please refer to <https://unlicense.org/>
 */
diff --git a/Modules/CppMicroServices/third_party/us_stdint.h b/Modules/CppMicroServices/third_party/us_stdint.h
index 66532802e0..81f4536d7b 100644
--- a/Modules/CppMicroServices/third_party/us_stdint.h
+++ b/Modules/CppMicroServices/third_party/us_stdint.h
@@ -1,33 +1,33 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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.
 
 ============================================================================*/
 
 #ifndef USSTDINT_H
 #define USSTDINT_H
 
 #ifdef US_HAVE_STDINT_H
 #include <stdint.h>
 #elif defined(_MSC_VER)
 #include "us_stdint_vc_p.h"
 #else
 #error The stdint.h header is not available
 #endif
 
 #endif // USSTDINT_H
diff --git a/Modules/CppMicroServices/tools/usResourceCompiler.c b/Modules/CppMicroServices/tools/usResourceCompiler.c
index 641f51e7be..dbd1096902 100644
--- a/Modules/CppMicroServices/tools/usResourceCompiler.c
+++ b/Modules/CppMicroServices/tools/usResourceCompiler.c
@@ -1,663 +1,663 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   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
+    https://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 "miniz.h"
 
 #include <string.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <errno.h>
 
 #define US_STR_(x) #x
 #define US_STR(x) US_STR_(x)
 
 static int cleanup_archive(mz_zip_archive* writeArchive)
 {
   if (writeArchive && writeArchive->m_zip_mode != MZ_ZIP_MODE_INVALID)
   {
     if (writeArchive->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)
     {
       if (!mz_zip_writer_finalize_archive(writeArchive))
       {
         return -1;
       }
     }
     if (writeArchive->m_zip_mode != MZ_ZIP_MODE_INVALID)
     {
       if (!mz_zip_writer_end(writeArchive))
       {
         return -1;
       }
     }
   }
   return 0;
 }
 
 static void exit_printf(mz_zip_archive* writeArchive, const char* format, ...)
 {
   va_list args;
   cleanup_archive(writeArchive);
   fprintf(stderr, "error: ");
   va_start(args, format);
   vfprintf(stderr, format, args);
   va_end(args);
   exit(EXIT_FAILURE);
 }
 
 static void exit_perror(mz_zip_archive* writeArchive, const char* desc)
 {
   cleanup_archive(writeArchive);
   fprintf(stderr, "error: ");
   perror(desc);
   exit(EXIT_FAILURE);
 }
 
 // ---------------------------------------------------------------------------------
 // --------------------------    PLATFORM SPECIFIC CODE    -------------------------
 // ---------------------------------------------------------------------------------
 
 #if defined(_WIN32) || defined(_WIN64)
 
 #define WIN32_LEAN_AND_MEAN
 #define VC_EXTRALEAN
 #include <windows.h>
 #include <io.h>
 #include <direct.h>
 #include <share.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 
 static char* get_error_str()
 {
   // Retrieve the system error message for the last-error code
   LPVOID lpMsgBuf;
   DWORD dw = GetLastError();
 
   FormatMessage(
     FORMAT_MESSAGE_ALLOCATE_BUFFER |
     FORMAT_MESSAGE_FROM_SYSTEM |
     FORMAT_MESSAGE_IGNORE_INSERTS,
     NULL,
     dw,
     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
     (LPTSTR) &lpMsgBuf,
     0, NULL );
 
   return lpMsgBuf;
 }
 
 static void free_error_str(char* buf)
 {
   LocalFree(buf);
 }
 
 static char* us_strcpy(char* dest, size_t dest_size, const char* src)
 {
   if (strcpy_s(dest, dest_size, src))
   {
     char* err_str = get_error_str();
     exit_printf(NULL, NULL, err_str);
   }
   return dest;
 }
 
 static char* us_strncpy(char* dest, size_t dest_size, const char* src, size_t count)
 {
   if (strncpy_s(dest, dest_size, src, count))
   {
     char* err_str = get_error_str();
     exit_printf(NULL, NULL, err_str);
   }
   return dest;
 }
 
 static FILE* us_fopen(const char* filename, const char* mode)
 {
   FILE* file = NULL;
   fopen_s(&file, filename, mode);
   return file;
 }
 
 #define US_CWD(b, s) _getcwd(b, s)
 
 #define US_CLOSE _close
 #define US_READ _read
 #define US_FOPEN us_fopen
 #define US_FILENO _fileno
 
 #define US_STRCASECMP _stricmp
 #define US_STRCPY us_strcpy
 #define US_STRNCPY us_strncpy
 
 #define US_SSCANF sscanf_s
 
 #else
 
 #include <unistd.h>
 
 static char* get_error_str()
 {
   return strerror(errno);
 }
 
 static void free_error_str(char* buf)
 {
 }
 
 static char* us_strcpy(char* dest, size_t dest_size, const char* src)
 {
   return strcpy(dest, src);
 }
 
 static char* us_strncpy(char* dest, size_t dest_size, const char* src, size_t count)
 {
   return strncpy(dest, src, count);
 }
 
 #define US_CLOSE close
 #define US_READ read
 #define US_FOPEN fopen
 #define US_FILENO fileno
 
 #define US_STRCASECMP strcasecmp
 #define US_STRCPY us_strcpy
 #define US_STRNCPY us_strncpy
 
 #define US_SSCANF sscanf
 
 #endif
 
 // ---------------------------------------------------------------------------------
 // -----------------------------    DEBUGGING STUFF    -----------------------------
 // ---------------------------------------------------------------------------------
 
 //#define DEBUG_TRACE
 
 #ifdef DEBUG_TRACE
 #define dbg_print printf
 #else
 static int void_printf(const char* format, ...) { return 0; }
 #define dbg_print void_printf
 #endif
 
 // ---------------------------------------------------------------------------------
 // -----------------------------    HELPER FUNCTIONS    ----------------------------
 // ---------------------------------------------------------------------------------
 
 void* malloc_or_abort(size_t size)
 {
   void* p;
   if (size == 0) size = 1;
   p = malloc(size);
   if (!p)
   {
     // try to print an error message; this might very well fail
     fprintf(stderr, "Could not allocate enough memory (%lld bytes)\n", size);
     abort();
   }
   return p;
 }
 
 static int cmpzipindex(const void *i1, const void *i2)
 {
   mz_uint index1 = *(const mz_uint*)i1;
   mz_uint index2 = *(const mz_uint*)i2;
   return index1 == index2 ? 0 : (index1 < index2 ? -1 : 1);
 }
 
 static int cmpstringp(const void *p1, const void *p2)
 {
   return US_STRCASECMP(* (char * const *) p1, * (char * const *) p2);
 }
 
 typedef struct us_archived_names_tag
 {
   char** names;
   mz_uint size;
   mz_uint capacity;
   mz_uint orderedSize;
 } us_archived_names;
 
 static void us_archived_names_free(us_archived_names * archivedNames)
 {
   mz_uint i;
   for (i = 0; i < archivedNames->size; ++i)
   {
     free(archivedNames->names[i]);
   }
   free(archivedNames->names);
 }
 
 enum
 {
   US_OK = 0,
   US_ARCHIVED_NAMES_ERROR_DUPLICATE = 1,
   US_MZ_ERROR_ADD_FILE = 2,
   US_ERROR_INVALID = 3
 };
 
 // messages can take two arguments:
 //   1. The archive entry name
 //   2. The path of the zip archive
 const char* us_error_msg[] = {
   "ok\n",
   "Duplicate entry '%s' (in %s)\n",
   "Could not add resource %s\n"
 };
 
 static int us_archived_names_append(us_archived_names* archivedNames, const char* archiveName)
 {
   if (archivedNames->names != NULL &&
       bsearch(&archiveName, archivedNames->names, archivedNames->orderedSize, sizeof(char*), cmpstringp) != NULL)
   {
     return US_ARCHIVED_NAMES_ERROR_DUPLICATE;
   }
 
   if (archivedNames->size >= archivedNames->capacity)
   {
     size_t newCapacity = archivedNames->size > archivedNames->capacity + 100 ? archivedNames->size + 1 : archivedNames->capacity + 100;
     archivedNames->names = realloc(archivedNames->names, newCapacity * sizeof(char*));
     if (archivedNames->names == NULL)
     {
       fprintf(stderr, "Could not realloc enough memory (%lld bytes)\n", newCapacity);
       abort();
     }
     memset(archivedNames->names + archivedNames->capacity, 0, sizeof(char*) * (newCapacity - archivedNames->capacity));
     archivedNames->capacity = (mz_uint)newCapacity;
   }
 
   if (archivedNames->names[archivedNames->size] == NULL)
   {
     archivedNames->names[archivedNames->size] = malloc_or_abort(MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE * sizeof(char));
   }
   US_STRCPY(archivedNames->names[archivedNames->size], MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE, archiveName);
   ++archivedNames->size;
 
   return US_OK;
 }
 
 static void us_archived_names_sort(us_archived_names* archivedNames)
 {
   qsort(archivedNames->names, archivedNames->size, sizeof(char*), cmpstringp);
   archivedNames->orderedSize = archivedNames->size;
 }
 
 static int us_zip_writer_add_dir_entries(mz_zip_archive* pZip, const char* pArchive_name, us_archived_names* archived_dirs)
 {
   size_t end;
   size_t length = strlen(pArchive_name);
   char dirName[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE];
   if (sizeof dirName < length - 1)
   {
     // This should be impossible
     fprintf(stderr, "Archive file name '%s' too long (%lld > %lld)", pArchive_name, length-1, sizeof dirName);
     exit(EXIT_FAILURE);
   }
 
   // split the archive name into directory tokens
   for (end = 0; end < length; ++end)
   {
     if (pArchive_name[end] == '/')
     {
       US_STRNCPY(dirName, sizeof dirName, pArchive_name, end + 1);
       //if (end < length-1)
       //{
         dirName[end+1] = '\0';
       //}
       if (us_archived_names_append(archived_dirs, dirName) == US_OK)
       {
         dbg_print("-- found new dir entry %s\n", dirName);
         // The directory entry does not yet exist, so add it
         if (!mz_zip_writer_add_mem(pZip, dirName, NULL, 0, MZ_NO_COMPRESSION))
         {
           dbg_print("-- zip add_mem error\n");
           return US_MZ_ERROR_ADD_FILE;
         }
         us_archived_names_sort(archived_dirs);
       }
     }
   }
   return US_OK;
 }
 
 static int us_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name,
                                   const char *pSrc_filename, const void *pComment,
                                   mz_uint16 comment_size, mz_uint level_and_flags,
                                   us_archived_names* archived_names,
                                   us_archived_names* archived_dirs)
 {
   int retCode = us_archived_names_append(archived_names, pArchive_name);
   if (US_OK != retCode) return retCode;
 
   if (!mz_zip_writer_add_file(pZip, pArchive_name, pSrc_filename, pComment,
                               comment_size, level_and_flags))
   {
     return US_MZ_ERROR_ADD_FILE;
   }
   return us_zip_writer_add_dir_entries(pZip, pArchive_name, archived_dirs);
 }
 
 static int us_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip,
                                              mz_uint file_index, us_archived_names* archived_names,
                                              us_archived_names* archived_dirs,
                                              char* archiveName, mz_uint archiveNameSize)
 {
   int retCode = 0;
 
   mz_uint numBytes = mz_zip_reader_get_filename(pSource_zip, file_index, archiveName, archiveNameSize);
   if (numBytes > 1 && archiveName[numBytes-2] != '/')
   {
     retCode = us_archived_names_append(archived_names, archiveName);
     if (US_OK != retCode) return retCode;
 
     if (!mz_zip_writer_add_from_zip_reader(pZip, pSource_zip, file_index))
     {
       return US_MZ_ERROR_ADD_FILE;
     }
   }
   return us_zip_writer_add_dir_entries(pZip, archiveName, archived_dirs);
 }
 
 // ---------------------------------------------------------------------------------
 // -----------------------------    MAIN ENTRY POINT    ----------------------------
 // ---------------------------------------------------------------------------------
 
 int main(int argc, char** argv)
 {
   int compressionLevel = 6;
   int argIndex = 0;
   int bPrintHelp = 0;
   int bAppendMode = 0;
 
   int errCode = US_OK;
 
   int mergeFlag = 0;
   const char* zipFile = NULL;
   const char* moduleName = NULL;
   size_t moduleNameLength = 0;
 
   FILE* zipfileStream = NULL;
   mz_zip_archive writeArchive;
 
   us_archived_names archivedNames;
   us_archived_names archivedDirs;
 
   FILE* appendStream = NULL;
 
   char archiveName[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE];
 
   int numZipArgs = 0;
   int* zipArgIndices = NULL;
 
   mz_zip_archive currFileArchive;
 
   int zipArgIndex = 0;
 
   char readBuffer[1024];
   mz_uint numRead = 0;
 
 
   // ---------------------------------------------------------------------------------
   //      COMMAND LINE VALIDATION
   // ---------------------------------------------------------------------------------
 
   if (argc < 4)
   {
     bPrintHelp = 1;
   }
   else if (argv[1][0] == '-')
   {
     if (strlen(argv[1]) == 2)
     {
       if (US_SSCANF(argv[1], "-%1d", &compressionLevel) != 1)
       {
         bPrintHelp = 1;
       }
       else
       {
         argIndex = 1;
         if (argc < 5 || compressionLevel < 0 || compressionLevel > 9) bPrintHelp = 1;
       }
     }
     else if (strcmp(argv[1], "--append") == 0)
     {
       if (argc > 4)
       {
         bPrintHelp = 1;
       }
       bAppendMode = 1;
     }
     else
     {
       bPrintHelp = 1;
     }
   }
 
   if (bPrintHelp)
   {
     printf("A resource compiler for C++ Micro Services modules\n\n");
     printf("Usage: usResourceCompiler [-#] zipfile modulename [[-a] file...] [-m archive...]\n");
     printf("Usage: usResourceCompiler --append outfile zipfile\n\n");
     printf("Add entries to zipfile and merge archives.\n\n");
     printf("  -# (-0, -1, -2, -3, -4, -5, -6, -7, -8, -9)\n");
     printf("             The Zip compression level. The default compression level is -6.\n");
     printf("  zipfile    The absolute path of the zip file.\n");
     printf("  modulename The module name as specified in the MODULE_NAME compile definition.\n");
     printf("  file       Path to a resource file, relative to the current working directory.\n");
     printf("  archive    Path to a zip archive for merging into zipfile.\n");
     exit(EXIT_SUCCESS);
   }
 
   if (bAppendMode)
   {
     // Special "append" mode. Just append zipfile to outfile as a binary blob.
     // Open the module file for appending the temporary zip archive
     dbg_print("Opening outfile '%s' as ab... ", argv[2]);
     if (NULL == (appendStream = US_FOPEN(argv[2], "ab")))
     {
       dbg_print("failure\n");
       exit_perror(NULL, "fopen");
     }
     else
     {
       dbg_print("success\n");
     }
 
     dbg_print("Opening zipfile '%s' as rb... ", argv[3]);
     if (NULL == (zipfileStream = US_FOPEN(argv[3], "rb")))
     {
       dbg_print("failure\n");
       exit_perror(NULL, "fopen");
     }
     else
     {
       dbg_print("success\n");
     }
 
     dbg_print("Appending zipfile to outfile\n");
     do
     {
       numRead = US_READ(US_FILENO(zipfileStream), readBuffer, sizeof(readBuffer));
       if (numRead == -1)
       {
         exit_perror(NULL, "read");
       }
       fwrite(readBuffer, numRead, 1, appendStream);
       if (ferror(appendStream))
       {
         exit_printf(&writeArchive, "Appending zipfile failed\n");
       }
     } while (numRead != 0);
 
     fclose(zipfileStream);
     fclose(appendStream);
     exit(EXIT_SUCCESS);
   }
 
 
   // ---------------------------------------------------------------------------------
   //      OPEN OR CREATE ZIP FILE
   // ---------------------------------------------------------------------------------
 
   zipFile = argv[++argIndex];
   moduleName = argv[++argIndex];
   moduleNameLength = strlen(moduleName);
 
   memset(&writeArchive, 0, sizeof(writeArchive));
   memset(&archivedNames, 0, sizeof archivedNames);
   memset(&archivedDirs, 0, sizeof archivedDirs);
 
 
   // ---------------------------------------------------------------------------------
   //      ZIP ARCHIVE WRITING (temporary archive)
   // ---------------------------------------------------------------------------------
 
   // Create a new zip archive which will be copied to zipfile later
   dbg_print("Creating zip archive\n");
   remove(zipFile);
 
   if (!mz_zip_writer_init_file(&writeArchive, zipFile, 0))
   {
     exit_printf(&writeArchive, "Internal error, could not init new zip archive\n");
   }
   dbg_print("Initialized zip archive\n");
 
   // Add current files to the zip archive
   zipArgIndices = malloc_or_abort(argc * sizeof *zipArgIndices);
   while(++argIndex < argc)
   {
     const char* fileName = argv[argIndex];
     const size_t fileNameLength = strlen(fileName);
 
     // determine the argument type
     if (strcmp(argv[argIndex], "-a") == 0)
     {
       mergeFlag = 0;
       continue;
     }
     else if (strcmp(argv[argIndex], "-m") == 0)
     {
       mergeFlag = 1;
       continue;
     }
 
     if (mergeFlag)
     {
       // check if the current file is a valid zip archive
       memset(&currFileArchive, 0, sizeof(currFileArchive));
       if (mz_zip_reader_init_file(&currFileArchive, fileName, 0))
       {
         dbg_print("Input is a valid zip archive: %s\n", fileName);
         zipArgIndices[numZipArgs++] = argIndex;
         mz_zip_reader_end(&currFileArchive);
       }
       // silently ignore files which are not zip archives
       continue;
     }
 
     if (fileNameLength + 1 + moduleNameLength > MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE - 1)
     {
       exit_printf(&writeArchive, "Resource filename too long: %s\n", moduleName);
     }
     US_STRCPY(archiveName, sizeof archiveName, moduleName);
     archiveName[moduleNameLength] = '/';
     US_STRCPY(archiveName + moduleNameLength + 1, (sizeof archiveName) - (moduleNameLength + 1), fileName);
 
     printf("  adding: %s\n", archiveName);
 
     // add the current file to the new archive
     if ((errCode = us_zip_writer_add_file(&writeArchive, archiveName, fileName, NULL, 0, compressionLevel,
                                          &archivedNames, &archivedDirs)))
     {
       dbg_print("Adding %s failed\n", archiveName);
       exit_printf(&writeArchive, us_error_msg[errCode], archiveName, fileName);
     }
   }
 
   us_archived_names_sort(&archivedNames);
 
   dbg_print("Added cmd line files to zip archive\n");
 
   // ---------------------------------------------------------------------------------
   //      MERGE ZIPFILE ENTRIES (into temporary archive)
   // ---------------------------------------------------------------------------------
 
   for (zipArgIndex = 0; zipArgIndex < numZipArgs; ++zipArgIndex)
   {
     mz_zip_archive currZipArchive;
     const char* currArchiveFileName = NULL;
     mz_uint currZipIndex = 0;
     mz_uint numZipIndices = 0;
 
     memset(&currZipArchive, 0, sizeof(mz_zip_archive));
     currArchiveFileName = argv[zipArgIndices[zipArgIndex]];
     if (!mz_zip_reader_init_file(&currZipArchive, currArchiveFileName, 0))
     {
       exit_printf(&writeArchive, "Could not initialize zip archive %s\n", currArchiveFileName);
     }
 
     numZipIndices = mz_zip_reader_get_num_files(&currZipArchive);
     for (currZipIndex = 0; currZipIndex < numZipIndices; ++currZipIndex)
     {
       errCode = us_zip_writer_add_from_zip_reader(&writeArchive, &currZipArchive, currZipIndex, &archivedNames,
                                                   &archivedDirs, archiveName, sizeof archiveName);
       printf(" merging: %s (from %s)\n", archiveName, currArchiveFileName);
       if (errCode == US_ARCHIVED_NAMES_ERROR_DUPLICATE)
       {
         printf(" warning: Merge failed: ");
         printf(us_error_msg[errCode], archiveName, currArchiveFileName);
       }
       else if (errCode != US_OK)
       {
         mz_zip_reader_end(&currZipArchive);
         exit_printf(&writeArchive, us_error_msg[errCode], archiveName, currArchiveFileName);
       }
     }
 
     mz_zip_reader_end(&currZipArchive);
     us_archived_names_sort(&archivedNames);
   }
 
   // We are finished, finalize the zip archive
   if (!mz_zip_writer_finalize_archive(&writeArchive))
   {
     exit_printf(&writeArchive, "Could not finalize zip archive\n");
   }
 
   dbg_print("Finalized zip archive\n");
 
 
   // ---------------------------------------------------------------------------------
   //      CLEANUP
   // ---------------------------------------------------------------------------------
 
   free(zipArgIndices);
   us_archived_names_free(&archivedNames);
   us_archived_names_free(&archivedDirs);
 
   if (cleanup_archive(&writeArchive) == -1)
   {
     fprintf(stderr, "Internal error finalizing zip archive\n");
     return EXIT_FAILURE;
   }
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DICOM/include/mitkDICOMFileReader.h b/Modules/DICOM/include/mitkDICOMFileReader.h
index 1e5c48219d..53b3208ae2 100644
--- a/Modules/DICOM/include/mitkDICOMFileReader.h
+++ b/Modules/DICOM/include/mitkDICOMFileReader.h
@@ -1,169 +1,169 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkDICOMFileReader_h
 #define mitkDICOMFileReader_h
 
 #include "itkObjectFactory.h"
 #include "mitkCommon.h"
 
 #include "MitkDICOMExports.h"
 
 #include "mitkDICOMTagCache.h"
 
 #include "mitkDICOMImageBlockDescriptor.h"
 
 #include <unordered_map>
 
 namespace mitk
 {
 // TODO Philips3D!
-// TODO http://bugs.mitk.org/show_bug.cgi?id=11572 ?
+// TODO https://phabricator.mitk.org/T11572 ?
 
 /**
   \ingroup DICOMModule
   \brief Interface for DICOM readers that produce mitk::Images.
 
   As described in \ref DICOMModule, this class structures
   the reader's part in the process of analyzing a set of DICOM files
   and selecting the most appropriate reader.
 
   The overall loading process is as follows:
    - <b>Define input files</b>: a list of absolute filenames
    - <b>Analyze the potential output</b>: see what can be made of the input files, describe with
   DICOMImageBlockDescriptor%s
    - <b>Load pixel data</b>: an application will usually analyze files using multiple readers and only load
   with a single reader
 
   Sub-classes are required to implement a number of methods that
   reflect above structure. See mitk::DICOMITKSeriesGDCMReader for
   an example.
 
   To help applications in describing different readers to the user, each reader
   brings a number of methods that describe its configuration/specifics by
   means of a short label and a (longer) description.
 */
 class MITKDICOM_EXPORT DICOMFileReader : public itk::Object
 {
 public:
   mitkClassMacroItkParent( DICOMFileReader, itk::Object );
 
   /// Test whether a file is DICOM at all
   static bool IsDICOM( const std::string& filename );
   /// Indicate whether this reader can handle given file
   virtual bool CanHandleFile( const std::string& filename ) = 0;
 
   /// This input files
   void SetInputFiles( const StringList& filenames );
   /// This input files
   const StringList& GetInputFiles() const;
 
   /// Analyze input files
   virtual void AnalyzeInputFiles() = 0;
 
   /// Number of outputs, only meaningful after calling AnalyzeInputFiles()
   unsigned int GetNumberOfOutputs() const;
   /// Individual outputs, only meaningful after calling AnalyzeInputFiles(). \throws std::invalid_argument
   const DICOMImageBlockDescriptor& GetOutput( unsigned int index ) const;
 
   // void AllocateOutputImages(); TODO for later implementation of slice-by-slice loading
 
   /// Load the mitk::Image%s in our outputs, the DICOMImageBlockDescriptor. To be called only after
   /// AnalyzeInputFiles(). Take care of potential exceptions!
   virtual bool LoadImages() = 0;
 
   virtual DICOMTagPathList GetTagsOfInterest() const = 0;
 
   /// A way to provide external knowledge about files and tag values is appreciated.
   virtual void SetTagCache( const DICOMTagCache::Pointer& ) = 0;
 
   /// Short label/name to describe this reader
   void SetConfigurationLabel( const std::string& );
   /// Short label/name to describe this reader
   std::string GetConfigurationLabel() const;
   /// One-sentence description of the reader's loading "strategy"
   void SetConfigurationDescription( const std::string& );
   /// One-sentence description of the reader's loading "strategy"
   std::string GetConfigurationDescription() const;
 
   /// Print configuration description to given stream, for human reader
   void PrintConfiguration( std::ostream& os ) const;
   /// Print output description to given stream, for human reader
   void PrintOutputs( std::ostream& os, bool filenameDetails = false ) const;
 
   virtual bool operator==( const DICOMFileReader& other ) const = 0;
 
   /** Type specifies additional tags of interest. Key is the tag path of interest.
    * The value is an optional user defined name for the property that should be used to store the tag value(s).
    * Empty value is default and will imply to use the found DICOMTagPath as property name.*/
   typedef DICOMImageBlockDescriptor::AdditionalTagsMapType AdditionalTagsMapType;
   /**
   * \brief Set a list of DICOMTagPaths that specify all DICOM-Tags that will be copied into the property of the mitk::Image.
   *
   * This method can be used to specify a list of DICOM-tags that shall be available after the loading.
   * The value in the tagMap is an optional user defined name for the property key that should be used
   * when storing the property). Empty value is default and will imply to use the found DICOMTagPath
   * as property key.
   * By default the content of the DICOM tags will be stored in a StringLookupTable on the mitk::Image.
   * This behaviour can be changed by setting a different TagLookupTableToPropertyFunctor via
   * SetTagLookupTableToPropertyFunctor().
   */
   virtual void SetAdditionalTagsOfInterest(const AdditionalTagsMapType& tagList);
 
   /**
   * \brief Set a functor that defines how the slice-specific tag-values are stored in a Property.
   *
   * This method sets a functor that is given a StringLookupTable that contains the values of one DICOM tag
   * mapped to the slice index.
   * The functor is supposed to store these values in an mitk Property.
   *
   * By default, the StringLookupTable is stored in a StringLookupTableProperty except if all values are
   * identical. In this case, the unique value is stored only once in a StringProperty.
   */
   virtual void SetTagLookupTableToPropertyFunctor(
     mitk::DICOMImageBlockDescriptor::TagLookupTableToPropertyFunctor functor );
 
 protected:
   DICOMFileReader();
   ~DICOMFileReader() override;
 
   DICOMFileReader( const DICOMFileReader& other );
   DICOMFileReader& operator=( const DICOMFileReader& other );
 
   void ClearOutputs();
   void SetNumberOfOutputs( unsigned int numberOfOutputs );
   void SetOutput( unsigned int index, const DICOMImageBlockDescriptor& output );
 
   /// non-const access to the DICOMImageBlockDescriptor
   DICOMImageBlockDescriptor& InternalGetOutput( unsigned int index );
 
   /// Configuration description for human reader, to be implemented by sub-classes
   virtual void InternalPrintConfiguration( std::ostream& os ) const = 0;
 
   virtual AdditionalTagsMapType GetAdditionalTagsOfInterest() const;
 
   mitk::DICOMImageBlockDescriptor::TagLookupTableToPropertyFunctor GetTagLookupTableToPropertyFunctor() const;
 
 
 private:
   StringList m_InputFilenames;
   std::vector<DICOMImageBlockDescriptor> m_Outputs;
 
   std::string m_ConfigLabel;
   std::string m_ConfigDescription;
 
   AdditionalTagsMapType m_AdditionalTagsOfInterest;
   mitk::DICOMImageBlockDescriptor::TagLookupTableToPropertyFunctor m_TagLookupTableToPropertyFunctor;
 };
 }
 
 #endif
diff --git a/Modules/DICOM/src/legacy/mitkDicomSR_GantryTiltInformation.cpp b/Modules/DICOM/src/legacy/mitkDicomSR_GantryTiltInformation.cpp
index 4038c821f0..083f1836ff 100644
--- a/Modules/DICOM/src/legacy/mitkDicomSR_GantryTiltInformation.cpp
+++ b/Modules/DICOM/src/legacy/mitkDicomSR_GantryTiltInformation.cpp
@@ -1,166 +1,166 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <legacy/mitkDicomSeriesReader.h>
 
 namespace mitk
 {
   DicomSeriesReader::GantryTiltInformation::GantryTiltInformation()
     : m_ShiftUp(0.0), m_ShiftRight(0.0), m_ShiftNormal(0.0), m_ITKAssumedSliceSpacing(0.0), m_NumberOfSlicesApart(1)
   {
   }
 
 #define doublepoint(x)                                                                                                 \
   Point3Dd x;                                                                                                          \
   x[0] = x##f[0];                                                                                                      \
   x[1] = x##f[1];                                                                                                      \
   x[2] = x##f[2];
 
 #define doublevector(x)                                                                                                \
   Vector3Dd x;                                                                                                         \
   x[0] = x##f[0];                                                                                                      \
   x[1] = x##f[1];                                                                                                      \
   x[2] = x##f[2];
 
   DicomSeriesReader::GantryTiltInformation::GantryTiltInformation(const Point3D &origin1f,
                                                                   const Point3D &origin2f,
                                                                   const Vector3D &rightf,
                                                                   const Vector3D &upf,
                                                                   unsigned int numberOfSlicesApart)
     : m_ShiftUp(0.0), m_ShiftRight(0.0), m_ShiftNormal(0.0), m_NumberOfSlicesApart(numberOfSlicesApart)
   {
     assert(numberOfSlicesApart);
 
     doublepoint(origin1);
     doublepoint(origin2);
     doublevector(right);
     doublevector(up);
 
     // determine if slice 1 (imagePosition1 and imageOrientation1) and slice 2 can be in one orthogonal slice stack:
     // calculate a line from origin 1, directed along the normal of slice (calculated as the cross product of
     // orientation
     // 1)
     // check if this line passes through origin 2
 
     /*
        Determine if line (imagePosition2 + l * normal) contains imagePosition1.
        Done by calculating the distance of imagePosition1 from line (imagePosition2 + l *normal)
 
-       E.g. http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
+       E.g. https://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
 
        squared distance = | (pointAlongNormal - origin2) x (origin2 - origin1) | ^ 2
        /
        |pointAlongNormal - origin2| ^ 2
 
        ( x meaning the cross product )
     */
 
     Vector3Dd normal = itk::CrossProduct(right, up);
     Point3Dd pointAlongNormal = origin2 + normal;
 
     double numerator = itk::CrossProduct(pointAlongNormal - origin2, origin2 - origin1).GetSquaredNorm();
     double denominator = (pointAlongNormal - origin2).GetSquaredNorm();
 
     double distance = sqrt(numerator / denominator);
 
     if (distance > 0.001) // mitk::eps is too small; 1/1000 of a mm should be enough to detect tilt
     {
       MITK_DEBUG << "  Series seems to contain a tilted (or sheared) geometry";
       MITK_DEBUG << "  Distance of expected slice origin from actual slice origin: " << distance;
       MITK_DEBUG << "    ==> storing this shift for later analysis:";
       MITK_DEBUG << "    v right: " << right;
       MITK_DEBUG << "    v up: " << up;
       MITK_DEBUG << "    v normal: " << normal;
 
       Point3Dd projectionRight = projectPointOnLine(origin1, origin2, right);
       Point3Dd projectionNormal = projectPointOnLine(origin1, origin2, normal);
 
       m_ShiftRight = (projectionRight - origin2).GetNorm();
       m_ShiftNormal = (projectionNormal - origin2).GetNorm();
 
       /*
          now also check to which side the image is shifted.
 
          Calculation e.g. from
-         http://mathworld.wolfram.com/Point-PlaneDistance.html
+         https://mathworld.wolfram.com/Point-PlaneDistance.html
       */
 
       Point3Dd testPoint = origin1;
       Vector3Dd planeNormal = up;
 
       double signedDistance =
         (planeNormal[0] * testPoint[0] + planeNormal[1] * testPoint[1] + planeNormal[2] * testPoint[2] -
          (planeNormal[0] * origin2[0] + planeNormal[1] * origin2[1] + planeNormal[2] * origin2[2])) /
         sqrt(planeNormal[0] * planeNormal[0] + planeNormal[1] * planeNormal[1] + planeNormal[2] * planeNormal[2]);
 
       m_ShiftUp = signedDistance;
 
       m_ITKAssumedSliceSpacing = (origin2 - origin1).GetNorm();
       // How do we now this is assumed? See header documentation for ITK code references
       // double itkAssumedSliceSpacing = sqrt( m_ShiftUp * m_ShiftUp + m_ShiftNormal * m_ShiftNormal );
 
       MITK_DEBUG << "    shift normal: " << m_ShiftNormal;
       MITK_DEBUG << "    shift normal assumed by ITK: " << m_ITKAssumedSliceSpacing;
       MITK_DEBUG << "    shift up: " << m_ShiftUp;
       MITK_DEBUG << "    shift right: " << m_ShiftRight;
 
       MITK_DEBUG << "    tilt angle (deg): " << atan(m_ShiftUp / m_ShiftNormal) * 180.0 / 3.1415926535;
     }
   }
 
   Point3D DicomSeriesReader::GantryTiltInformation::projectPointOnLine(Point3Dd p,
                                                                        Point3Dd lineOrigin,
                                                                        Vector3Dd lineDirection)
   {
     /**
-      See illustration at http://mo.mathematik.uni-stuttgart.de/inhalt/aussage/aussage472/
+      See illustration at https://mo.mathematik.uni-stuttgart.de/inhalt/aussage/aussage472/
 
       vector(lineOrigin,p) = normal * ( innerproduct((p - lineOrigin),normal) / squared-length(normal) )
     */
 
     Vector3Dd lineOriginToP = p - lineOrigin;
     double innerProduct = lineOriginToP * lineDirection;
 
     double factor = innerProduct / lineDirection.GetSquaredNorm();
     Point3Dd projection = lineOrigin + factor * lineDirection;
 
     return projection;
   }
 
   double DicomSeriesReader::GantryTiltInformation::GetTiltCorrectedAdditionalSize() const { return fabs(m_ShiftUp); }
   double DicomSeriesReader::GantryTiltInformation::GetTiltAngleInDegrees() const
   {
     return atan(fabs(m_ShiftUp) / m_ShiftNormal) * 180.0 / 3.1415926535;
   }
 
   double DicomSeriesReader::GantryTiltInformation::GetMatrixCoefficientForCorrectionInWorldCoordinates() const
   {
     // so many mm need to be shifted per slice!
     return m_ShiftUp / static_cast<double>(m_NumberOfSlicesApart);
   }
 
   double DicomSeriesReader::GantryTiltInformation::GetRealZSpacing() const
   {
     return m_ShiftNormal / static_cast<double>(m_NumberOfSlicesApart);
   }
 
   bool DicomSeriesReader::GantryTiltInformation::IsSheared() const
   {
     return (fabs(m_ShiftRight) > 0.001 || fabs(m_ShiftUp) > 0.001);
   }
 
   bool DicomSeriesReader::GantryTiltInformation::IsRegularGantryTilt() const
   {
     return (fabs(m_ShiftRight) < 0.001 && fabs(m_ShiftUp) > 0.001);
   }
 
 } // end namespace mitk
diff --git a/Modules/DICOM/src/legacy/mitkDicomSeriesReader.cpp b/Modules/DICOM/src/legacy/mitkDicomSeriesReader.cpp
index 738a0bf028..15c880a52c 100644
--- a/Modules/DICOM/src/legacy/mitkDicomSeriesReader.cpp
+++ b/Modules/DICOM/src/legacy/mitkDicomSeriesReader.cpp
@@ -1,1860 +1,1860 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // uncomment for learning more about the internal sorting mechanisms
 //#define MBILOG_ENABLE_DEBUG
 
 #include <legacy/mitkDicomSeriesReader.h>
 #include <mitkImage.h>
 #include <mitkImageCast.h>
 #include <mitkLocaleSwitch.h>
 
 #include <itkGDCMSeriesFileNames.h>
 
 #include <gdcmAttribute.h>
 #include <gdcmDirectory.h>
 #include <gdcmPixmapReader.h>
 #include <gdcmRAWCodec.h>
 #include <gdcmScanner.h>
 #include <gdcmSorter.h>
 #include <gdcmStringFilter.h>
 #include <gdcmUIDs.h>
 
 #include "mitkProperties.h"
 
 namespace mitk
 {
   std::string DicomSeriesReader::ReaderImplementationLevelToString(const ReaderImplementationLevel &enumValue)
   {
     switch (enumValue)
     {
       case ReaderImplementationLevel_Supported:
         return "Supported";
       case ReaderImplementationLevel_PartlySupported:
         return "PartlySupported";
       case ReaderImplementationLevel_Implemented:
         return "Implemented";
       case ReaderImplementationLevel_Unsupported:
         return "Unsupported";
       default:
         return "<unknown value of enum ReaderImplementationLevel>";
     };
   }
 
   std::string DicomSeriesReader::PixelSpacingInterpretationToString(const PixelSpacingInterpretation &enumValue)
   {
     switch (enumValue)
     {
       case PixelSpacingInterpretation_SpacingInPatient:
         return "In Patient";
       case PixelSpacingInterpretation_SpacingAtDetector:
         return "At Detector";
       case PixelSpacingInterpretation_SpacingUnknown:
         return "Unknown spacing";
       default:
         return "<unknown value of enum PixelSpacingInterpretation>";
     };
   }
 
   const DicomSeriesReader::TagToPropertyMapType &DicomSeriesReader::GetDICOMTagsToMITKPropertyMap()
   {
     static bool initialized = false;
     static TagToPropertyMapType dictionary;
     if (!initialized)
     {
       /*
          Selection criteria:
          - no sequences because we cannot represent that
          - nothing animal related (specified, breed registration number), MITK focuses on human medical image processing.
          - only general attributes so far
 
          When extending this, we should make use of a real dictionary (GDCM/DCMTK and lookup the tag names there)
       */
 
       // Patient module
       dictionary["0010|0010"] = "dicom.patient.PatientsName";
       dictionary["0010|0020"] = "dicom.patient.PatientID";
       dictionary["0010|0030"] = "dicom.patient.PatientsBirthDate";
       dictionary["0010|0040"] = "dicom.patient.PatientsSex";
       dictionary["0010|0032"] = "dicom.patient.PatientsBirthTime";
       dictionary["0010|1000"] = "dicom.patient.OtherPatientIDs";
       dictionary["0010|1001"] = "dicom.patient.OtherPatientNames";
       dictionary["0010|2160"] = "dicom.patient.EthnicGroup";
       dictionary["0010|4000"] = "dicom.patient.PatientComments";
       dictionary["0012|0062"] = "dicom.patient.PatientIdentityRemoved";
       dictionary["0012|0063"] = "dicom.patient.DeIdentificationMethod";
 
       // General Study module
       dictionary["0020|000d"] = "dicom.study.StudyInstanceUID";
       dictionary["0008|0020"] = "dicom.study.StudyDate";
       dictionary["0008|0030"] = "dicom.study.StudyTime";
       dictionary["0008|0090"] = "dicom.study.ReferringPhysiciansName";
       dictionary["0020|0010"] = "dicom.study.StudyID";
       dictionary["0008|0050"] = "dicom.study.AccessionNumber";
       dictionary["0008|1030"] = "dicom.study.StudyDescription";
       dictionary["0008|1048"] = "dicom.study.PhysiciansOfRecord";
       dictionary["0008|1060"] = "dicom.study.NameOfPhysicianReadingStudy";
 
       // General Series module
       dictionary["0008|0060"] = "dicom.series.Modality";
       dictionary["0020|000e"] = "dicom.series.SeriesInstanceUID";
       dictionary["0020|0011"] = "dicom.series.SeriesNumber";
       dictionary["0020|0060"] = "dicom.series.Laterality";
       dictionary["0008|0021"] = "dicom.series.SeriesDate";
       dictionary["0008|0031"] = "dicom.series.SeriesTime";
       dictionary["0008|1050"] = "dicom.series.PerformingPhysiciansName";
       dictionary["0018|1030"] = "dicom.series.ProtocolName";
       dictionary["0008|103e"] = "dicom.series.SeriesDescription";
       dictionary["0008|1070"] = "dicom.series.OperatorsName";
       dictionary["0018|0015"] = "dicom.series.BodyPartExamined";
       dictionary["0018|5100"] = "dicom.series.PatientPosition";
       dictionary["0028|0108"] = "dicom.series.SmallestPixelValueInSeries";
       dictionary["0028|0109"] = "dicom.series.LargestPixelValueInSeries";
 
       // VOI LUT module
       dictionary["0028|1050"] = "dicom.voilut.WindowCenter";
       dictionary["0028|1051"] = "dicom.voilut.WindowWidth";
       dictionary["0028|1055"] = "dicom.voilut.WindowCenterAndWidthExplanation";
 
       // Image Pixel module
       dictionary["0028|0004"] = "dicom.pixel.PhotometricInterpretation";
       dictionary["0028|0010"] = "dicom.pixel.Rows";
       dictionary["0028|0011"] = "dicom.pixel.Columns";
 
       // Image Plane module
       dictionary["0028|0030"] = "dicom.PixelSpacing";
       dictionary["0018|1164"] = "dicom.ImagerPixelSpacing";
 
       // Misc
       dictionary["0008|0005"] = "dicom.SpecificCharacterSet";
 
       initialized = true;
     }
 
     return dictionary;
   }
 
   DataNode::Pointer DicomSeriesReader::LoadDicomSeries(const StringContainer &filenames,
                                                        bool sort,
                                                        bool check_4d,
                                                        bool correctTilt,
                                                        UpdateCallBackMethod callback,
                                                        Image::Pointer preLoadedImageBlock)
   {
     DataNode::Pointer node = DataNode::New();
 
     if (DicomSeriesReader::LoadDicomSeries(
           filenames, *node, sort, check_4d, correctTilt, callback, preLoadedImageBlock))
     {
       if (filenames.empty())
       {
         return nullptr;
       }
 
       return node;
     }
     else
     {
       return nullptr;
     }
   }
 
   bool DicomSeriesReader::LoadDicomSeries(const StringContainer &filenames,
                                           DataNode &node,
                                           bool sort,
                                           bool check_4d,
                                           bool correctTilt,
                                           UpdateCallBackMethod callback,
                                           itk::SmartPointer<Image> preLoadedImageBlock)
   {
     if (filenames.empty())
     {
       MITK_DEBUG << "Calling LoadDicomSeries with empty filename string container. Probably invalid application logic.";
       node.SetData(nullptr);
       return true; // this is not actually an error but the result is very simple
     }
 
     DcmIoType::Pointer io = DcmIoType::New();
 
     try
     {
       if (io->CanReadFile(filenames.front().c_str()))
       {
         io->SetFileName(filenames.front().c_str());
         io->ReadImageInformation();
 
         if (io->GetPixelType() == itk::IOPixelEnum::SCALAR || io->GetPixelType() == itk::IOPixelEnum::RGB)
         {
           LoadDicom(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
         }
 
         if (node.GetData())
         {
           return true;
         }
       }
     }
     catch ( const itk::MemoryAllocationError &e )
     {
       MITK_ERROR << "Out of memory. Cannot load DICOM series: " << e.what();
     }
     catch ( const std::exception &e )
     {
       MITK_ERROR << "Error encountered when loading DICOM series:" << e.what();
     }
     catch (...)
     {
       MITK_ERROR << "Unspecified error encountered when loading DICOM series.";
     }
 
     return false;
   }
 
   bool DicomSeriesReader::IsDicom(const std::string &filename)
   {
     DcmIoType::Pointer io = DcmIoType::New();
 
     return io->CanReadFile(filename.c_str());
   }
 
   bool DicomSeriesReader::IsPhilips3DDicom(const std::string &filename)
   {
     DcmIoType::Pointer io = DcmIoType::New();
 
     if (io->CanReadFile(filename.c_str()))
     {
       // Look at header Tag 3001,0010 if it is "Philips3D"
       gdcm::Reader reader;
       reader.SetFileName(filename.c_str());
       reader.Read();
       gdcm::DataSet &data_set = reader.GetFile().GetDataSet();
       gdcm::StringFilter sf;
       sf.SetFile(reader.GetFile());
 
       if (data_set.FindDataElement(gdcm::Tag(0x3001, 0x0010)) &&
           (sf.ToString(gdcm::Tag(0x3001, 0x0010)) == "Philips3D "))
       {
         return true;
       }
     }
     return false;
   }
 
   bool DicomSeriesReader::ReadPhilips3DDicom(const std::string &filename, itk::SmartPointer<Image> output_image)
   {
     // Now get PhilipsSpecific Tags
 
     gdcm::PixmapReader reader;
     reader.SetFileName(filename.c_str());
     reader.Read();
     gdcm::DataSet &data_set = reader.GetFile().GetDataSet();
     gdcm::StringFilter sf;
     sf.SetFile(reader.GetFile());
 
     gdcm::Attribute<0x0028, 0x0011> dimTagX;   // columns || sagittal
     gdcm::Attribute<0x3001, 0x1001, gdcm::VR::UL, gdcm::VM::VM1>
       dimTagZ;                                 // I have no idea what is VM1. // (Philips specific) // axial
     gdcm::Attribute<0x0028, 0x0010> dimTagY;   // rows || coronal
     gdcm::Attribute<0x0028, 0x0008> dimTagT;   // how many frames
     gdcm::Attribute<0x0018, 0x602c> spaceTagX; // Spacing in X , unit is "physicalTagx" (usually centimeter)
     gdcm::Attribute<0x0018, 0x602e> spaceTagY;
     gdcm::Attribute<0x3001, 0x1003, gdcm::VR::FD, gdcm::VM::VM1> spaceTagZ; // (Philips specific)
     gdcm::Attribute<0x0018, 0x6024> physicalTagX;                           // if 3, then spacing params are centimeter
     gdcm::Attribute<0x0018, 0x6026> physicalTagY;
     gdcm::Attribute<0x3001, 0x1002, gdcm::VR::US, gdcm::VM::VM1> physicalTagZ; // (Philips specific)
 
     dimTagX.Set(data_set);
     dimTagY.Set(data_set);
     dimTagZ.Set(data_set);
     dimTagT.Set(data_set);
     spaceTagX.Set(data_set);
     spaceTagY.Set(data_set);
     spaceTagZ.Set(data_set);
     physicalTagX.Set(data_set);
     physicalTagY.Set(data_set);
     physicalTagZ.Set(data_set);
 
     unsigned int dimX = dimTagX.GetValue(), dimY = dimTagY.GetValue(), dimZ = dimTagZ.GetValue(),
                  dimT = dimTagT.GetValue(), physicalX = physicalTagX.GetValue(), physicalY = physicalTagY.GetValue(),
                  physicalZ = physicalTagZ.GetValue();
 
     float spaceX = spaceTagX.GetValue(), spaceY = spaceTagY.GetValue(), spaceZ = spaceTagZ.GetValue();
 
     if (physicalX == 3) // spacing parameter in cm, have to convert it to mm.
       spaceX = spaceX * 10;
 
     if (physicalY == 3) // spacing parameter in cm, have to convert it to mm.
       spaceY = spaceY * 10;
 
     if (physicalZ == 3) // spacing parameter in cm, have to convert it to mm.
       spaceZ = spaceZ * 10;
 
     // Ok, got all necessary Tags!
     // Now read Pixeldata (7fe0,0010) X x Y x Z x T Elements
 
     const gdcm::Pixmap &pixels = reader.GetPixmap();
     gdcm::RAWCodec codec;
 
     codec.SetPhotometricInterpretation(gdcm::PhotometricInterpretation::MONOCHROME2);
     codec.SetPixelFormat(pixels.GetPixelFormat());
     codec.SetPlanarConfiguration(0);
 
     gdcm::DataElement out;
     codec.Decode(data_set.GetDataElement(gdcm::Tag(0x7fe0, 0x0010)), out);
 
     const gdcm::ByteValue *bv = out.GetByteValue();
     const char *new_pixels = bv->GetPointer();
 
     // Create MITK Image + Geometry
     typedef itk::Image<unsigned char, 4>
       ImageType; // Pixeltype might be different sometimes? Maybe read it out from header
     ImageType::RegionType myRegion;
     ImageType::SizeType mySize;
     ImageType::IndexType myIndex;
     ImageType::SpacingType mySpacing;
     ImageType::Pointer imageItk = ImageType::New();
 
     mySpacing[0] = spaceX;
     mySpacing[1] = spaceY;
     mySpacing[2] = spaceZ;
     mySpacing[3] = 1;
     myIndex[0] = 0;
     myIndex[1] = 0;
     myIndex[2] = 0;
     myIndex[3] = 0;
     mySize[0] = dimX;
     mySize[1] = dimY;
     mySize[2] = dimZ;
     mySize[3] = dimT;
     myRegion.SetSize(mySize);
     myRegion.SetIndex(myIndex);
     imageItk->SetSpacing(mySpacing);
     imageItk->SetRegions(myRegion);
     imageItk->Allocate();
     imageItk->FillBuffer(0);
 
     itk::ImageRegionIterator<ImageType> iterator(imageItk, imageItk->GetLargestPossibleRegion());
     iterator.GoToBegin();
     unsigned long pixCount = 0;
     unsigned long planeSize = dimX * dimY;
     unsigned long planeCount = 0;
     unsigned long timeCount = 0;
     unsigned long numberOfSlices = dimZ;
 
     while (!iterator.IsAtEnd())
     {
       unsigned long addressedPixel =
         pixCount +
         (numberOfSlices - 1 - planeCount) * planeSize // add offset to address the first pixel of current plane
         + timeCount * numberOfSlices * planeSize;     // add time offset
 
       iterator.Set(new_pixels[addressedPixel]);
       pixCount++;
       ++iterator;
 
       if (pixCount == planeSize)
       {
         pixCount = 0;
         planeCount++;
       }
       if (planeCount == numberOfSlices)
       {
         planeCount = 0;
         timeCount++;
       }
       if (timeCount == dimT)
       {
         break;
       }
     }
     mitk::CastToMitkImage(imageItk, output_image);
     return true; // actually never returns false yet.. but exception possible
   }
 
   std::string DicomSeriesReader::ConstCharStarToString(const char *s) { return s ? std::string(s) : std::string(); }
   bool DicomSeriesReader::DICOMStringToSpacing(const std::string &s, ScalarType &spacingX, ScalarType &spacingY)
   {
     bool successful = false;
 
     std::istringstream spacingReader(s);
     std::string spacing;
     if (std::getline(spacingReader, spacing, '\\'))
     {
       spacingY = atof(spacing.c_str());
 
       if (std::getline(spacingReader, spacing, '\\'))
       {
         spacingX = atof(spacing.c_str());
 
         successful = true;
       }
     }
 
     return successful;
   }
 
   Point3D DicomSeriesReader::DICOMStringToPoint3D(const std::string &s, bool &successful)
   {
     Point3D p;
     successful = true;
 
     std::istringstream originReader(s);
     std::string coordinate;
     unsigned int dim(0);
     while (std::getline(originReader, coordinate, '\\') && dim < 3)
     {
       p[dim++] = atof(coordinate.c_str());
     }
 
     if (dim && dim != 3)
     {
       successful = false;
       MITK_ERROR << "Reader implementation made wrong assumption on tag (0020,0032). Found " << dim
                  << " instead of 3 values.";
     }
     else if (dim == 0)
     {
       successful = false;
       p.Fill(0.0); // assume default (0,0,0)
     }
 
     return p;
   }
 
   void DicomSeriesReader::DICOMStringToOrientationVectors(const std::string &s,
                                                           Vector3D &right,
                                                           Vector3D &up,
                                                           bool &successful)
   {
     successful = true;
 
     std::istringstream orientationReader(s);
     std::string coordinate;
     unsigned int dim(0);
     while (std::getline(orientationReader, coordinate, '\\') && dim < 6)
     {
       if (dim < 3)
       {
         right[dim++] = atof(coordinate.c_str());
       }
       else
       {
         up[dim++ - 3] = atof(coordinate.c_str());
       }
     }
 
     if (dim && dim != 6)
     {
       successful = false;
       MITK_ERROR << "Reader implementation made wrong assumption on tag (0020,0037). Found " << dim
                  << " instead of 6 values.";
     }
     else if (dim == 0)
     {
       // fill with defaults
       right.Fill(0.0);
       right[0] = 1.0;
 
       up.Fill(0.0);
       up[1] = 1.0;
 
       successful = false;
     }
   }
 
   DicomSeriesReader::SliceGroupingAnalysisResult DicomSeriesReader::AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
     const StringContainer &files, bool groupImagesWithGantryTilt, const gdcm::Scanner::MappingType &tagValueMappings_)
   {
     // result.first = files that fit ITK's assumption
     // result.second = files that do not fit, should be run through
     // AnalyzeFileForITKImageSeriesReaderSpacingAssumption()
     // again
     SliceGroupingAnalysisResult result;
 
     // we const_cast here, because I could not use a map.at(), which would make the code much more readable
     auto &tagValueMappings = const_cast<gdcm::Scanner::MappingType &>(tagValueMappings_);
     const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image Position (Patient)
     const gdcm::Tag tagImageOrientation(0x0020, 0x0037);     // Image Orientation
     const gdcm::Tag tagGantryTilt(0x0018, 0x1120);           // gantry tilt
 
     Vector3D fromFirstToSecondOrigin;
     fromFirstToSecondOrigin.Fill(0.0);
     bool fromFirstToSecondOriginInitialized(false);
     Point3D thisOrigin;
     thisOrigin.Fill(0.0f);
     Point3D lastOrigin;
     lastOrigin.Fill(0.0f);
     Point3D lastDifferentOrigin;
     lastDifferentOrigin.Fill(0.0f);
 
     bool lastOriginInitialized(false);
 
     MITK_DEBUG << "--------------------------------------------------------------------------------";
     MITK_DEBUG << "Analyzing files for z-spacing assumption of ITK's ImageSeriesReader (group tilted: "
                << groupImagesWithGantryTilt << ")";
     unsigned int fileIndex(0);
     for (auto fileIter = files.begin(); fileIter != files.end(); ++fileIter, ++fileIndex)
     {
       bool fileFitsIntoPattern(false);
       std::string thisOriginString;
       // Read tag value into point3D. PLEASE replace this by appropriate GDCM code if you figure out how to do that
       thisOriginString = ConstCharStarToString(tagValueMappings[fileIter->c_str()][tagImagePositionPatient]);
 
       if (thisOriginString.empty())
       {
         // don't let such files be in a common group. Everything without position information will be loaded as a single
         // slice:
         // with standard DICOM files this can happen to: CR, DX, SC
         MITK_DEBUG << "    ==> Sort away " << *fileIter
                    << " for later analysis (no position information)"; // we already have one occupying this position
 
         if (result.GetBlockFilenames().empty()) // nothing WITH position information yet
         {
           // ==> this is a group of its own, stop processing, come back later
           result.AddFileToSortedBlock(*fileIter);
 
           StringContainer remainingFiles;
           remainingFiles.insert(remainingFiles.end(), fileIter + 1, files.end());
           result.AddFilesToUnsortedBlock(remainingFiles);
 
           fileFitsIntoPattern = false;
           break; // no files anymore
         }
         else
         {
           // ==> this does not match, consider later
           result.AddFileToUnsortedBlock(*fileIter);
           fileFitsIntoPattern = false;
           continue; // next file
         }
       }
 
       bool ignoredConversionError(-42); // hard to get here, no graceful way to react
       thisOrigin = DICOMStringToPoint3D(thisOriginString, ignoredConversionError);
 
       MITK_DEBUG << "  " << fileIndex << " " << *fileIter << " at "
                  /* << thisOriginString */
                  << "(" << thisOrigin[0] << "," << thisOrigin[1] << "," << thisOrigin[2] << ")";
 
       if (lastOriginInitialized && (thisOrigin == lastOrigin))
       {
         MITK_DEBUG << "    ==> Sort away " << *fileIter
                    << " for separate time step"; // we already have one occupying this position
         result.AddFileToUnsortedBlock(*fileIter);
         fileFitsIntoPattern = false;
       }
       else
       {
         if (!fromFirstToSecondOriginInitialized &&
             lastOriginInitialized) // calculate vector as soon as possible when we get a new position
         {
           fromFirstToSecondOrigin = thisOrigin - lastDifferentOrigin;
           fromFirstToSecondOriginInitialized = true;
 
           // Here we calculate if this slice and the previous one are well aligned,
           // i.e. we test if the previous origin is on a line through the current
           // origin, directed into the normal direction of the current slice.
 
           // If this is NOT the case, then we have a data set with a TILTED GANTRY geometry,
           // which cannot be simply loaded into a single mitk::Image at the moment.
           // For this case, we flag this finding in the result and DicomSeriesReader
           // can correct for that later.
 
           Vector3D right;
           right.Fill(0.0);
           Vector3D up;
           right.Fill(0.0); // might be down as well, but it is just a name at this point
           DICOMStringToOrientationVectors(
             tagValueMappings[fileIter->c_str()][tagImageOrientation], right, up, ignoredConversionError);
 
           GantryTiltInformation tiltInfo(lastDifferentOrigin, thisOrigin, right, up, 1);
 
           if (tiltInfo.IsSheared()) // mitk::eps is too small; 1/1000 of a mm should be enough to detect tilt
           {
             /* optimistic approach, accepting gantry tilt: save file for later, check all further files */
 
             // at this point we have TWO slices analyzed! if they are the only two files, we still split, because there
             // is
             // no third to verify our tilting assumption.
             // later with a third being available, we must check if the initial tilting vector is still valid. if yes,
             // continue.
             // if NO, we need to split the already sorted part (result.first) and the currently analyzed file
             // (*fileIter)
 
             // tell apart gantry tilt from overall skewedness
             // sort out irregularly sheared slices, that IS NOT tilting
 
             if (groupImagesWithGantryTilt && tiltInfo.IsRegularGantryTilt())
             {
               // check if this is at least roughly the same angle as recorded in DICOM tags
               if (tagValueMappings[fileIter->c_str()].find(tagGantryTilt) != tagValueMappings[fileIter->c_str()].end())
               {
                 // read value, compare to calculated angle
                 std::string tiltStr = ConstCharStarToString(tagValueMappings[fileIter->c_str()][tagGantryTilt]);
                 double angle = atof(tiltStr.c_str());
 
                 MITK_DEBUG << "Comparing recorded tilt angle " << angle << " against calculated value "
                            << tiltInfo.GetTiltAngleInDegrees();
                 // TODO we probably want the signs correct, too (that depends: this is just a rough check, nothing
                 // serious)
                 // TODO TODO TODO when angle -27 and tiltangle 63, this will never trigger the if-clause... useless
                 // check
                 // in this case! old bug..?!
                 if (fabs(angle) - tiltInfo.GetTiltAngleInDegrees() > 0.25)
                 {
                   result.AddFileToUnsortedBlock(*fileIter); // sort away for further analysis
                   fileFitsIntoPattern = false;
                 }
                 else // tilt angle from header is less than 0.25 degrees different from what we calculated, assume this
                      // is
                      // fine
                 {
                   result.FlagGantryTilt();
                   result.AddFileToSortedBlock(*fileIter); // this file is good for current block
                   fileFitsIntoPattern = true;
                 }
               }
               else // we cannot check the calculated tilt angle against the one from the dicom header (so we assume we
                    // are
                    // right)
               {
                 result.FlagGantryTilt();
                 result.AddFileToSortedBlock(*fileIter); // this file is good for current block
                 fileFitsIntoPattern = true;
               }
             }
             else // caller does not want tilt compensation OR shearing is more complicated than tilt
             {
               result.AddFileToUnsortedBlock(*fileIter); // sort away for further analysis
               fileFitsIntoPattern = false;
             }
           }
           else // not sheared
           {
             result.AddFileToSortedBlock(*fileIter); // this file is good for current block
             fileFitsIntoPattern = true;
           }
         }
         else if (fromFirstToSecondOriginInitialized) // we already know the offset between slices
         {
           Point3D assumedOrigin = lastDifferentOrigin + fromFirstToSecondOrigin;
 
           Vector3D originError = assumedOrigin - thisOrigin;
           double norm = originError.GetNorm();
           double toleratedError(0.005); // max. 1/10mm error when measurement crosses 20 slices in z direction
 
           if (norm > toleratedError)
           {
             MITK_DEBUG << "  File does not fit into the inter-slice distance pattern (diff = " << norm << ", allowed "
                        << toleratedError << ").";
             MITK_DEBUG << "  Expected position (" << assumedOrigin[0] << "," << assumedOrigin[1] << ","
                        << assumedOrigin[2] << "), got position (" << thisOrigin[0] << "," << thisOrigin[1] << ","
                        << thisOrigin[2] << ")";
             MITK_DEBUG << "    ==> Sort away " << *fileIter << " for later analysis";
 
             // At this point we know we deviated from the expectation of ITK's ImageSeriesReader
             // We split the input file list at this point, i.e. all files up to this one (excluding it)
             // are returned as group 1, the remaining files (including the faulty one) are group 2
 
             /* Optimistic approach: check if any of the remaining slices fits in */
             result.AddFileToUnsortedBlock(*fileIter); // sort away for further analysis
             fileFitsIntoPattern = false;
           }
           else
           {
             result.AddFileToSortedBlock(*fileIter); // this file is good for current block
             fileFitsIntoPattern = true;
           }
         }
         else // this should be the very first slice
         {
           result.AddFileToSortedBlock(*fileIter); // this file is good for current block
           fileFitsIntoPattern = true;
         }
       }
 
       // record current origin for reference in later iterations
       if (!lastOriginInitialized || (fileFitsIntoPattern && (thisOrigin != lastOrigin)))
       {
         lastDifferentOrigin = thisOrigin;
       }
 
       lastOrigin = thisOrigin;
       lastOriginInitialized = true;
     }
 
     if (result.ContainsGantryTilt())
     {
       // check here how many files were grouped.
       // IF it was only two files AND we assume tiltedness (e.g. save "distance")
       // THEN we would want to also split the two previous files (simple) because
       // we don't have any reason to assume they belong together
 
       if (result.GetBlockFilenames().size() == 2)
       {
         result.UndoPrematureGrouping();
       }
     }
 
     return result;
   }
 
   DicomSeriesReader::FileNamesGrouping DicomSeriesReader::GetSeries(const StringContainer &files,
                                                                     bool groupImagesWithGantryTilt,
                                                                     const StringContainer &restrictions)
   {
     return GetSeries(files, true, groupImagesWithGantryTilt, restrictions);
   }
 
   DicomSeriesReader::FileNamesGrouping DicomSeriesReader::GetSeries(const StringContainer &files,
                                                                     bool sortTo3DPlust,
                                                                     bool groupImagesWithGantryTilt,
                                                                     const StringContainer & /*restrictions*/)
   {
     /**
       assumption about this method:
         returns a map of uid-like-key --> list(filename)
         each entry should contain filenames that have images of same
           - series instance uid (automatically done by GDCMSeriesFileNames
           - 0020,0037 image orientation (patient)
           - 0028,0030 pixel spacing (x,y)
           - 0018,0050 slice thickness
     */
 
     // use GDCM directly, itk::GDCMSeriesFileNames does not work with GDCM 2
 
     // PART I: scan files for sorting relevant DICOM tags,
     //         separate images that differ in any of those
     //         attributes (they cannot possibly form a 3D block)
 
     // scan for relevant tags in dicom files
     gdcm::Scanner scanner;
     const gdcm::Tag tagSOPClassUID(0x0008, 0x0016); // SOP class UID
     scanner.AddTag(tagSOPClassUID);
 
     const gdcm::Tag tagSeriesInstanceUID(0x0020, 0x000e); // Series Instance UID
     scanner.AddTag(tagSeriesInstanceUID);
 
     const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // image orientation
     scanner.AddTag(tagImageOrientation);
 
     const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // pixel spacing
     scanner.AddTag(tagPixelSpacing);
 
     const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164); // imager pixel spacing
     scanner.AddTag(tagImagerPixelSpacing);
 
     const gdcm::Tag tagSliceThickness(0x0018, 0x0050); // slice thickness
     scanner.AddTag(tagSliceThickness);
 
     const gdcm::Tag tagNumberOfRows(0x0028, 0x0010); // number rows
     scanner.AddTag(tagNumberOfRows);
 
     const gdcm::Tag tagNumberOfColumns(0x0028, 0x0011); // number cols
     scanner.AddTag(tagNumberOfColumns);
 
     const gdcm::Tag tagGantryTilt(0x0018, 0x1120); // gantry tilt
     scanner.AddTag(tagGantryTilt);
 
     const gdcm::Tag tagModality(0x0008, 0x0060); // modality
     scanner.AddTag(tagModality);
 
     const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008); // number of frames
     scanner.AddTag(tagNumberOfFrames);
 
     // additional tags read in this scan to allow later analysis
     // THESE tag are not used for initial separating of files
     const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image Position (Patient)
     scanner.AddTag(tagImagePositionPatient);
 
     // TODO add further restrictions from arguments (when anybody asks for it)
 
     FileNamesGrouping result;
 
     // let GDCM scan files
     if (!scanner.Scan(files))
     {
       MITK_ERROR << "gdcm::Scanner failed when scanning " << files.size() << " input files.";
       return result;
     }
 
     // assign files IDs that will separate them for loading into image blocks
     for (auto fileIter = scanner.Begin(); fileIter != scanner.End(); ++fileIter)
     {
       if (std::string(fileIter->first).empty())
         continue; // TODO understand why Scanner has empty string entries
       if (std::string(fileIter->first) == std::string("DICOMDIR"))
         continue;
 
       /* sort out multi-frame
       if ( scanner.GetValue( fileIter->first , tagNumberOfFrames ) )
       {
         MITK_INFO << "Ignoring " << fileIter->first << " because we cannot handle multi-frame images.";
         continue;
       }
       */
 
       // we const_cast here, because I could not use a map.at() function in CreateMoreUniqueSeriesIdentifier.
       // doing the same thing with find would make the code less readable. Since we forget the Scanner results
       // anyway after this function, we can simply tolerate empty map entries introduced by bad operator[] access
       std::string moreUniqueSeriesId =
         CreateMoreUniqueSeriesIdentifier(const_cast<gdcm::Scanner::TagToValue &>(fileIter->second));
       result[moreUniqueSeriesId].AddFile(fileIter->first);
     }
 
     // PART II: sort slices spatially (or at least consistently if this is NOT possible, see method)
 
     for (FileNamesGrouping::const_iterator groupIter = result.begin(); groupIter != result.end(); ++groupIter)
     {
       try
       {
         result[groupIter->first] =
           ImageBlockDescriptor(SortSeriesSlices(groupIter->second.GetFilenames())); // sort each slice group spatially
       }
       catch (...)
       {
         MITK_ERROR << "Caught something.";
       }
     }
 
     // PART III: analyze pre-sorted images for valid blocks (i.e. blocks of equal z-spacing),
     //          separate into multiple blocks if necessary.
     //
     //          Analysis performs the following steps:
     //            * imitate itk::ImageSeriesReader: use the distance between the first two images as z-spacing
     //            * check what images actually fulfill ITK's z-spacing assumption
     //            * separate all images that fail the test into new blocks, re-iterate analysis for these blocks
     //              * this includes images which DO NOT PROVIDE spatial information, i.e. all images w/o
     //              ImagePositionPatient will be loaded separately
 
     FileNamesGrouping groupsOf3DPlusTBlocks; // final result of this function
     for (FileNamesGrouping::const_iterator groupIter = result.begin(); groupIter != result.end(); ++groupIter)
     {
       FileNamesGrouping groupsOf3DBlocks; // intermediate result for only this group(!)
       StringContainer filesStillToAnalyze = groupIter->second.GetFilenames();
       std::string groupUID = groupIter->first;
       unsigned int subgroup(0);
       MITK_DEBUG << "Analyze group " << groupUID << " of " << groupIter->second.GetFilenames().size() << " files";
 
       while (!filesStillToAnalyze.empty()) // repeat until all files are grouped somehow
       {
         SliceGroupingAnalysisResult analysisResult = AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
           filesStillToAnalyze, groupImagesWithGantryTilt, scanner.GetMappings());
 
         // enhance the UID for additional groups
         std::stringstream newGroupUID;
         newGroupUID << groupUID << '.' << subgroup;
 
         ImageBlockDescriptor thisBlock(analysisResult.GetBlockFilenames());
 
         std::string firstFileInBlock = thisBlock.GetFilenames().front();
 
         thisBlock.SetImageBlockUID(newGroupUID.str());
         thisBlock.SetSeriesInstanceUID(
           DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagSeriesInstanceUID)));
         thisBlock.SetHasGantryTiltCorrected(analysisResult.ContainsGantryTilt());
         thisBlock.SetSOPClassUID(
           DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagSOPClassUID)));
         thisBlock.SetNumberOfFrames(
           ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagNumberOfFrames)));
         thisBlock.SetModality(
           DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagModality)));
         thisBlock.SetPixelSpacingInformation(
           DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagPixelSpacing)),
           DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagImagerPixelSpacing)));
         thisBlock.SetHasMultipleTimePoints(false);
 
         groupsOf3DBlocks[newGroupUID.str()] = thisBlock;
 
         // MITK_DEBUG << "Result: sorted 3D group " << newGroupUID.str() << " with " << groupsOf3DBlocks[
         // newGroupUID.str() ].GetFilenames().size() << " files";
         MITK_DEBUG << "Result: sorted 3D group with " << groupsOf3DBlocks[newGroupUID.str()].GetFilenames().size()
                    << " files";
         StringContainer debugOutputFiles = analysisResult.GetBlockFilenames();
         for (StringContainer::const_iterator siter = debugOutputFiles.begin(); siter != debugOutputFiles.end(); ++siter)
           MITK_DEBUG << "  IN  " << *siter;
 
         ++subgroup;
 
         filesStillToAnalyze = analysisResult.GetUnsortedFilenames(); // remember what needs further analysis
         for (StringContainer::const_iterator siter = filesStillToAnalyze.begin(); siter != filesStillToAnalyze.end();
              ++siter)
           MITK_DEBUG << " OUT  " << *siter;
       }
 
       // end of grouping, now post-process groups
 
       // PART IV: attempt to group blocks to 3D+t blocks if requested
       //           inspect entries of groupsOf3DBlocks
       //            - if number of files is identical to previous entry, collect for 3D+t block
       //            - as soon as number of files changes from previous entry, record collected blocks as 3D+t block,
       //            start
       //            a new one, continue
 
       // decide whether or not to group 3D blocks into 3D+t blocks where possible
       if (!sortTo3DPlust)
       {
         // copy 3D blocks to output
         groupsOf3DPlusTBlocks.insert(groupsOf3DBlocks.begin(), groupsOf3DBlocks.end());
       }
       else
       {
         // sort 3D+t (as described in "PART IV")
 
         MITK_DEBUG << "================================================================================";
         MITK_DEBUG << "3D+t analysis:";
 
         unsigned int numberOfFilesInPreviousBlock(0);
         std::string previousBlockKey;
 
         for (FileNamesGrouping::const_iterator block3DIter = groupsOf3DBlocks.begin();
              block3DIter != groupsOf3DBlocks.end();
              ++block3DIter)
         {
           unsigned int numberOfFilesInThisBlock = block3DIter->second.GetFilenames().size();
           std::string thisBlockKey = block3DIter->first;
 
           if (numberOfFilesInPreviousBlock == 0)
           {
             numberOfFilesInPreviousBlock = numberOfFilesInThisBlock;
             groupsOf3DPlusTBlocks[thisBlockKey] = block3DIter->second;
             MITK_DEBUG << "  3D+t group " << thisBlockKey;
             previousBlockKey = thisBlockKey;
           }
           else
           {
             bool identicalOrigins;
             try
             {
               // check whether this and the previous block share a common origin
               // TODO should be safe, but a little try/catch or other error handling wouldn't hurt
 
               const char *origin_value = scanner.GetValue(groupsOf3DBlocks[thisBlockKey].GetFilenames().front().c_str(),
                                                           tagImagePositionPatient),
                          *previous_origin_value = scanner.GetValue(
                            groupsOf3DBlocks[previousBlockKey].GetFilenames().front().c_str(), tagImagePositionPatient),
                          *destination_value = scanner.GetValue(
                            groupsOf3DBlocks[thisBlockKey].GetFilenames().back().c_str(), tagImagePositionPatient),
                          *previous_destination_value = scanner.GetValue(
                            groupsOf3DBlocks[previousBlockKey].GetFilenames().back().c_str(), tagImagePositionPatient);
 
               if (!origin_value || !previous_origin_value || !destination_value || !previous_destination_value)
               {
                 identicalOrigins = false;
               }
               else
               {
                 std::string thisOriginString = ConstCharStarToString(origin_value);
                 std::string previousOriginString = ConstCharStarToString(previous_origin_value);
 
                 // also compare last origin, because this might differ if z-spacing is different
                 std::string thisDestinationString = ConstCharStarToString(destination_value);
                 std::string previousDestinationString = ConstCharStarToString(previous_destination_value);
 
                 identicalOrigins =
                   ((thisOriginString == previousOriginString) && (thisDestinationString == previousDestinationString));
               }
             }
             catch (...)
             {
               identicalOrigins = false;
             }
 
             if (identicalOrigins && (numberOfFilesInPreviousBlock == numberOfFilesInThisBlock))
             {
               // group with previous block
               groupsOf3DPlusTBlocks[previousBlockKey].AddFiles(block3DIter->second.GetFilenames());
               groupsOf3DPlusTBlocks[previousBlockKey].SetHasMultipleTimePoints(true);
               MITK_DEBUG << "  --> group enhanced with another timestep";
             }
             else
             {
               // start a new block
               groupsOf3DPlusTBlocks[thisBlockKey] = block3DIter->second;
               int numberOfTimeSteps =
                 groupsOf3DPlusTBlocks[previousBlockKey].GetFilenames().size() / numberOfFilesInPreviousBlock;
               MITK_DEBUG << "  ==> group closed with " << numberOfTimeSteps << " time steps";
               previousBlockKey = thisBlockKey;
               MITK_DEBUG << "  3D+t group " << thisBlockKey << " started";
             }
           }
 
           numberOfFilesInPreviousBlock = numberOfFilesInThisBlock;
         }
       }
     }
 
     MITK_DEBUG << "================================================================================";
     MITK_DEBUG << "Summary: ";
     for (FileNamesGrouping::const_iterator groupIter = groupsOf3DPlusTBlocks.begin();
          groupIter != groupsOf3DPlusTBlocks.end();
          ++groupIter)
     {
       ImageBlockDescriptor block = groupIter->second;
       MITK_DEBUG << "  " << block.GetFilenames().size() << " '" << block.GetModality() << "' images ("
                  << block.GetSOPClassUIDAsString() << ") in volume " << block.GetImageBlockUID();
       MITK_DEBUG << "    (gantry tilt : " << (block.HasGantryTiltCorrected() ? "Yes" : "No") << "; "
                                                                                                 "pixel spacing : "
                  << PixelSpacingInterpretationToString(block.GetPixelSpacingType()) << "; "
                                                                                        "3D+t: "
                  << (block.HasMultipleTimePoints() ? "Yes" : "No") << "; "
                                                                       "reader support: "
                  << ReaderImplementationLevelToString(block.GetReaderImplementationLevel()) << ")";
       StringContainer debugOutputFiles = block.GetFilenames();
       for (StringContainer::const_iterator siter = debugOutputFiles.begin(); siter != debugOutputFiles.end(); ++siter)
         MITK_DEBUG << "  F " << *siter;
     }
     MITK_DEBUG << "================================================================================";
 
     return groupsOf3DPlusTBlocks;
   }
 
   DicomSeriesReader::FileNamesGrouping DicomSeriesReader::GetSeries(const std::string &dir,
                                                                     bool groupImagesWithGantryTilt,
                                                                     const StringContainer &restrictions)
   {
     gdcm::Directory directoryLister;
     directoryLister.Load(dir.c_str(), false); // non-recursive
     return GetSeries(directoryLister.GetFilenames(), groupImagesWithGantryTilt, restrictions);
   }
 
   std::string DicomSeriesReader::CreateSeriesIdentifierPart(gdcm::Scanner::TagToValue &tagValueMap,
                                                             const gdcm::Tag &tag)
   {
     std::string result;
     try
     {
       result = IDifyTagValue(tagValueMap[tag] ? tagValueMap[tag] : std::string(""));
     }
     catch ( const std::exception & )
     {
       // we are happy with even nothing, this will just group images of a series
       // MITK_WARN << "Could not access tag " << tag << ": " << e.what();
     }
 
     return result;
   }
 
   std::string DicomSeriesReader::CreateMoreUniqueSeriesIdentifier(gdcm::Scanner::TagToValue &tagValueMap)
   {
     const gdcm::Tag tagSeriesInstanceUID(0x0020, 0x000e);  // Series Instance UID
     const gdcm::Tag tagImageOrientation(0x0020, 0x0037);   // image orientation
     const gdcm::Tag tagPixelSpacing(0x0028, 0x0030);       // pixel spacing
     const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164); // imager pixel spacing
     const gdcm::Tag tagSliceThickness(0x0018, 0x0050);     // slice thickness
     const gdcm::Tag tagNumberOfRows(0x0028, 0x0010);       // number rows
     const gdcm::Tag tagNumberOfColumns(0x0028, 0x0011);    // number cols
     const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008);     // number of frames
 
     const char *tagSeriesInstanceUid = tagValueMap[tagSeriesInstanceUID];
     if (!tagSeriesInstanceUid)
     {
       mitkThrow() << "CreateMoreUniqueSeriesIdentifier() could not access series instance UID. Something is seriously "
                      "wrong with this image, so stopping here.";
     }
     std::string constructedID = tagSeriesInstanceUid;
 
     constructedID += CreateSeriesIdentifierPart(tagValueMap, tagNumberOfRows);
     constructedID += CreateSeriesIdentifierPart(tagValueMap, tagNumberOfColumns);
     constructedID += CreateSeriesIdentifierPart(tagValueMap, tagPixelSpacing);
     constructedID += CreateSeriesIdentifierPart(tagValueMap, tagImagerPixelSpacing);
     constructedID += CreateSeriesIdentifierPart(tagValueMap, tagSliceThickness);
     constructedID += CreateSeriesIdentifierPart(tagValueMap, tagNumberOfFrames);
 
     // be a bit tolerant for orientation, let only the first few digits matter
-    // (http://bugs.mitk.org/show_bug.cgi?id=12263)
+    // (https://phabricator.mitk.org/T12263)
     // NOT constructedID += CreateSeriesIdentifierPart( tagValueMap, tagImageOrientation );
     if (tagValueMap.find(tagImageOrientation) != tagValueMap.end())
     {
       bool conversionError(false);
       Vector3D right;
       right.Fill(0.0);
       Vector3D up;
       right.Fill(0.0);
       DICOMStringToOrientationVectors(tagValueMap[tagImageOrientation], right, up, conversionError);
       // string  newstring sprintf(simplifiedOrientationString, "%.3f\\%.3f\\%.3f\\%.3f\\%.3f\\%.3f", right[0],
       // right[1],
       // right[2], up[0], up[1], up[2]);
       std::ostringstream ss;
       ss.setf(std::ios::fixed, std::ios::floatfield);
       ss.precision(5);
       ss << right[0] << "\\" << right[1] << "\\" << right[2] << "\\" << up[0] << "\\" << up[1] << "\\" << up[2];
       std::string simplifiedOrientationString(ss.str());
 
       constructedID += IDifyTagValue(simplifiedOrientationString);
     }
 
     constructedID.resize(constructedID.length() - 1); // cut of trailing '.'
 
     return constructedID;
   }
 
   std::string DicomSeriesReader::IDifyTagValue(const std::string &value)
   {
     std::string IDifiedValue(value);
     if (value.empty())
       throw std::logic_error("IDifyTagValue() illegaly called with empty tag value");
 
     // Eliminate non-alnum characters, including whitespace...
     //   that may have been introduced by concats.
     for (std::size_t i = 0; i < IDifiedValue.size(); i++)
     {
       while (i < IDifiedValue.size() &&
              !(IDifiedValue[i] == '.' || (IDifiedValue[i] >= 'a' && IDifiedValue[i] <= 'z') ||
                (IDifiedValue[i] >= '0' && IDifiedValue[i] <= '9') ||
                (IDifiedValue[i] >= 'A' && IDifiedValue[i] <= 'Z')))
       {
         IDifiedValue.erase(i, 1);
       }
     }
 
     IDifiedValue += ".";
     return IDifiedValue;
   }
 
   DicomSeriesReader::StringContainer DicomSeriesReader::GetSeries(const std::string &dir,
                                                                   const std::string &series_uid,
                                                                   bool groupImagesWithGantryTilt,
                                                                   const StringContainer &restrictions)
   {
     FileNamesGrouping allSeries = GetSeries(dir, groupImagesWithGantryTilt, restrictions);
     StringContainer resultingFileList;
 
     for (FileNamesGrouping::const_iterator idIter = allSeries.begin(); idIter != allSeries.end(); ++idIter)
     {
       if (idIter->first.find(series_uid) == 0) // this ID starts with given series_uid
       {
         return idIter->second.GetFilenames();
       }
     }
 
     return resultingFileList;
   }
 
   DicomSeriesReader::StringContainer DicomSeriesReader::SortSeriesSlices(const StringContainer &unsortedFilenames)
   {
     /* we CAN expect a group of equal
        - series instance uid
        - image orientation
        - pixel spacing
        - imager pixel spacing
        - slice thickness
        - number of rows/columns
 
        (each piece of information except the rows/columns might be missing)
 
        sorting with GdcmSortFunction tries its best by sorting by spatial position
        and more hints (acquisition number, acquisition time, trigger time) but will
        always produce a sorting by falling back to SOP Instance UID.
     */
     gdcm::Sorter sorter;
 
     sorter.SetSortFunction(DicomSeriesReader::GdcmSortFunction);
     try
     {
       if (sorter.Sort(unsortedFilenames))
       {
         return sorter.GetFilenames();
       }
       else
       {
         MITK_WARN << "Sorting error. Leaving series unsorted.";
         return unsortedFilenames;
       }
     }
     catch ( const std::logic_error & )
     {
       MITK_WARN << "Sorting error. Leaving series unsorted.";
       return unsortedFilenames;
     }
   }
 
   bool DicomSeriesReader::GdcmSortFunction(const gdcm::DataSet &ds1, const gdcm::DataSet &ds2)
   {
     // This method MUST accept missing location and position information (and all else, too)
     // because we cannot rely on anything
     // (restriction on the sentence before: we have to provide consistent sorting, so we
     // rely on the minimum information all DICOM files need to provide: SOP Instance UID)
 
     /* we CAN expect a group of equal
        - series instance uid
        - image orientation
        - pixel spacing
        - imager pixel spacing
        - slice thickness
        - number of rows/columns
     */
     static const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image Position (Patient)
     static const gdcm::Tag tagImageOrientation(0x0020, 0x0037);     // Image Orientation
 
     // see if we have Image Position and Orientation
     if (ds1.FindDataElement(tagImagePositionPatient) && ds1.FindDataElement(tagImageOrientation) &&
         ds2.FindDataElement(tagImagePositionPatient) && ds2.FindDataElement(tagImageOrientation))
     {
       gdcm::Attribute<0x0020, 0x0032> image_pos1;         // Image Position (Patient)
       gdcm::Attribute<0x0020, 0x0037> image_orientation1; // Image Orientation (Patient)
 
       image_pos1.Set(ds1);
       image_orientation1.Set(ds1);
 
       gdcm::Attribute<0x0020, 0x0032> image_pos2;
       gdcm::Attribute<0x0020, 0x0037> image_orientation2;
 
       image_pos2.Set(ds2);
       image_orientation2.Set(ds2);
 
       /*
          we tolerate very small differences in image orientation, since we got to know about
          acquisitions where these values change across a single series (7th decimal digit)
-         (http://bugs.mitk.org/show_bug.cgi?id=12263)
+         (https://phabricator.mitk.org/T12263)
 
          still, we want to check if our assumption of 'almost equal' orientations is valid
        */
       for (unsigned int dim = 0; dim < 6; ++dim)
       {
         if (fabs(image_orientation2[dim] - image_orientation1[dim]) > 0.0001)
         {
           MITK_ERROR << "Dicom images have different orientations.";
           throw std::logic_error(
             "Dicom images have different orientations. Call GetSeries() first to separate images.");
         }
       }
 
       double normal[3];
 
       normal[0] = image_orientation1[1] * image_orientation1[5] - image_orientation1[2] * image_orientation1[4];
       normal[1] = image_orientation1[2] * image_orientation1[3] - image_orientation1[0] * image_orientation1[5];
       normal[2] = image_orientation1[0] * image_orientation1[4] - image_orientation1[1] * image_orientation1[3];
 
       double dist1 = 0.0, dist2 = 0.0;
 
       // this computes the distance from world origin (0,0,0) ALONG THE NORMAL of the image planes
       for (unsigned char i = 0u; i < 3u; ++i)
       {
         dist1 += normal[i] * image_pos1[i];
         dist2 += normal[i] * image_pos2[i];
       }
 
       // if we can sort by just comparing the distance, we do exactly that
       if (fabs(dist1 - dist2) >= mitk::eps)
       {
         // default: compare position
         return dist1 < dist2;
       }
       else // we need to check more properties to distinguish slices
       {
         // try to sort by Acquisition Number
         static const gdcm::Tag tagAcquisitionNumber(0x0020, 0x0012);
         if (ds1.FindDataElement(tagAcquisitionNumber) && ds2.FindDataElement(tagAcquisitionNumber))
         {
           gdcm::Attribute<0x0020, 0x0012> acquisition_number1; // Acquisition number
           gdcm::Attribute<0x0020, 0x0012> acquisition_number2;
 
           acquisition_number1.Set(ds1);
           acquisition_number2.Set(ds2);
 
           if (acquisition_number1 != acquisition_number2)
           {
             return acquisition_number1 < acquisition_number2;
           }
           else // neither position nor acquisition number are good for sorting, so check more
           {
             // try to sort by Acquisition Time
             static const gdcm::Tag tagAcquisitionTime(0x0008, 0x0032);
             if (ds1.FindDataElement(tagAcquisitionTime) && ds2.FindDataElement(tagAcquisitionTime))
             {
               gdcm::Attribute<0x0008, 0x0032> acquisition_time1; // Acquisition time
               gdcm::Attribute<0x0008, 0x0032> acquisition_time2;
 
               acquisition_time1.Set(ds1);
               acquisition_time2.Set(ds2);
 
               if (acquisition_time1 != acquisition_time2)
               {
                 return acquisition_time1 < acquisition_time2;
               }
               else // we gave up on image position, acquisition number and acquisition time now
               {
                 // let's try trigger time
                 static const gdcm::Tag tagTriggerTime(0x0018, 0x1060);
                 if (ds1.FindDataElement(tagTriggerTime) && ds2.FindDataElement(tagTriggerTime))
                 {
                   gdcm::Attribute<0x0018, 0x1060> trigger_time1; // Trigger time
                   gdcm::Attribute<0x0018, 0x1060> trigger_time2;
 
                   trigger_time1.Set(ds1);
                   trigger_time2.Set(ds2);
 
                   if (trigger_time1 != trigger_time2)
                   {
                     return trigger_time1 < trigger_time2;
                   }
                   // ELSE!
                   // for this and many previous ifs we fall through if nothing lets us sort
                 } // .
               }   // .
             }     // .
           }
         }
       }
     } // .
 
     // LAST RESORT: all valuable information for sorting is missing.
     // Sort by some meaningless but unique identifiers to satisfy the sort function
     static const gdcm::Tag tagSOPInstanceUID(0x0008, 0x0018);
     if (ds1.FindDataElement(tagSOPInstanceUID) && ds2.FindDataElement(tagSOPInstanceUID))
     {
       MITK_DEBUG
         << "Dicom images are missing attributes for a meaningful sorting, falling back to SOP instance UID comparison.";
       gdcm::Attribute<0x0008, 0x0018> SOPInstanceUID1; // SOP instance UID is mandatory and unique
       gdcm::Attribute<0x0008, 0x0018> SOPInstanceUID2;
 
       SOPInstanceUID1.Set(ds1);
       SOPInstanceUID2.Set(ds2);
 
       return SOPInstanceUID1 < SOPInstanceUID2;
     }
     else
     {
       // no DICOM file should really come down here, this should only be reached with unskillful and unlucky
       // manipulation
       // of files
       std::string error_message("Malformed DICOM images, which do not even contain a SOP Instance UID.");
       MITK_ERROR << error_message;
       throw std::logic_error(error_message);
     }
   }
 
   std::string DicomSeriesReader::GetConfigurationString()
   {
     std::stringstream configuration;
     configuration << "MITK_USE_GDCMIO: ";
     configuration << "true";
     configuration << "\n";
 
     configuration << "GDCM_VERSION: ";
 #ifdef GDCM_MAJOR_VERSION
     configuration << GDCM_VERSION;
 #endif
     // configuration << "\n";
 
     return configuration.str();
   }
 
   void DicomSeriesReader::CopyMetaDataToImageProperties(StringContainer filenames,
                                                         const gdcm::Scanner::MappingType &tagValueMappings_,
                                                         DcmIoType *io,
                                                         const ImageBlockDescriptor &blockInfo,
                                                         Image *image)
   {
     std::list<StringContainer> imageBlock;
     imageBlock.push_back(filenames);
     CopyMetaDataToImageProperties(imageBlock, tagValueMappings_, io, blockInfo, image);
   }
 
   void DicomSeriesReader::CopyMetaDataToImageProperties(std::list<StringContainer> imageBlock,
                                                         const gdcm::Scanner::MappingType &tagValueMappings_,
                                                         DcmIoType *io,
                                                         const ImageBlockDescriptor &blockInfo,
                                                         Image *image)
   {
     if (!io || !image)
       return;
 
     StringLookupTable filesForSlices;
     StringLookupTable sliceLocationForSlices;
     StringLookupTable instanceNumberForSlices;
     StringLookupTable SOPInstanceNumberForSlices;
 
     auto &tagValueMappings = const_cast<gdcm::Scanner::MappingType &>(tagValueMappings_);
 
     // DICOM tags which should be added to the image properties
     const gdcm::Tag tagSliceLocation(0x0020, 0x1041); // slice location
 
     const gdcm::Tag tagInstanceNumber(0x0020, 0x0013); // (image) instance number
 
     const gdcm::Tag tagSOPInstanceNumber(0x0008, 0x0018); // SOP instance number
     unsigned int timeStep(0);
 
     std::string propertyKeySliceLocation = "dicom.image.0020.1041";
     std::string propertyKeyInstanceNumber = "dicom.image.0020.0013";
     std::string propertyKeySOPInstanceNumber = "dicom.image.0008.0018";
 
     // tags for each image
     for (auto i = imageBlock.begin(); i != imageBlock.end(); i++, timeStep++)
     {
       const StringContainer &files = (*i);
       unsigned int slice(0);
       for (auto fIter = files.begin(); fIter != files.end(); ++fIter, ++slice)
       {
         filesForSlices.SetTableValue(slice, *fIter);
         gdcm::Scanner::TagToValue tagValueMapForFile = tagValueMappings[fIter->c_str()];
         if (tagValueMapForFile.find(tagSliceLocation) != tagValueMapForFile.end())
           sliceLocationForSlices.SetTableValue(slice, tagValueMapForFile[tagSliceLocation]);
         if (tagValueMapForFile.find(tagInstanceNumber) != tagValueMapForFile.end())
           instanceNumberForSlices.SetTableValue(slice, tagValueMapForFile[tagInstanceNumber]);
         if (tagValueMapForFile.find(tagSOPInstanceNumber) != tagValueMapForFile.end())
           SOPInstanceNumberForSlices.SetTableValue(slice, tagValueMapForFile[tagSOPInstanceNumber]);
       }
 
       image->SetProperty("files", StringLookupTableProperty::New(filesForSlices));
 
       // If more than one time step add postfix ".t" + timestep
       if (timeStep != 0)
       {
         std::ostringstream postfix;
         postfix << ".t" << timeStep;
 
         propertyKeySliceLocation.append(postfix.str());
         propertyKeyInstanceNumber.append(postfix.str());
         propertyKeySOPInstanceNumber.append(postfix.str());
       }
       image->SetProperty(propertyKeySliceLocation.c_str(), StringLookupTableProperty::New(sliceLocationForSlices));
       image->SetProperty(propertyKeyInstanceNumber.c_str(), StringLookupTableProperty::New(instanceNumberForSlices));
       image->SetProperty(propertyKeySOPInstanceNumber.c_str(),
                          StringLookupTableProperty::New(SOPInstanceNumberForSlices));
     }
 
     // Copy tags for series, study, patient level (leave interpretation to application).
     // These properties will be copied to the DataNode by DicomSeriesReader.
 
     // tags for the series (we just use the one that ITK copied to its dictionary (probably that of the last slice)
     const itk::MetaDataDictionary &dict = io->GetMetaDataDictionary();
     const TagToPropertyMapType &propertyLookup = DicomSeriesReader::GetDICOMTagsToMITKPropertyMap();
 
     auto dictIter = dict.Begin();
     while (dictIter != dict.End())
     {
       // MITK_DEBUG << "Key " << dictIter->first;
       std::string value;
       if (itk::ExposeMetaData<std::string>(dict, dictIter->first, value))
       {
         // MITK_DEBUG << "Value " << value;
 
         auto valuePosition = propertyLookup.find(dictIter->first);
         if (valuePosition != propertyLookup.end())
         {
           std::string propertyKey = valuePosition->second;
           // MITK_DEBUG << "--> " << propertyKey;
 
           image->SetProperty(propertyKey.c_str(), StringProperty::New(value));
         }
       }
       else
       {
         MITK_WARN << "Tag " << dictIter->first << " not read as string as expected. Ignoring...";
       }
       ++dictIter;
     }
 
     // copy imageblockdescriptor as properties
     image->SetProperty("dicomseriesreader.SOPClass", StringProperty::New(blockInfo.GetSOPClassUIDAsString()));
     image->SetProperty(
       "dicomseriesreader.ReaderImplementationLevelString",
       StringProperty::New(ReaderImplementationLevelToString(blockInfo.GetReaderImplementationLevel())));
     image->SetProperty("dicomseriesreader.ReaderImplementationLevel",
                        GenericProperty<ReaderImplementationLevel>::New(blockInfo.GetReaderImplementationLevel()));
     image->SetProperty("dicomseriesreader.PixelSpacingInterpretationString",
                        StringProperty::New(PixelSpacingInterpretationToString(blockInfo.GetPixelSpacingType())));
     image->SetProperty("dicomseriesreader.PixelSpacingInterpretation",
                        GenericProperty<PixelSpacingInterpretation>::New(blockInfo.GetPixelSpacingType()));
     image->SetProperty("dicomseriesreader.MultiFrameImage", BoolProperty::New(blockInfo.IsMultiFrameImage()));
     image->SetProperty("dicomseriesreader.GantyTiltCorrected", BoolProperty::New(blockInfo.HasGantryTiltCorrected()));
     image->SetProperty("dicomseriesreader.3D+t", BoolProperty::New(blockInfo.HasMultipleTimePoints()));
   }
 
   void DicomSeriesReader::FixSpacingInformation(mitk::Image *image, const ImageBlockDescriptor &imageBlockDescriptor)
   {
     // spacing provided by ITK/GDCM
     Vector3D imageSpacing = image->GetGeometry()->GetSpacing();
     ScalarType imageSpacingX = imageSpacing[0];
     ScalarType imageSpacingY = imageSpacing[1];
 
     // spacing as desired by MITK (preference for "in patient", else "on detector", or "1.0/1.0")
     ScalarType desiredSpacingX = imageSpacingX;
     ScalarType desiredSpacingY = imageSpacingY;
     imageBlockDescriptor.GetDesiredMITKImagePixelSpacing(desiredSpacingX, desiredSpacingY);
 
     MITK_DEBUG << "Loaded spacing: " << imageSpacingX << "/" << imageSpacingY;
     MITK_DEBUG << "Corrected spacing: " << desiredSpacingX << "/" << desiredSpacingY;
 
     imageSpacing[0] = desiredSpacingX;
     imageSpacing[1] = desiredSpacingY;
     image->GetGeometry()->SetSpacing(imageSpacing);
   }
 
   void DicomSeriesReader::LoadDicom(const StringContainer &filenames,
                                     DataNode &node,
                                     bool sort,
                                     bool load4D,
                                     bool correctTilt,
                                     UpdateCallBackMethod callback,
                                     Image::Pointer preLoadedImageBlock)
   {
     mitk::LocaleSwitch localeSwitch("C");
     std::locale previousCppLocale(std::cin.getloc());
     std::locale l("C");
     std::cin.imbue(l);
 
     ImageBlockDescriptor imageBlockDescriptor;
 
     const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image Position (Patient)
     const gdcm::Tag tagImageOrientation(0x0020, 0x0037);     // Image Orientation
     const gdcm::Tag tagSeriesInstanceUID(0x0020, 0x000e);    // Series Instance UID
     const gdcm::Tag tagSOPClassUID(0x0008, 0x0016);          // SOP class UID
     const gdcm::Tag tagModality(0x0008, 0x0060);             // modality
     const gdcm::Tag tagPixelSpacing(0x0028, 0x0030);         // pixel spacing
     const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164);   // imager pixel spacing
     const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008);       // number of frames
 
     try
     {
       Image::Pointer image = preLoadedImageBlock.IsNull() ? Image::New() : preLoadedImageBlock;
       CallbackCommand *command = callback ? new CallbackCommand(callback) : nullptr;
       bool initialize_node = false;
 
       /* special case for Philips 3D+t ultrasound images */
       if (DicomSeriesReader::IsPhilips3DDicom(filenames.front().c_str()))
       {
         // TODO what about imageBlockDescriptor?
         // TODO what about preLoadedImageBlock?
         ReadPhilips3DDicom(filenames.front().c_str(), image);
         initialize_node = true;
       }
       else
       {
         /* default case: assume "normal" image blocks, possibly 3D+t */
         bool canLoadAs4D(true);
         gdcm::Scanner scanner;
         ScanForSliceInformation(filenames, scanner);
 
         // need non-const access for map
         auto &tagValueMappings = const_cast<gdcm::Scanner::MappingType &>(scanner.GetMappings());
 
         std::list<StringContainer> imageBlocks =
           SortIntoBlocksFor3DplusT(filenames, tagValueMappings, sort, canLoadAs4D);
         unsigned int volume_count = imageBlocks.size();
 
         imageBlockDescriptor.SetSeriesInstanceUID(
           DicomSeriesReader::ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagSeriesInstanceUID)));
         imageBlockDescriptor.SetSOPClassUID(
           DicomSeriesReader::ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagSOPClassUID)));
         imageBlockDescriptor.SetModality(
           DicomSeriesReader::ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagModality)));
         imageBlockDescriptor.SetNumberOfFrames(
           ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagNumberOfFrames)));
         imageBlockDescriptor.SetPixelSpacingInformation(
           ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagPixelSpacing)),
           ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagImagerPixelSpacing)));
 
         GantryTiltInformation tiltInfo;
 
         // check possibility of a single slice with many timesteps. In this case, don't check for tilt, no second slice
         // possible
         if (!imageBlocks.empty() && imageBlocks.front().size() > 1 && correctTilt)
         {
           // check tiltedness here, potentially fixup ITK's loading result by shifting slice contents
           // check first and last position slice from tags, make some calculations to detect tilt
 
           std::string firstFilename(imageBlocks.front().front());
           // calculate from first and last slice to minimize rounding errors
           std::string secondFilename(imageBlocks.front().back());
 
           std::string imagePosition1(
             ConstCharStarToString(tagValueMappings[firstFilename.c_str()][tagImagePositionPatient]));
           std::string imageOrientation(
             ConstCharStarToString(tagValueMappings[firstFilename.c_str()][tagImageOrientation]));
           std::string imagePosition2(
             ConstCharStarToString(tagValueMappings[secondFilename.c_str()][tagImagePositionPatient]));
 
           bool ignoredConversionError(-42); // hard to get here, no graceful way to react
           Point3D origin1(DICOMStringToPoint3D(imagePosition1, ignoredConversionError));
           Point3D origin2(DICOMStringToPoint3D(imagePosition2, ignoredConversionError));
 
           Vector3D right;
           right.Fill(0.0);
           Vector3D up;
           right.Fill(0.0); // might be down as well, but it is just a name at this point
           DICOMStringToOrientationVectors(imageOrientation, right, up, ignoredConversionError);
 
           tiltInfo = GantryTiltInformation(origin1, origin2, right, up, filenames.size() - 1);
           correctTilt = tiltInfo.IsSheared() && tiltInfo.IsRegularGantryTilt();
         }
         else
         {
           correctTilt = false; // we CANNOT do that
         }
 
         imageBlockDescriptor.SetHasGantryTiltCorrected(correctTilt);
 
         if (volume_count == 1 || !canLoadAs4D || !load4D)
         {
           DcmIoType::Pointer io;
           image = MultiplexLoadDICOMByITK(
             imageBlocks.front(), correctTilt, tiltInfo, io, command, preLoadedImageBlock); // load first 3D block
 
           imageBlockDescriptor.AddFiles(imageBlocks.front()); // only the first part is loaded
           imageBlockDescriptor.SetHasMultipleTimePoints(false);
 
           FixSpacingInformation(image, imageBlockDescriptor);
           CopyMetaDataToImageProperties(imageBlocks.front(), scanner.GetMappings(), io, imageBlockDescriptor, image);
 
           initialize_node = true;
         }
         else if (volume_count > 1)
         {
           imageBlockDescriptor.AddFiles(filenames); // all is loaded
           imageBlockDescriptor.SetHasMultipleTimePoints(true);
 
           DcmIoType::Pointer io;
           image = MultiplexLoadDICOMByITK4D(
             imageBlocks, imageBlockDescriptor, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
 
           initialize_node = true;
         }
       }
 
       if (initialize_node)
       {
         // forward some image properties to node
         node.GetPropertyList()->ConcatenatePropertyList(image->GetPropertyList(), true);
 
         std::string patientName = "NoName";
         if (node.GetProperty("dicom.patient.PatientsName"))
           patientName = node.GetProperty("dicom.patient.PatientsName")->GetValueAsString();
 
         node.SetData(image);
         node.SetName(patientName);
         std::cin.imbue(previousCppLocale);
       }
 
       MITK_DEBUG << "--------------------------------------------------------------------------------";
       MITK_DEBUG << "DICOM files loaded (from series UID " << imageBlockDescriptor.GetSeriesInstanceUID() << "):";
       MITK_DEBUG << "  " << imageBlockDescriptor.GetFilenames().size() << " '" << imageBlockDescriptor.GetModality()
                  << "' files (" << imageBlockDescriptor.GetSOPClassUIDAsString() << ") loaded into 1 mitk::Image";
       MITK_DEBUG << "  multi-frame: " << (imageBlockDescriptor.IsMultiFrameImage() ? "Yes" : "No");
       MITK_DEBUG << "  reader support: "
                  << ReaderImplementationLevelToString(imageBlockDescriptor.GetReaderImplementationLevel());
       MITK_DEBUG << "  pixel spacing type: "
                  << PixelSpacingInterpretationToString(imageBlockDescriptor.GetPixelSpacingType()) << " "
                  << image->GetGeometry()->GetSpacing()[0] << "/" << image->GetGeometry()->GetSpacing()[0];
       MITK_DEBUG << "  gantry tilt corrected: " << (imageBlockDescriptor.HasGantryTiltCorrected() ? "Yes" : "No");
       MITK_DEBUG << "  3D+t: " << (imageBlockDescriptor.HasMultipleTimePoints() ? "Yes" : "No");
       MITK_DEBUG << "--------------------------------------------------------------------------------";
     }
     catch ( const std::exception &e )
     {
       // reset locale then throw up
       std::cin.imbue(previousCppLocale);
 
       MITK_DEBUG << "Caught exception in DicomSeriesReader::LoadDicom";
 
       throw e;
     }
   }
 
   void DicomSeriesReader::ScanForSliceInformation(const StringContainer &filenames, gdcm::Scanner &scanner)
   {
     const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image position (Patient)
     scanner.AddTag(tagImagePositionPatient);
 
     const gdcm::Tag tagSeriesInstanceUID(0x0020, 0x000e); // Series Instance UID
     scanner.AddTag(tagSeriesInstanceUID);
 
     const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // Image orientation
     scanner.AddTag(tagImageOrientation);
 
     const gdcm::Tag tagSliceLocation(0x0020, 0x1041); // slice location
     scanner.AddTag(tagSliceLocation);
 
     const gdcm::Tag tagInstanceNumber(0x0020, 0x0013); // (image) instance number
     scanner.AddTag(tagInstanceNumber);
 
     const gdcm::Tag tagSOPInstanceNumber(0x0008, 0x0018); // SOP instance number
     scanner.AddTag(tagSOPInstanceNumber);
 
     const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // Pixel Spacing
     scanner.AddTag(tagPixelSpacing);
 
     const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164); // Imager Pixel Spacing
     scanner.AddTag(tagImagerPixelSpacing);
 
     const gdcm::Tag tagModality(0x0008, 0x0060); // Modality
     scanner.AddTag(tagModality);
 
     const gdcm::Tag tagSOPClassUID(0x0008, 0x0016); // SOP Class UID
     scanner.AddTag(tagSOPClassUID);
 
     const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008); // number of frames
     scanner.AddTag(tagNumberOfFrames);
 
     scanner.Scan(filenames); // make available image information for each file
   }
 
   std::list<DicomSeriesReader::StringContainer> DicomSeriesReader::SortIntoBlocksFor3DplusT(
     const StringContainer &presortedFilenames,
     const gdcm::Scanner::MappingType &tagValueMappings,
     bool /*sort*/,
     bool &canLoadAs4D)
   {
     std::list<StringContainer> imageBlocks;
 
     // ignore sort request, because most likely re-sorting is now needed due to changes in GetSeries(bug #8022)
     StringContainer sorted_filenames = DicomSeriesReader::SortSeriesSlices(presortedFilenames);
 
     std::string firstPosition;
     unsigned int numberOfBlocks(0); // number of 3D image blocks
 
     static const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image position (Patient)
     const gdcm::Tag tagModality(0x0008, 0x0060);
 
     // loop files to determine number of image blocks
     for (StringContainer::const_iterator fileIter = sorted_filenames.begin(); fileIter != sorted_filenames.end();
          ++fileIter)
     {
       gdcm::Scanner::TagToValue tagToValueMap = tagValueMappings.find(fileIter->c_str())->second;
 
       if (tagToValueMap.find(tagImagePositionPatient) == tagToValueMap.end())
       {
         const std::string &modality = tagToValueMap.find(tagModality)->second;
         if (modality.compare("RTIMAGE ") == 0 || modality.compare("RTIMAGE") == 0)
         {
           MITK_WARN << "Modality " << modality << " is not fully supported yet.";
           numberOfBlocks = 1;
           break;
         }
         else
         {
           // we expect to get images w/ missing position information ONLY as separated blocks.
           assert(presortedFilenames.size() == 1);
           numberOfBlocks = 1;
           break;
         }
       }
 
       std::string position = tagToValueMap.find(tagImagePositionPatient)->second;
       MITK_DEBUG << "  " << *fileIter << " at " << position;
       if (firstPosition.empty())
       {
         firstPosition = position;
       }
 
       if (position == firstPosition)
       {
         ++numberOfBlocks;
       }
       else
       {
         break; // enough information to know the number of image blocks
       }
     }
 
     MITK_DEBUG << "  ==> Assuming " << numberOfBlocks << " time steps";
 
     if (numberOfBlocks == 0)
       return imageBlocks; // only possible if called with no files
 
     // loop files to sort them into image blocks
     unsigned int numberOfExpectedSlices(0);
     for (unsigned int block = 0; block < numberOfBlocks; ++block)
     {
       StringContainer filesOfCurrentBlock;
 
       for (StringContainer::const_iterator fileIter = sorted_filenames.begin() + block;
            fileIter != sorted_filenames.end();
            // fileIter += numberOfBlocks) // TODO shouldn't this work? give invalid iterators on first attempts
            )
       {
         filesOfCurrentBlock.push_back(*fileIter);
         for (unsigned int b = 0; b < numberOfBlocks; ++b)
         {
           if (fileIter != sorted_filenames.end())
             ++fileIter;
         }
       }
 
       imageBlocks.push_back(filesOfCurrentBlock);
 
       if (block == 0)
       {
         numberOfExpectedSlices = filesOfCurrentBlock.size();
       }
       else
       {
         if (filesOfCurrentBlock.size() != numberOfExpectedSlices)
         {
           MITK_WARN
             << "DicomSeriesReader expected " << numberOfBlocks << " image blocks of " << numberOfExpectedSlices
             << " images each. Block " << block << " got " << filesOfCurrentBlock.size()
             << " instead. Cannot load this as 3D+t"; // TODO implement recovery (load as many slices 3D+t as much
                                                      // as possible)
           canLoadAs4D = false;
         }
       }
     }
 
     return imageBlocks;
   }
 
   Image::Pointer DicomSeriesReader::MultiplexLoadDICOMByITK(const StringContainer &filenames,
                                                             bool correctTilt,
                                                             const GantryTiltInformation &tiltInfo,
                                                             DcmIoType::Pointer &io,
                                                             CallbackCommand *command,
                                                             Image::Pointer preLoadedImageBlock)
   {
     io = DcmIoType::New();
     io->SetFileName(filenames.front().c_str());
     io->ReadImageInformation();
 
     if (io->GetPixelType() == itk::IOPixelEnum::SCALAR)
     {
       return MultiplexLoadDICOMByITKScalar(filenames, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
     }
     else if (io->GetPixelType() == itk::IOPixelEnum::RGB)
     {
       return MultiplexLoadDICOMByITKRGBPixel(filenames, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
     }
     else
     {
       return nullptr;
     }
   }
 
   Image::Pointer DicomSeriesReader::MultiplexLoadDICOMByITK4D(std::list<StringContainer> &imageBlocks,
                                                               ImageBlockDescriptor imageBlockDescriptor,
                                                               bool correctTilt,
                                                               const GantryTiltInformation &tiltInfo,
                                                               DcmIoType::Pointer &io,
                                                               CallbackCommand *command,
                                                               Image::Pointer preLoadedImageBlock)
   {
     io = DcmIoType::New();
     io->SetFileName(imageBlocks.front().front().c_str());
     io->ReadImageInformation();
 
     if (io->GetPixelType() == itk::IOPixelEnum::SCALAR)
     {
       return MultiplexLoadDICOMByITK4DScalar(
         imageBlocks, imageBlockDescriptor, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
     }
     else if (io->GetPixelType() == itk::IOPixelEnum::RGB)
     {
       return MultiplexLoadDICOMByITK4DRGBPixel(
         imageBlocks, imageBlockDescriptor, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
     }
     else
     {
       return nullptr;
     }
   }
 } // end namespace mitk
diff --git a/Modules/DICOM/src/mitkDICOMTagBasedSorter.cpp b/Modules/DICOM/src/mitkDICOMTagBasedSorter.cpp
index 534da7c29b..d84f0914dc 100644
--- a/Modules/DICOM/src/mitkDICOMTagBasedSorter.cpp
+++ b/Modules/DICOM/src/mitkDICOMTagBasedSorter.cpp
@@ -1,596 +1,596 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkDICOMTagBasedSorter.h"
 
 #include <algorithm>
 #include <iomanip>
 
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::CutDecimalPlaces(unsigned int precision)
 :m_Precision(precision)
 {
 }
 
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::CutDecimalPlaces(const CutDecimalPlaces& other)
 :m_Precision(other.m_Precision)
 {
 }
 
 std::string
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::operator()(const std::string& input) const
 {
-  // be a bit tolerant for tags such as image orientation orientation, let only the first few digits matter (http://bugs.mitk.org/show_bug.cgi?id=12263)
+  // be a bit tolerant for tags such as image orientation orientation, let only the first few digits matter (https://phabricator.mitk.org/T12263)
   // iterate all fields, convert each to a number, cut this number as configured, then return a concatenated string with all cut-off numbers
   std::ostringstream resultString;
   resultString.str(std::string());
   resultString.clear();
   resultString.setf(std::ios::fixed, std::ios::floatfield);
   resultString.precision(m_Precision);
 
   std::stringstream ss(input);
   ss.str(input);
   ss.clear();
   std::string item;
   double number(0);
   std::istringstream converter(item);
   while (std::getline(ss, item, '\\'))
   {
     converter.str(item);
     converter.clear();
     if (converter >> number && converter.eof())
     {
       // converted to double
       resultString << number;
     }
     else
     {
       // did not convert to double
       resultString << item; // just paste the unmodified string
     }
 
     if (!ss.eof())
     {
       resultString << "\\";
     }
   }
 
   return resultString.str();
 }
 
 mitk::DICOMTagBasedSorter::TagValueProcessor*
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::Clone() const
 {
   return new CutDecimalPlaces(*this);
 }
 
 
 unsigned int
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::GetPrecision() const
 {
   return m_Precision;
 }
 
 mitk::DICOMTagBasedSorter
 ::DICOMTagBasedSorter()
 :DICOMDatasetSorter()
 ,m_StrictSorting(m_DefaultStrictSorting)
 ,m_ExpectDistanceOne(m_DefaultExpectDistanceOne)
 {
 }
 
 mitk::DICOMTagBasedSorter
 ::~DICOMTagBasedSorter()
 {
   for(auto ti = m_TagValueProcessor.cbegin();
       ti != m_TagValueProcessor.cend();
       ++ti)
   {
     delete ti->second;
   }
 }
 
 mitk::DICOMTagBasedSorter
 ::DICOMTagBasedSorter(const DICOMTagBasedSorter& other )
 :DICOMDatasetSorter(other)
 ,m_DistinguishingTags( other.m_DistinguishingTags )
 ,m_SortCriterion( other.m_SortCriterion )
 ,m_StrictSorting( other.m_StrictSorting )
 ,m_ExpectDistanceOne( other.m_ExpectDistanceOne )
 {
   for(auto ti = other.m_TagValueProcessor.cbegin();
       ti != other.m_TagValueProcessor.cend();
       ++ti)
   {
     m_TagValueProcessor[ti->first] = ti->second->Clone();
   }
 }
 
 mitk::DICOMTagBasedSorter&
 mitk::DICOMTagBasedSorter
 ::operator=(const DICOMTagBasedSorter& other)
 {
   if (this != &other)
   {
     DICOMDatasetSorter::operator=(other);
     m_DistinguishingTags = other.m_DistinguishingTags;
     m_SortCriterion = other.m_SortCriterion;
     m_StrictSorting = other.m_StrictSorting;
     m_ExpectDistanceOne = other.m_ExpectDistanceOne;
 
     for(auto ti = other.m_TagValueProcessor.cbegin();
         ti != other.m_TagValueProcessor.cend();
         ++ti)
     {
       m_TagValueProcessor[ti->first] = ti->second->Clone();
     }
   }
   return *this;
 }
 
 bool
 mitk::DICOMTagBasedSorter
 ::operator==(const DICOMDatasetSorter& other) const
 {
   if (const auto* otherSelf = dynamic_cast<const DICOMTagBasedSorter*>(&other))
   {
     if (this->m_StrictSorting != otherSelf->m_StrictSorting) return false;
     if (this->m_ExpectDistanceOne != otherSelf->m_ExpectDistanceOne) return false;
 
     bool allTagsPresentAndEqual(true);
     if (this->m_DistinguishingTags.size() != otherSelf->m_DistinguishingTags.size())
       return false;
 
     for (auto myTag = this->m_DistinguishingTags.cbegin();
         myTag != this->m_DistinguishingTags.cend();
         ++myTag)
     {
       allTagsPresentAndEqual &= (std::find( otherSelf->m_DistinguishingTags.cbegin(), otherSelf->m_DistinguishingTags.cend(), *myTag )
                                  != otherSelf->m_DistinguishingTags.cend()); // other contains this tags
                                              // since size is equal, we don't need to check the inverse
     }
 
     if (!allTagsPresentAndEqual) return false;
 
     if (this->m_SortCriterion.IsNotNull() && otherSelf->m_SortCriterion.IsNotNull())
     {
       return *(this->m_SortCriterion) == *(otherSelf->m_SortCriterion);
     }
     else
     {
       return this->m_SortCriterion.IsNull() && otherSelf->m_SortCriterion.IsNull();
     }
   }
   else
   {
     return false;
   }
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::PrintConfiguration(std::ostream& os, const std::string& indent) const
 {
   os << indent << "Tag based sorting "
      << "(strict=" << (m_StrictSorting?"true":"false")
      << ", expectDistanceOne=" << (m_ExpectDistanceOne?"true":"false") << "):"
      << std::endl;
 
   for (auto tagIter = m_DistinguishingTags.begin();
        tagIter != m_DistinguishingTags.end();
        ++tagIter)
   {
     os << indent << "  Split on ";
     tagIter->Print(os);
     os << std::endl;
   }
 
   DICOMSortCriterion::ConstPointer crit = m_SortCriterion.GetPointer();
   while (crit.IsNotNull())
   {
     os << indent << "   Sort by ";
     crit->Print(os);
     os << std::endl;
     crit = crit->GetSecondaryCriterion();
   }
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::SetStrictSorting(bool strict)
 {
   m_StrictSorting = strict;
 }
 
 bool
 mitk::DICOMTagBasedSorter
 ::GetStrictSorting() const
 {
   return m_StrictSorting;
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::SetExpectDistanceOne(bool strict)
 {
   m_ExpectDistanceOne = strict;
 }
 
 bool
 mitk::DICOMTagBasedSorter
 ::GetExpectDistanceOne() const
 {
   return m_ExpectDistanceOne;
 }
 
 
 mitk::DICOMTagList
 mitk::DICOMTagBasedSorter
 ::GetTagsOfInterest()
 {
   DICOMTagList allTags = m_DistinguishingTags;
 
   if (m_SortCriterion.IsNotNull())
   {
     const DICOMTagList sortingRelevantTags = m_SortCriterion->GetAllTagsOfInterest();
     allTags.insert( allTags.end(), sortingRelevantTags.cbegin(), sortingRelevantTags.cend() ); // append
   }
 
   return allTags;
 }
 
 mitk::DICOMTagList
 mitk::DICOMTagBasedSorter
 ::GetDistinguishingTags() const
 {
   return m_DistinguishingTags;
 }
 
 const mitk::DICOMTagBasedSorter::TagValueProcessor*
 mitk::DICOMTagBasedSorter
 ::GetTagValueProcessorForDistinguishingTag(const DICOMTag& tag) const
 {
   auto loc = m_TagValueProcessor.find(tag);
   if (loc != m_TagValueProcessor.cend())
   {
     return loc->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::AddDistinguishingTag( const DICOMTag& tag, TagValueProcessor* tagValueProcessor )
 {
   m_DistinguishingTags.push_back(tag);
   m_TagValueProcessor[tag] = tagValueProcessor;
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::SetSortCriterion( DICOMSortCriterion::ConstPointer criterion )
 {
   m_SortCriterion = criterion;
 }
 
 mitk::DICOMSortCriterion::ConstPointer
 mitk::DICOMTagBasedSorter
 ::GetSortCriterion() const
 {
   return m_SortCriterion;
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::Sort()
 {
   // 1. split
   // 2. sort each group
   GroupIDToListType groups = this->SplitInputGroups();
   GroupIDToListType& sortedGroups = this->SortGroups( groups );
 
   // 3. define output
   this->SetNumberOfOutputs(sortedGroups.size());
   unsigned int outputIndex(0);
   for (auto groupIter = sortedGroups.cbegin();
        groupIter != sortedGroups.cend();
        ++outputIndex, ++groupIter)
   {
     this->SetOutput(outputIndex, groupIter->second);
   }
 }
 
 std::string
 mitk::DICOMTagBasedSorter
 ::BuildGroupID( DICOMDatasetAccess* dataset )
 {
   // just concatenate all tag values
   assert(dataset);
   std::stringstream groupID;
   groupID << "g";
   for (auto tagIter = m_DistinguishingTags.cbegin();
        tagIter != m_DistinguishingTags.cend();
        ++tagIter)
   {
     groupID << tagIter->GetGroup() << tagIter->GetElement(); // make group/element part of the id to cover empty tags
     DICOMDatasetFinding rawTagValue = dataset->GetTagValueAsString(*tagIter);
     std::string processedTagValue;
     if ( m_TagValueProcessor[*tagIter] != nullptr && rawTagValue.isValid)
     {
       processedTagValue = (*m_TagValueProcessor[*tagIter])(rawTagValue.value);
     }
     else
     {
       processedTagValue = rawTagValue.value;
     }
     groupID << processedTagValue;
   }
   // shorten ID?
   return groupID.str();
 }
 
 mitk::DICOMTagBasedSorter::GroupIDToListType
 mitk::DICOMTagBasedSorter
 ::SplitInputGroups()
 {
   DICOMDatasetList input = GetInput(); // copy
 
   GroupIDToListType listForGroupID;
 
   for (auto dsIter = input.cbegin();
        dsIter != input.cend();
        ++dsIter)
   {
     DICOMDatasetAccess* dataset = *dsIter;
     assert(dataset);
 
     std::string groupID = this->BuildGroupID( dataset );
     MITK_DEBUG << "Group ID for for " << dataset->GetFilenameIfAvailable() << ": " << groupID;
     listForGroupID[groupID].push_back(dataset);
   }
 
   MITK_DEBUG << "After tag based splitting: " << listForGroupID.size() << " groups";
 
   return listForGroupID;
 }
 
 mitk::DICOMTagBasedSorter::GroupIDToListType&
 mitk::DICOMTagBasedSorter
 ::SortGroups(GroupIDToListType& groups)
 {
   if (m_SortCriterion.IsNotNull())
   {
     /*
        Three steps here:
         1. sort within each group
            - this may result in orders such as 1 2 3 4 6 7 8 10 12 13 14
         2. create new groups by enforcing consecutive order within each group
            - resorts above example like 1 2 3 4  ;  6 7 8  ;  10  ;  12 13 14
         3. sort all of the groups (not WITHIN each group) by their first frame
            - if earlier "distinguish" steps created groups like 6 7 8  ;  1 2 3 4  ; 10,
              then this step would sort them like 1 2 3 4  ;  6 7 8  ;  10
     */
 
     // Step 1: sort within the groups
     // for each output
     //   sort by all configured tags, use secondary tags when equal or empty
     //   make configurable:
     //    - sorting order (ascending, descending)
     //    - sort numerically
     //    - ... ?
     unsigned int groupIndex(0);
     for (auto gIter = groups.begin();
          gIter != groups.end();
          ++groupIndex, ++gIter)
     {
       DICOMDatasetList& dsList = gIter->second;
 
 #ifdef MBILOG_ENABLE_DEBUG
       MITK_DEBUG << "   --------------------------------------------------------------------------------";
       MITK_DEBUG << "   DICOMTagBasedSorter before sorting group : " << groupIndex;
       for (auto oi = dsList.begin();
            oi != dsList.cend();
            ++oi)
       {
         MITK_DEBUG << "     INPUT     : " << (*oi)->GetFilenameIfAvailable();
       }
 #endif // #ifdef MBILOG_ENABLE_DEBUG
 
 
       std::sort( dsList.begin(), dsList.end(), ParameterizedDatasetSort( m_SortCriterion ) );
 
 #ifdef MBILOG_ENABLE_DEBUG
       MITK_DEBUG << "   --------------------------------------------------------------------------------";
       MITK_DEBUG << "   DICOMTagBasedSorter after sorting group : " << groupIndex;
       for (auto oi = dsList.cbegin();
            oi != dsList.cend();
            ++oi)
       {
         MITK_DEBUG << "     OUTPUT    : " << (*oi)->GetFilenameIfAvailable();
       }
       MITK_DEBUG << "   --------------------------------------------------------------------------------";
 
 #endif // MBILOG_ENABLE_DEBUG
 
     }
 
     GroupIDToListType consecutiveGroups;
     if (m_StrictSorting)
     {
       // Step 2: create new groups by enforcing consecutive order within each group
       unsigned int groupIndex(0);
       for (auto gIter = groups.begin();
            gIter != groups.end();
            ++gIter)
       {
         std::stringstream groupKey;
         groupKey << std::setfill('0') << std::setw(6) << groupIndex++;
 
         DICOMDatasetList& dsList = gIter->second;
         DICOMDatasetAccess* previousDS(nullptr);
         unsigned int dsIndex(0);
         double constantDistance(0.0);
         bool constantDistanceInitialized(false);
         for (auto dataset = dsList.cbegin();
              dataset != dsList.cend();
              ++dsIndex, ++dataset)
         {
           if (dsIndex >0) // ignore the first dataset, we cannot check any distances yet..
           {
             // for the second and every following dataset:
             // let the sorting criterion calculate a "distance"
             // if the distance is not 1, split off a new group!
             const double currentDistance = m_SortCriterion->NumericDistance(previousDS, *dataset);
             if (constantDistanceInitialized)
             {
               if (fabs(currentDistance - constantDistance) < fabs(constantDistance * 0.01)) // ok, deviation of up to 1% of distance is tolerated
               {
                 // nothing to do, just ok
                 MITK_DEBUG << "Checking currentDistance==" << currentDistance << ": small enough";
               }
               //else if (currentDistance < mitk::eps) // close enough to 0
               else
               {
                 MITK_DEBUG << "Split consecutive group at index " << dsIndex << " (current distance " << currentDistance << ", constant distance " << constantDistance << ")";
                 // split! this is done by simply creating a new group (key)
                 groupKey.str(std::string());
                 groupKey.clear();
                 groupKey << std::setfill('0') << std::setw(6) << groupIndex++;
               }
             }
             else
             {
               // second slice: learn about the expected distance!
 
               // heuristic: if distance is an integer, we check for a special case:
               //            if the distance is integer and not 1/-1, then we assume
               //            a missing slice right after the first slice
               //            ==> split off slices
               // in all other cases: second dataset at this position, no need to split already, we are still learning about the images
 
               // addition to the above: when sorting by imagepositions, a distance other than 1 between the first two slices is
               // not unusual, actually expected... then we should not split
 
               if (m_ExpectDistanceOne)
               {
                 if ((currentDistance - (int)currentDistance == 0.0) && fabs(currentDistance) != 1.0)
                   // exact comparison. An integer should not be expressed as 1.000000000000000000000000001!
                 {
                   MITK_DEBUG << "Split consecutive group at index " << dsIndex << " (special case: expected distance 1 exactly)";
                   groupKey.str(std::string());
                   groupKey.clear();
                   groupKey << std::setfill('0') << std::setw(6) << groupIndex++;
                 }
               }
 
               MITK_DEBUG << "Initialize strict distance to currentDistance=" << currentDistance;
 
               constantDistance = currentDistance;
               constantDistanceInitialized = true;
             }
           }
           consecutiveGroups[groupKey.str()].push_back(*dataset);
           previousDS = *dataset;
         }
       }
     }
     else
     {
       consecutiveGroups = groups;
     }
 
     // Step 3: sort all of the groups (not WITHIN each group) by their first frame
     /*
       build a list-1 of datasets with the first dataset one of each group
       sort this list-1
       build a new result list-2:
        - iterate list-1, for each dataset
          - find the group that contains this dataset
          - add this group as the next element to list-2
       return list-2 as the sorted output
     */
     DICOMDatasetList firstSlices;
     for (auto gIter = consecutiveGroups.cbegin();
          gIter != consecutiveGroups.cend();
          ++gIter)
     {
       assert(!gIter->second.empty());
       firstSlices.push_back(gIter->second.front());
     }
 
     std::sort( firstSlices.begin(), firstSlices.end(), ParameterizedDatasetSort( m_SortCriterion ) );
 
     GroupIDToListType sortedResultBlocks;
     unsigned int groupKeyValue(0);
     for (auto firstSlice = firstSlices.cbegin();
          firstSlice != firstSlices.cend();
          ++firstSlice)
     {
       for (auto gIter = consecutiveGroups.cbegin();
            gIter != consecutiveGroups.cend();
            ++groupKeyValue, ++gIter)
       {
         if (gIter->second.front() == *firstSlice)
         {
           std::stringstream groupKey;
           groupKey << std::setfill('0') << std::setw(6) << groupKeyValue; // try more than 999,999 groups and you are doomed (your application already is)
           sortedResultBlocks[groupKey.str()] = gIter->second;
         }
       }
     }
 
     groups = sortedResultBlocks;
   }
 
 #ifdef MBILOG_ENABLE_DEBUG
   unsigned int groupIndex( 0 );
   for ( auto gIter = groups.begin(); gIter != groups.end(); ++groupIndex, ++gIter )
   {
     DICOMDatasetList& dsList = gIter->second;
     MITK_DEBUG << "   --------------------------------------------------------------------------------";
     MITK_DEBUG << "   DICOMTagBasedSorter after sorting group : " << groupIndex;
     for ( auto oi = dsList.begin(); oi != dsList.end(); ++oi )
     {
       MITK_DEBUG << "     OUTPUT    : " << ( *oi )->GetFilenameIfAvailable();
     }
     MITK_DEBUG << "   --------------------------------------------------------------------------------";
   }
 #endif // MBILOG_ENABLE_DEBUG
 
 
 
   return groups;
 }
 
 mitk::DICOMTagBasedSorter::ParameterizedDatasetSort
 ::ParameterizedDatasetSort(DICOMSortCriterion::ConstPointer criterion)
 :m_SortCriterion(criterion)
 {
 }
 
 bool
 mitk::DICOMTagBasedSorter::ParameterizedDatasetSort
 ::operator() (const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right)
 {
   assert(left);
   assert(right);
   assert(m_SortCriterion.IsNotNull());
 
   return m_SortCriterion->IsLeftBeforeRight(left, right);
 }
diff --git a/Modules/DICOM/src/mitkGantryTiltInformation.cpp b/Modules/DICOM/src/mitkGantryTiltInformation.cpp
index f268ddf8c8..74c0162c42 100644
--- a/Modules/DICOM/src/mitkGantryTiltInformation.cpp
+++ b/Modules/DICOM/src/mitkGantryTiltInformation.cpp
@@ -1,255 +1,255 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "mitkGantryTiltInformation.h"
 
 #include "mitkDICOMTag.h"
 
 #include "mitkLogMacros.h"
 
 mitk::GantryTiltInformation::GantryTiltInformation()
 : m_ShiftUp(0.0)
 , m_ShiftRight(0.0)
 , m_ShiftNormal(0.0)
 , m_ITKAssumedSliceSpacing(0.0)
 , m_NumberOfSlicesApart(0)
 {
 }
 
 
 #define doublepoint(x) \
   Point3Dd x; \
   x[0] = x ## f[0]; \
   x[1] = x ## f[1]; \
   x[2] = x ## f[2];
 
 
 #define doublevector(x) \
   Vector3Dd x; \
   x[0] = x ## f[0]; \
   x[1] = x ## f[1]; \
   x[2] = x ## f[2];
 
 mitk::GantryTiltInformation::GantryTiltInformation(
     const Point3D& origin1f, const Point3D& origin2f,
     const Vector3D& rightf, const Vector3D& upf,
     unsigned int numberOfSlicesApart)
 : m_ShiftUp(0.0)
 , m_ShiftRight(0.0)
 , m_ShiftNormal(0.0)
 , m_ITKAssumedSliceSpacing(0.0)
 , m_NumberOfSlicesApart(numberOfSlicesApart)
 {
   assert(numberOfSlicesApart);
 
   doublepoint(origin1);
   doublepoint(origin2);
   doublevector(right);
   doublevector(up);
 
   // determine if slice 1 (imagePosition1 and imageOrientation1) and slice 2 can be in one orthogonal slice stack:
   // calculate a line from origin 1, directed along the normal of slice (calculated as the cross product of orientation 1)
   // check if this line passes through origin 2
 
   /*
      Determine if line (imagePosition2 + l * normal) contains imagePosition1.
      Done by calculating the distance of imagePosition1 from line (imagePosition2 + l *normal)
 
-     E.g. http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
+     E.g. https://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
 
      squared distance = | (pointAlongNormal - origin2) x (origin2 - origin1) | ^ 2
      /
      |pointAlongNormal - origin2| ^ 2
 
      ( x meaning the cross product )
   */
 
   Vector3Dd normal = itk::CrossProduct(right, up);
   Point3Dd pointAlongNormal = origin2 + normal;
 
   double numerator = itk::CrossProduct( pointAlongNormal - origin2 , origin2 - origin1 ).GetSquaredNorm();
   double denominator = (pointAlongNormal - origin2).GetSquaredNorm();
 
   double distance = sqrt(numerator / denominator);
 
   if ( distance > 0.001 ) // mitk::eps is too small; 1/1000 of a mm should be enough to detect tilt
   {
     MITK_DEBUG << "  Series seems to contain a tilted (or sheared) geometry";
     MITK_DEBUG << "  Distance of expected slice origin from actual slice origin: " << distance;
     MITK_DEBUG << "    ==> storing this shift for later analysis:";
     MITK_DEBUG << "    v origin1: " << origin1;
     MITK_DEBUG << "    v origin2: " << origin2;
     MITK_DEBUG << "    v right: " << right;
     MITK_DEBUG << "    v up: " << up;
     MITK_DEBUG << "    v normal: " << normal;
 
     Point3Dd projectionRight = projectPointOnLine( origin1, origin2, right );
     Point3Dd projectionNormal = projectPointOnLine( origin1, origin2, normal );
 
     m_ShiftRight = (projectionRight - origin2).GetNorm();
     m_ShiftNormal = (projectionNormal - origin2).GetNorm();
 
     /*
        now also check to which side the image is shifted.
 
        Calculation e.g. from
-       http://mathworld.wolfram.com/Point-PlaneDistance.html
+       https://mathworld.wolfram.com/Point-PlaneDistance.html
     */
 
     Point3Dd  testPoint = origin1;
     Vector3Dd planeNormal = up;
 
     double signedDistance = (
                              planeNormal[0] * testPoint[0]
                            + planeNormal[1] * testPoint[1]
                            + planeNormal[2] * testPoint[2]
                            - (
                                planeNormal[0] * origin2[0]
                              + planeNormal[1] * origin2[1]
                              + planeNormal[2] * origin2[2]
                              )
                            )
                            /
                            sqrt( planeNormal[0] * planeNormal[0]
                                + planeNormal[1] * planeNormal[1]
                                + planeNormal[2] * planeNormal[2]
                                );
 
     m_ShiftUp = signedDistance;
 
     m_ITKAssumedSliceSpacing = (origin2 - origin1).GetNorm();
     // How do we now this is assumed? See header documentation for ITK code references
     //double itkAssumedSliceSpacing = sqrt( m_ShiftUp * m_ShiftUp + m_ShiftNormal * m_ShiftNormal );
 
     MITK_DEBUG << "    calculated from slices " << m_NumberOfSlicesApart << " slices apart";
     MITK_DEBUG << "    shift normal: " << m_ShiftNormal;
     MITK_DEBUG << "    shift normal assumed by ITK: " << m_ITKAssumedSliceSpacing;
     MITK_DEBUG << "    shift up: " << m_ShiftUp;
     MITK_DEBUG << "    shift right: " << m_ShiftRight;
 
     MITK_DEBUG << "    tilt angle (deg): " << atan( m_ShiftUp / m_ShiftNormal ) * 180.0 / 3.1415926535;
   }
 }
 
 mitk::GantryTiltInformation
 mitk::GantryTiltInformation
 ::MakeFromTagValues(
     const std::string& origin1String,
     const std::string& origin2String,
     const std::string& orientationString,
     unsigned int numberOfSlicesApart)
 {
   Vector3D right; right.Fill(0.0);
   Vector3D up; right.Fill(0.0); // might be down as well, but it is just a name at this point
   bool orientationConversion(false);
   DICOMStringToOrientationVectors( orientationString, right, up, orientationConversion );
 
   if (orientationConversion
       && !origin1String.empty() && !origin2String.empty()
     )
   {
     bool firstOriginConversion(false);
     bool lastOriginConversion(false);
 
     Point3D firstOrigin = DICOMStringToPoint3D( origin1String, firstOriginConversion );
     Point3D lastOrigin = DICOMStringToPoint3D( origin2String, lastOriginConversion );
 
     if (firstOriginConversion && lastOriginConversion)
     {
       return GantryTiltInformation( firstOrigin, lastOrigin, right, up, numberOfSlicesApart );
     }
   }
 
   std::stringstream ss;
   ss << "Invalid tag values when constructing tilt information from origin1 '" << origin1String
      << "', origin2 '" << origin2String
      << "', and orientation '" << orientationString << "'";
 
   throw std::invalid_argument(ss.str());
 }
 
 void
 mitk::GantryTiltInformation
 ::Print(std::ostream& os) const
 {
   os << "  calculated from slices " << m_NumberOfSlicesApart << " slices apart" << std::endl;
   os << "  shift normal: " << m_ShiftNormal << std::endl;
   os << "  shift normal assumed by ITK: " << m_ITKAssumedSliceSpacing << std::endl;
   os << "  shift up: " << m_ShiftUp << std::endl;
   os << "  shift right: " << m_ShiftRight << std::endl;
 
   os << "  tilt angle (deg): " << atan( m_ShiftUp / m_ShiftNormal ) * 180.0 / 3.1415926535 << std::endl;
 }
 
 mitk::Point3D
 mitk::GantryTiltInformation::projectPointOnLine( Point3Dd p, Point3Dd lineOrigin, Vector3Dd lineDirection )
 {
   /**
-    See illustration at http://mo.mathematik.uni-stuttgart.de/inhalt/aussage/aussage472/
+    See illustration at https://mo.mathematik.uni-stuttgart.de/inhalt/aussage/aussage472/
 
     vector(lineOrigin,p) = normal * ( innerproduct((p - lineOrigin),normal) / squared-length(normal) )
   */
 
   Vector3Dd lineOriginToP = p - lineOrigin;
   double innerProduct = lineOriginToP * lineDirection;
 
   double factor = innerProduct / lineDirection.GetSquaredNorm();
   Point3Dd projection = lineOrigin + factor * lineDirection;
 
   return projection;
 }
 
 double
 mitk::GantryTiltInformation::GetTiltCorrectedAdditionalSize(unsigned int imageSizeZ) const
 {
   return fabs(m_ShiftUp /  static_cast<double>(m_NumberOfSlicesApart) * static_cast<double>(imageSizeZ-1));
 }
 
 double
 mitk::GantryTiltInformation::GetTiltAngleInDegrees() const
 {
   return atan( fabs(m_ShiftUp) / m_ShiftNormal ) * 180.0 / 3.1415926535;
 }
 
 double
 mitk::GantryTiltInformation::GetMatrixCoefficientForCorrectionInWorldCoordinates() const
 {
   // so many mm need to be shifted per slice!
   return m_ShiftUp / static_cast<double>(m_NumberOfSlicesApart);
 }
 
 double
 mitk::GantryTiltInformation::GetRealZSpacing() const
 {
   return m_ShiftNormal / static_cast<double>(m_NumberOfSlicesApart);
 }
 
 
 bool
 mitk::GantryTiltInformation::IsSheared() const
 {
   return m_NumberOfSlicesApart &&
          (   fabs(m_ShiftRight) > 0.001
           ||    fabs(m_ShiftUp) > 0.001);
 }
 
 
 bool
 mitk::GantryTiltInformation::IsRegularGantryTilt() const
 {
   return m_NumberOfSlicesApart &&
          (   fabs(m_ShiftRight) < 0.001
           &&    fabs(m_ShiftUp) > 0.001);
 }
 
diff --git a/Modules/DICOM/src/mitkSortByImagePositionPatient.cpp b/Modules/DICOM/src/mitkSortByImagePositionPatient.cpp
index f7a7936914..48fb80b0f7 100644
--- a/Modules/DICOM/src/mitkSortByImagePositionPatient.cpp
+++ b/Modules/DICOM/src/mitkSortByImagePositionPatient.cpp
@@ -1,164 +1,164 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkSortByImagePositionPatient.h"
 #include "mitkDICOMTag.h"
 
 mitk::SortByImagePositionPatient
 ::SortByImagePositionPatient(DICOMSortCriterion::Pointer secondaryCriterion)
 :DICOMSortCriterion(secondaryCriterion)
 {
 }
 
 mitk::SortByImagePositionPatient
 ::~SortByImagePositionPatient()
 {
 }
 
 mitk::SortByImagePositionPatient
 ::SortByImagePositionPatient(const SortByImagePositionPatient& other )
 :DICOMSortCriterion(other)
 {
 }
 
 mitk::SortByImagePositionPatient&
 mitk::SortByImagePositionPatient
 ::operator=(const SortByImagePositionPatient& other)
 {
   if (this != &other)
   {
     DICOMSortCriterion::operator=(other);
   }
   return *this;
 }
 
 bool
 mitk::SortByImagePositionPatient
 ::operator==(const DICOMSortCriterion& other) const
 {
   return dynamic_cast<const SortByImagePositionPatient*>(&other) != nullptr; // same class
 }
 
 void
 mitk::SortByImagePositionPatient
 ::Print(std::ostream& os) const
 {
   os << "(0020,0032) Image Position (Patient) along normal of (0020,0037) Image Orientation (Patient)";
 }
 
 mitk::DICOMTagList
 mitk::SortByImagePositionPatient
 ::GetTagsOfInterest() const
 {
   DICOMTagList tags;
   tags.push_back( DICOMTag(0x0020, 0x0032) ); // ImagePositionPatient
   tags.push_back( DICOMTag(0x0020, 0x0037) ); // ImageOrientationPatient
 
   return tags;
 }
 
 bool
 mitk::SortByImagePositionPatient
 ::IsLeftBeforeRight(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right) const
 {
   bool possible(false);
   double distance = InternalNumericDistance(left, right, possible); // returns 0.0 if not possible
   if (possible)
   {
     return distance > 0.0;
   }
   else
   {
     return this->NextLevelIsLeftBeforeRight(left, right);
   }
 }
 
 double
 mitk::SortByImagePositionPatient
 ::InternalNumericDistance(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right, bool& possible) const
 {
   // sort by distance to world origin, assuming (almost) equal orientation
   static const DICOMTag tagImagePositionPatient = DICOMTag(0x0020,0x0032); // Image Position (Patient)
   static const DICOMTag    tagImageOrientation = DICOMTag(0x0020, 0x0037); // Image Orientation
 
   Vector3D leftRight; leftRight.Fill(0.0);
   Vector3D leftUp; leftUp.Fill(0.0);
   bool leftHasOrientation(false);
   DICOMStringToOrientationVectors( left->GetTagValueAsString( tagImageOrientation ).value,
                                    leftRight, leftUp, leftHasOrientation );
 
   Vector3D rightRight; rightRight.Fill(0.0);
   Vector3D rightUp; rightUp.Fill(0.0);
   bool rightHasOrientation(false);
   DICOMStringToOrientationVectors(right->GetTagValueAsString(tagImageOrientation).value,
                                    rightRight, rightUp, rightHasOrientation );
 
   Point3D leftOrigin; leftOrigin.Fill(0.0f);
   bool leftHasOrigin(false);
   leftOrigin = DICOMStringToPoint3D(left->GetTagValueAsString(tagImagePositionPatient).value, leftHasOrigin);
 
   Point3D rightOrigin; rightOrigin.Fill(0.0f);
   bool rightHasOrigin(false);
   rightOrigin = DICOMStringToPoint3D(right->GetTagValueAsString(tagImagePositionPatient).value, rightHasOrigin);
 
   //   we tolerate very small differences in image orientation, since we got to know about
   //   acquisitions where these values change across a single series (7th decimal digit)
-  //   (http://bugs.mitk.org/show_bug.cgi?id=12263)
+  //   (https://phabricator.mitk.org/T12263)
   //   still, we want to check if our assumption of 'almost equal' orientations is valid
   for (unsigned int dim = 0; dim < 3; ++dim)
   {
     if (   fabs(leftRight[dim] - rightRight[dim]) > 0.0001
         || fabs(leftUp[dim] - rightUp[dim]) > 0.0001)
     {
       MITK_ERROR << "Dicom images have different orientations.";
       throw std::logic_error("Dicom images have different orientations. Call GetSeries() first to separate images.");
     }
   }
 
   Vector3D normal;
   normal[0] = leftRight[1] * leftUp[2] - leftRight[2] * leftUp[1];
   normal[1] = leftRight[2] * leftUp[0] - leftRight[0] * leftUp[2];
   normal[2] = leftRight[0] * leftUp[1] - leftRight[1] * leftUp[0];
 
   double leftDistance = 0.0;
   double rightDistance = 0.0;
 
   // this computes the distance from world origin (0,0,0) ALONG THE NORMAL of the image planes
   for (unsigned int dim = 0; dim < 3; ++dim)
   {
     leftDistance += normal[dim] * leftOrigin[dim];
     rightDistance += normal[dim] * rightOrigin[dim];
   }
 
   // if we can sort by just comparing the distance, we do exactly that
   if ( fabs(leftDistance - rightDistance) >= mitk::eps)
   {
     possible = true;
     // default: compare position
     return rightDistance - leftDistance; // if (left < right> ==> diff > 0
   }
   else
   {
     possible = false;
     return 0.0;
   }
 }
 
 
 double
 mitk::SortByImagePositionPatient
 ::NumericDistance(const mitk::DICOMDatasetAccess* from, const mitk::DICOMDatasetAccess* to) const
 {
   bool possible(false);
   double retVal = InternalNumericDistance(from, to, possible); // returns 0.0 if not possible
   return possible ? retVal : 0.0;
 }
diff --git a/Modules/DICOMPM/resource/mitkParamapPresets.xml b/Modules/DICOMPM/resource/mitkParamapPresets.xml
index 76bb8dfb42..434763bf42 100644
--- a/Modules/DICOMPM/resource/mitkParamapPresets.xml
+++ b/Modules/DICOMPM/resource/mitkParamapPresets.xml
@@ -1,213 +1,213 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <!--
 * Source
 
 *Coding schemes:
-  http://dicom.nema.org/medical/dicom/current/output/chtml/part16/PS3.16.html
+  https://dicom.nema.org/medical/dicom/current/output/chtml/part16/PS3.16.html
 
 -->
 
 <mitkParamapPresets file_version="0.1" >
 <!--
 Tracer Kinetic Models
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4101.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4101.html
 -->
   <preset name="Standard Tofts Model">
     <type code_value="126340" coding_scheme="DCM" code_name="Standard Tofts Model"/>
   </preset>
   <preset name="Extended Tofts Model">
     <type code_value="126341" coding_scheme="DCM" code_name="Extended Tofts Model"/>
   </preset>
   <preset name="First Pass Leakage Profile (FPLP) Model">
     <type code_value="126343" coding_scheme="DCM" code_name="First Pass Leakage Profile (FPLP) Model"/>
   </preset>
   <preset name="Shutter-Speed Model (SSM)">
     <type code_value="126344" coding_scheme="DCM" code_name="Shutter-Speed Model (SSM)"/>
   </preset>
   <preset name="Gamma Capillary Transit Time (GCTT) Model">
     <type code_value="126345" coding_scheme="DCM" code_name="Gamma Capillary Transit Time (GCTT) Model"/>
   </preset>
   <preset name="Adiabatic Tissue Homogeneity (ATH) Model">
     <type code_value="126346" coding_scheme="DCM" code_name="Adiabatic Tissue Homogeneity (ATH) Model"/>
   </preset>
   <preset name="Two Compartment Exchange (2CX) Model">
     <type code_value="126347" coding_scheme="DCM" code_name="Two Compartment Exchange (2CX) Model"/>
   </preset>
 <!--
 Perfusion Measurement Methods
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4102.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4102.html
 -->
   <preset name="Perfusion analysis by Arterial Spin Labeling MR technique">
     <type code_value="126302" coding_scheme="DCM" code_name="Perfusion analysis by Arterial Spin Labeling MR technique"/>
   </preset>
   <preset name="Perfusion analysis by Susceptibility MR technique">
     <type code_value="126303" coding_scheme="DCM" code_name="Perfusion analysis by Susceptibility MR technique"/>
   </preset>
   <preset name="Perfusion analysis by Susceptibility MR technique">
     <type code_value="126303" coding_scheme="DCM" code_name="Perfusion analysis by Susceptibility MR technique"/>
   </preset>
 <!--
 Arterial Input Function Measurement Methods
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4103.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4103.html
 -->
   <preset name="AIF Ignored">
     <type code_value="126360" coding_scheme="DCM" code_name="AIF Ignored"/>
   </preset>
   <preset name="Population Averaged AIF">
     <type code_value="126361" coding_scheme="DCM" code_name="Population Averaged AIF"/>
   </preset>
   <preset name="User-defined AIF ROI">
     <type code_value="126362" coding_scheme="DCM" code_name="User-defined AIF ROI"/>
   </preset>
   <preset name="Automatically Detected AIF ROI">
     <type code_value="126363" coding_scheme="DCM" code_name="Automatically Detected AIF ROI"/>
   </preset>
   <preset name="Blind Estimation of AIF">
     <type code_value="126364" coding_scheme="DCM" code_name="Blind Estimation of AIF"/>
   </preset>
 <!--
 Bolus Arrival Time Derivation Methods
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4104.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4104.html
 -->
   <preset name="Temporal Derivative Exceeds Threshold">
     <type code_value="126373" coding_scheme="DCM" code_name="Temporal Derivative Exceeds Threshold"/>
   </preset>
   <preset name="Time of Peak Concentration">
     <type code_value="126370" coding_scheme="DCM" code_name="Time of Peak Concentration"/>
   </preset>
   <preset name="Time of Leading Half-Peak Concentration">
     <type code_value="126372" coding_scheme="DCM" code_name="Time of Leading Half-Peak Concentration"/>
   </preset>
 <!--
 Perfusion Analysis Methods
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4105.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4105.html
 -->
   <preset name="Least Mean Square (LMS) deconvolution">
     <type code_value="126310" coding_scheme="DCM" code_name="Least Mean Square (LMS) deconvolution"/>
   </preset>
   <preset name="Singular Value Decomposition (SVD) deconvolution">
     <type code_value="126311" coding_scheme="DCM" code_name="Singular Value Decomposition (SVD) deconvolution"/>
   </preset>
 <!--
 Perfusion Analysis Methods
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4105.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4105.html
 -->
   <preset name="Model-free concentration-time quantitification">
     <type code_value="126342" coding_scheme="DCM" code_name="Model-free concentration-time quantitification"/>
   </preset>
 <!--
 Tracer Kinetic Model Parameters
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4107.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4107.html
 -->
   <preset name="KTrans">
     <type code_value="126312" coding_scheme="DCM" code_name="KTrans"/>
   </preset>
   <preset name="kep">
     <type code_value="126313" coding_scheme="DCM" code_name="kep"/>
   </preset>
   <preset name="ve">
     <type code_value="126314" coding_scheme="DCM" code_name="ve"/>
   </preset>
   <preset name="tau_m">
     <type code_value="126330" coding_scheme="DCM" code_name="tau_m"/>
   </preset>
   <preset name="vp">
     <type code_value="126331" coding_scheme="DCM" code_name="vp"/>
   </preset>
 <!--
 Perfusion Model Parameters
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4108.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4108.html
 -->
   <preset name="Regional Cerebral Blood Flow">
     <type code_value="113055" coding_scheme="DCM" code_name="Regional Cerebral Blood Flow"/>
   </preset>
   <preset name="Regional Blood Flow">
     <type code_value="126390" coding_scheme="DCM" code_name="Regional Blood Flow"/>
   </preset>
   <preset name="Regional Cerebral Blood Volume">
     <type code_value="113056" coding_scheme="DCM" code_name="Regional Cerebral Blood Volume"/>
   </preset>
   <preset name="Regional Blood Volume">
     <type code_value="126391" coding_scheme="DCM" code_name="Regional Blood Volume"/>
   </preset>
   <preset name="Mean Transit Time">
     <type code_value="113052" coding_scheme="DCM" code_name="Mean Transit Time"/>
   </preset>
   <preset name="Time To Peak">
     <type code_value="113069" coding_scheme="DCM" code_name="Time To Peak"/>
   </preset>
   <preset name="Oxygen Extraction Fraction">
     <type code_value="126392" coding_scheme="DCM" code_name="Oxygen Extraction Fraction"/>
   </preset>
   <preset name="Tmax">
     <type code_value="113084" coding_scheme="DCM" code_name="Tmax"/>
   </preset>
 <!--
 Model-Independent Dynamic Contrast Analysis Parameters
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4109.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4109.html
 -->
   <preset name="IAUC">
     <type code_value="126320" coding_scheme="DCM" code_name="IAUC"/>
   </preset>
   <preset name="IAUC60">
     <type code_value="126321" coding_scheme="DCM" code_name="IAUC60"/>
   </preset>
   <preset name="IAUC90">
     <type code_value="126322" coding_scheme="DCM" code_name="IAUC90"/>
   </preset>
   <preset name="IAUC190">
     <type code_value="126323" coding_scheme="DCM" code_name="IAUC180"/>
   </preset>
   <preset name="IAUCBN">
     <type code_value="126324" coding_scheme="DCM" code_name="IAUCBN"/>
   </preset>
   <preset name="IAUC60BN">
     <type code_value="126325" coding_scheme="DCM" code_name="IAUC60BN"/>
   </preset>
   <preset name="IAUC90BN">
     <type code_value="126326" coding_scheme="DCM" code_name="IAUC90BN"/>
   </preset>
   <preset name="IAUC180BN">
     <type code_value="126327" coding_scheme="DCM" code_name="IAUC90BN"/>
   </preset>
   <preset name="Time of Peak Concentration">
     <type code_value="126370" coding_scheme="DCM" code_name="Time of Peak Concentration"/>
   </preset>
   <preset name="Time of Leading Half-Peak Concentration">
     <type code_value="126372" coding_scheme="DCM" code_name="Time of Leading Half-Peak Concentration"/>
   </preset>
   <preset name="Bolus Arrival Time">
     <type code_value="126371" coding_scheme="DCM" code_name="Bolus Arrival Time"/>
   </preset>
   <preset name="Time To Peak">
     <type code_value="113069" coding_scheme="DCM" code_name="Time To Peak"/>
   </preset>
   <preset name="Temporal Derivative Threshold">
     <type code_value="126374" coding_scheme="DCM" code_name="Temporal Derivative Threshold"/>
   </preset>
   <preset name="Maximum Slope">
     <type code_value="126375" coding_scheme="DCM" code_name="Maximum Slope"/>
   </preset>
   <preset name="Time To Peak">
     <type code_value="126376" coding_scheme="DCM" code_name="Maximum Difference"/>
   </preset>
   <preset name="Tracer Concentration">
     <type code_value="126377" coding_scheme="DCM" code_name="Tracer Concentration"/>
   </preset>
   <!--
 Tracer Kinetic Modeling Covariates
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4110.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4110.html
 -->
   <preset name="Hematocrit">
     <type code_value="20570-8" coding_scheme="DCM" code_name="Hematocrit"/>
   </preset>
 
   <!--
 Contrast Characteristics
-http://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4111.html
+https://dicom.nema.org/medical/dicom/current/output/chtml/part16/sect_CID_4111.html
 -->
   <preset name="Contrast Longitudinal Relaxivity">
     <type code_value="126380" coding_scheme="DCM" code_name="Contrast Longitudinal Relaxivity"/>
   </preset>  
   
 </mitkParamapPresets>
diff --git a/Modules/DICOMweb/include/mitkDICOMweb.h b/Modules/DICOMweb/include/mitkDICOMweb.h
index 36643d4f6a..1613a8ccba 100644
--- a/Modules/DICOMweb/include/mitkDICOMweb.h
+++ b/Modules/DICOMweb/include/mitkDICOMweb.h
@@ -1,137 +1,137 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkDICOMweb_h
 #define mitkDICOMweb_h
 
 #include <MitkDICOMwebExports.h>
 
 #include "cpprest/asyncrt_utils.h"
 #include "cpprest/http_client.h"
 #include <iostream>
 #include <mitkCommon.h>
 #include <mitkIRESTManager.h>
 #include <mitkRESTUtil.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 /**
  * @brief This class represents the implementation of the RESTful DICOMweb standard
- * (http://dicom.nema.org/medical/dicom/current/output/html/part18.html). It is used to communicate DICOM data over HTTP
+ * (https://dicom.nema.org/medical/dicom/current/output/html/part18.html). It is used to communicate DICOM data over HTTP
  * to a DICOMweb enabled PACS server.
  *
  * @author Tobias Stein
  */
 
 namespace mitk
 {
 
  class MITKDICOMWEB_EXPORT DICOMweb
  {
  public:
    typedef web::http::uri_builder MitkUriBuilder;
    typedef web::http::http_request MitkRequest;
    typedef web::http::http_response MitkResponse;
    typedef web::http::methods MitkRESTMethods;
 
    DICOMweb();
 
    /**
     * @brief Creates a DICOMweb service instance which allow basic DICOM operations on the given base URI.
     *
     * @param baseURI the uri for the PACS server: for example a dcm4chee
-    * <code>http://<ip:port>/dcm4chee-arc/aets/DCM4CHEE/</code>
+    * <code>https://<ip:port>/dcm4chee-arc/aets/DCM4CHEE/</code>
     */
    DICOMweb(utility::string_t baseURI);
 
    /**
     * @brief Sends a STOW request with the file in the given path to the study given bei its UID.
     *
     * @param filePath the path to a valid DICOM file which should be send
     * @param studyUID the DICOM study uid
     * @return the task to wait for
     */
    pplx::task<void> SendSTOW(utility::string_t filePath, utility::string_t studyUID);
 
    /**
     * @brief Sends a WADO request for an DICOM object instance matching the given uid parameters and stores it at the
     * given file path.
     *
     * @param filePath the path at which the retrieved DICOM object instance will be stored
     * @param studyUID the DICOM study uid
     * @param seriesUID the DICOM series uid
     * @param instanceUID the DICOM instance uid
     * @return the task to wait for, which unfolds no value when finished
     */
    pplx::task<void> SendWADO(utility::string_t filePath,
                              utility::string_t studyUID,
                              utility::string_t seriesUID,
                              utility::string_t instanceUID);
 
    /**
     * @brief Sends a WADO request for an DICOM object series matching the given uid parameters and stores all the
     * containing instances at the given folder path.
     *
     * @param folderPath the path at which the retrieved DICOM object instances of the retrieved series will be stored
     * @param studyUID the DICOM study uid
     * @param seriesUID the DICOM series uid
     * @return the task to wait for, which unfolds the name of the first DICOM object file within the folder path
     */
    pplx::task<std::string> SendWADO(utility::string_t folderPath,
                                     utility::string_t studyUID,
                                     utility::string_t seriesUID);
 
    /**
     * @brief Sends a QIDO request containing the given parameters to filter the query.
     *
     * Example Map:
     * <code>
     *  mitk::RESTUtil::ParamMap seriesInstancesParams;
     *  seriesInstancesParams.insert(mitk::RESTUtil::ParamMap::value_type(U("limit"), U("1")));
     * </code>
     *
     * @param map the map of parameters to filter the query
     * @return the task to wait for, which unfolds the result JSON response for the request when finished
     */
    pplx::task<web::json::value> SendQIDO(mitk::RESTUtil::ParamMap map);
 
  private:
    /**
     * @brief Creates a QIDO request URI with the given parameter map
     */
    utility::string_t CreateQIDOUri(mitk::RESTUtil::ParamMap map);
 
    /**
     * @brief Creates a WADO request URI with the given parameter
     */
    utility::string_t CreateWADOUri(utility::string_t studyUID,
                                    utility::string_t seriesUID,
                                    utility::string_t instanceUID);
 
    /**
     * @brief Creates a STOW request URI with the study uid
     */
    utility::string_t CreateSTOWUri(utility::string_t studyUID);
 
    /**
     * @brief Initializes the rest manager for this service instance. Should be called in constructor to make sure the
     * public API can work properly.
     */
    void InitializeRESTManager();
 
    utility::string_t m_BaseURI;
    mitk::IRESTManager *m_RESTManager;
  };
 }
 
 #endif // DICOMweb_h
diff --git a/Modules/IGT/Testing/mitkNavigationDataTest.cpp b/Modules/IGT/Testing/mitkNavigationDataTest.cpp
index c29e40af87..c41a08123f 100644
--- a/Modules/IGT/Testing/mitkNavigationDataTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataTest.cpp
@@ -1,620 +1,620 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkTestingMacros.h"
 #include "mitkNavigationData.h"
 #include "mitkVector.h"
 #include <vnl/vnl_math.h>
 #include <itkIndent.h>
 
 
 using namespace mitk;
 
 /**
  * helper function which checks if the non position / orientation / covariance related members are all set to certain values
  */
 static bool AreBasicNavigationMembersEqual(const NavigationData::Pointer nd, const bool dataValid,
     const NavigationData::TimeStampType timeStamp, const std::string name)
 {
   bool result = true;
   result = result && (nd->IsDataValid() == dataValid);
   result = result && (mitk::Equal(nd->GetIGTTimeStamp(), timeStamp));
   result = result && (0 == name.compare(nd->GetName()));
 
   return result;
 }
 
 /**
  * helper function which checks if the basic members, meaning the members not related to position / orientation / covariance
  * are the same for two NavigationData objects.
  */
 static bool AreBasicNavigationMembersEqual(const NavigationData::Pointer nd1, const NavigationData::Pointer nd2)
 {
   return AreBasicNavigationMembersEqual(nd1, nd2->IsDataValid(),
       nd2->GetIGTTimeStamp(),
       nd2->GetName());
 }
 
 /**
  * Test if the NavigationData object nd has the correct settings for covariance matrix specific members.
  *
  * @param nd
  * @param hasPosition the desired value for the hasPosition member
  * @param hasOrientation  the desired value for the hasOrientation member
  * @param covMatrix the covariance matrix nd should have
  * @return
  */
 static bool AreCovarianceNavigationMembersEqual(const NavigationData::Pointer nd, bool hasPosition,
     bool hasOrientation, NavigationData::CovarianceMatrixType covMatrix)
 {
   bool result = true;
   result = result && (nd->GetHasPosition() == hasPosition);
   result = result && (nd->GetHasOrientation() == hasOrientation);
   result = result && (mitk::MatrixEqualElementWise(nd->GetCovErrorMatrix(), covMatrix));
 
   return result;
 }
 
 /**
  * Checks if the covariance related members of the two NavigationData objects are the same
  *
  * @see AreCovarianceNavigationMembersEqual
  *
  * @param nd1
  * @param nd2
  * @return
  */
 static bool AreCovarianceNavigationMembersEqual(const NavigationData::Pointer nd1, const NavigationData::Pointer nd2)
 {
   return AreCovarianceNavigationMembersEqual(nd1,
       nd2->GetHasPosition(), nd2->GetHasOrientation(), nd2->GetCovErrorMatrix());
 }
 
 
 /**
  * Creates a fully set NavigationData object for testing purposes.
  *
  * @return a smartpointer to the object
  */
 static mitk::NavigationData::Pointer GetTestData()
 {
   mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
   mitk::NavigationData::PositionType p;
   mitk::FillVector3D(p, 44.4, 55.5, 66.66);
   nd->SetPosition(p);
   mitk::NavigationData::OrientationType o(1.0, 2.0, 3.0, 4.0);
   nd->SetOrientation(o);
   nd->SetDataValid(true);
   nd->SetIGTTimeStamp(100.111);
   nd->SetHasPosition(false);
   nd->SetHasOrientation(false);
   mitk::NavigationData::CovarianceMatrixType m;
   m.Fill(17.17);
   m(2, 2) = 1000.01;
   nd->SetCovErrorMatrix(m);
   nd->SetName("my NavigationData");
   nd->SetPositionAccuracy(100.0);
   nd->SetOrientationAccuracy(10.0);
   return nd;
 }
 
 
 static void TestInstatiation()
 {
   // Test instantiation of NavigationData
   mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
   MITK_TEST_CONDITION(nd.IsNotNull(),"Test instatiation");
 }
 
 
 static void TestGetterSetter()
 {
   mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
 
   mitk::NavigationData::PositionType p;
   mitk::FillVector3D(p, 44.4, 55.5, 66.66);
   nd->SetPosition(p);
   MITK_TEST_CONDITION(nd->GetPosition() == p, "Set-/GetPosition()");
 
   mitk::NavigationData::OrientationType o(1.0, 2.0, 3.0, 4.0);
   nd->SetOrientation(o);
   MITK_TEST_CONDITION(nd->GetOrientation() == o, "Set-/GetOrientation()");
 
   nd->SetDataValid(true);
   MITK_TEST_CONDITION(nd->IsDataValid() == true, "Set-/IsDataValid()");
 
   nd->SetIGTTimeStamp(100.111);
   MITK_TEST_CONDITION(mitk::Equal(nd->GetIGTTimeStamp(), 100.111), "Set-/GetIGTTimeStamp()");
 
   nd->SetHasPosition(false);
   MITK_TEST_CONDITION(nd->GetHasPosition() == false, "Set-/GetHasPosition()");
 
   nd->SetHasOrientation(false);
   MITK_TEST_CONDITION(nd->GetHasOrientation() == false, "Set-/GetHasOrientation()");
 
   mitk::NavigationData::CovarianceMatrixType m;
   m.Fill(17.17);
   m(2, 2) = 1000.01;
   nd->SetCovErrorMatrix(m);
   MITK_TEST_CONDITION(nd->GetCovErrorMatrix() == m, "Set-/GetCovErrorMatrix()");
 
   nd->SetName("my NavigationData");
   MITK_TEST_CONDITION(std::string(nd->GetName()) == "my NavigationData", "Set-/GetName()");
 
   nd->SetPositionAccuracy(100.0);
   mitk::NavigationData::CovarianceMatrixType result = nd->GetCovErrorMatrix();
   MITK_TEST_CONDITION(mitk::Equal(result(0, 0), 10000.0)
     && mitk::Equal(result(1, 1), 10000.0)
     && mitk::Equal(result(2, 2), 10000.0), "SetPositionAccuracy()");
 
   nd->SetOrientationAccuracy(10.0);
   mitk::NavigationData::CovarianceMatrixType result2 = nd->GetCovErrorMatrix();
   MITK_TEST_CONDITION(mitk::Equal(result2(3, 3), 100.0)
     && mitk::Equal(result2(4, 4), 100.0)
     && mitk::Equal(result2(5, 5), 100.0), "SetOrientationAccuracy()");
 }
 
 static void TestGraft()
 {
   //create test data
   mitk::NavigationData::Pointer nd = GetTestData();
 
   mitk::NavigationData::Pointer graftedCopy = mitk::NavigationData::New();
   graftedCopy->Graft(nd);
 
   bool graftIsEqual = (nd->GetPosition() == graftedCopy->GetPosition())
     && (nd->GetOrientation() == graftedCopy->GetOrientation())
     && AreCovarianceNavigationMembersEqual(nd, graftedCopy)
     && AreBasicNavigationMembersEqual(nd, graftedCopy);
 
   MITK_TEST_CONDITION(graftIsEqual, "Graft() produces equal NavigationData object");
 }
 
 static void TestPrintSelf()
 {
   mitk::NavigationData::Pointer nd = GetTestData();
   itk::Indent myIndent = itk::Indent();
 
   MITK_TEST_OUTPUT(<<"Testing method PrintSelf(), method output will follow:");
   bool success = true;
   try
   {
     nd->PrintSelf(std::cout,myIndent);
   }
   catch(...)
   {
     success = false;
   }
   MITK_TEST_CONDITION(success, "Testing method PrintSelf().");
 }
 
 
 static void TestWrongInputs()
 {
   mitk::NavigationData::Pointer nd = GetTestData();
 
   // Test CopyInformation
   bool success = false;
   try
   {
     nd->CopyInformation(nullptr);
   }
   catch(itk::ExceptionObject&)
   {
     success = true;
   }
   MITK_TEST_CONDITION(success, "Testing wrong input for method CopyInformation.");
 
 
   // Test Graft
   success = false;
   try
   {
     nd->Graft(nullptr);
   }
   catch(itk::ExceptionObject&)
   {
     success = true;
   }
   MITK_TEST_CONDITION(success, "Testing wrong input for method Graft.");
 }
 
 
 static mitk::Quaternion quaternion;
 static mitk::Quaternion quaternion_realistic;
 static mitk::Vector3D   offsetVector;
 static mitk::Point3D    offsetPoint;
 static mitk::Matrix3D   rotation;
 
 static mitk::Quaternion quaternion2;
 static mitk::Vector3D   offsetVector2;
 static mitk::Point3D    offsetPoint2;
 static mitk::Matrix3D   rotation2;
 
 static mitk::Point3D  point;
 
 /**
  * Helper method setting up data required for tests (like points which shall be transformed by the NavigationData).
  */
 static void SetupNaviDataTests()
 {
   // set rotation matrix to
   /*
   * 0 -1  0
   * 1  0  0
   * 0  0  1
   */
   rotation.Fill(0);
   rotation[0][1] = -1;
   rotation[1][0] =  1;
   rotation[2][2] =  1;
 
   // set quaternion to quaternion equivalent
   // values calculated with javascript at
-  // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
+  // https://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
   quaternion = mitk::Quaternion(0, 0, 0.7071067811865475, 0.7071067811865476);
 
   // a more realistic quaternion from real tracking data
   quaternion_realistic = mitk::Quaternion(-0.57747,0.225593,0.366371,0.693933);
 
   // set offset to some value. Some tests need vectors, offers points.
   double offsetArray[3] = {1.0,2.0,3.123456};
   offsetVector          = offsetArray;
   offsetPoint           = offsetArray;
 
   /***** Second set of data for compose tests ****/
 
   // set rotation2 matrix to
   /*
   * 1  0  0
   * 0  0 -1
   * 0  1  0
   */
   rotation2.Fill(0);
   rotation2[0][0] =  1;
   rotation2[1][2] = -1;
   rotation2[2][1] =  1;
 
   quaternion2                = mitk::Quaternion(0.7071067811865475, 0, 0, 0.7071067811865476);
   mitk::ScalarType offsetArray2[3] = {1, 0, 0};
   offsetVector2              = offsetArray2;
   offsetPoint2               = offsetArray2;
 
   /***** Create a point to be transformed *****/
   mitk::ScalarType pointArray[] = {1.0, 3.0, 5.0};
   point        = pointArray;
 }
 
 /**
 * Helper method, which creates a NavigationData object using the data created in SetupNaviDataTests()
 */
 static mitk::NavigationData::Pointer CreateNavidata(mitk::Quaternion quaternion, mitk::Point3D offset)
 {
   mitk::NavigationData::Pointer navigationData = mitk::NavigationData::New();
   navigationData->SetOrientation(quaternion);
   navigationData->SetPosition(offset);
 
   return navigationData;
 }
 
 /**
  * Helper method which creates an affine transformation only composed by a rotation and a translation (no scalings and the likes).
  *
  * @param rotationMatrix
  * @param offset
  * @return
  */
 static mitk::AffineTransform3D::Pointer CreateAffineTransform(mitk::Matrix3D rotationMatrix, mitk::Vector3D offset)
 {
   mitk::AffineTransform3D::Pointer affineTransform3D = mitk::AffineTransform3D::New();
   affineTransform3D->SetOffset(offset);
   affineTransform3D->SetMatrix(rotationMatrix);
 
   return affineTransform3D;
 }
 
 /**
  * Test if NavigationData::GetInverse returns the correct inverse
  */
 /*static void TestInverse()
 {
   SetupNaviDataTests();
   mitk::NavigationData::Pointer nd = CreateNavidata(quaternion, offsetPoint);
 
   mitk::NavigationData::Pointer ndInverse = nd->GetInverse();
 
   // calculate expected inverted position vector: b2 = -A2b1
 
   // for -A2b1 we need vnl_vectors.
   vnl_vector_fixed<mitk::ScalarType, 3> b1;
   for (int i = 0; i < 3; ++i) {
     b1[i] = nd->GetPosition()[i];
   }
   vnl_vector_fixed<mitk::ScalarType, 3> b2;
   b2 = -(ndInverse->GetOrientation().rotate(b1));
 
   // now copy result back into our mitk::Point3D
   mitk::Point3D invertedPosition;
   for (int i = 0; i < 3; ++i) {
     invertedPosition[i] = b2[i];
   }
 
   MITK_TEST_CONDITION(mitk::Equal(nd->GetOrientation().inverse(), ndInverse->GetOrientation()),"Testing GetInverse: orientation inverted");
   MITK_TEST_CONDITION(mitk::Equal(invertedPosition, ndInverse->GetPosition()), "Testing GetInverse: position inverted");
 
   bool otherFlagsOk = AreBasicNavigationMembersEqual(nd, ndInverse)
       && AreCovarianceNavigationMembersEqual(ndInverse, false, false, nd->GetCovErrorMatrix());
   // covariance update mechanism not yet implemented, thus validities are set to false.
 
 
   MITK_TEST_CONDITION(otherFlagsOk, "Testing GetInverse: other flags are same");
 
   //########################################################################################
   //################### Second test with more realistic quaternion #########################
   //########################################################################################
 
   //just copy data to be real sure that it is not overwritten during the test
   mitk::Quaternion referenceQuaternion;
   referenceQuaternion[0] = quaternion_realistic[0];
   referenceQuaternion[1] = quaternion_realistic[1];
   referenceQuaternion[2] = quaternion_realistic[2];
   referenceQuaternion[3] = quaternion_realistic[3];
 
   mitk::Point3D referencePoint;
   referencePoint[0] = offsetPoint[0];
   referencePoint[1] = offsetPoint[1];
   referencePoint[2] = offsetPoint[2];
   referencePoint[3] = offsetPoint[3];
 
   mitk::NavigationData::Pointer nd2 = CreateNavidata(quaternion_realistic, offsetPoint);
 
   mitk::NavigationData::Pointer ndInverse2 = nd2->GetInverse();
   MITK_TEST_CONDITION(mitk::Equal(nd2->GetOrientation(),referenceQuaternion),"Testing if the method GetInverse() modifies the data which should never happen!");
   MITK_TEST_CONDITION(mitk::Equal(ndInverse2->GetOrientation(),referenceQuaternion.inverse()),"Testing if the Qrientation was inverted correctly with the realistic quaternion");
 }*/
 
 /**
  * Test if the original orientation and position are retained after inverting two times.
  */
 static void TestDoubleInverse()
 {
   SetupNaviDataTests();
   mitk::NavigationData::Pointer nd = CreateNavidata(quaternion, offsetPoint);
 
   mitk::NavigationData::Pointer ndDoubleInverse = nd->GetInverse()->GetInverse();
 
   MITK_TEST_CONDITION(mitk::Equal(nd->GetOrientation(), ndDoubleInverse->GetOrientation()),"Testing GetInverse double application: orientation preserved");
   MITK_TEST_CONDITION(mitk::Equal(nd->GetPosition(), ndDoubleInverse->GetPosition()), "Testing GetInverse double application: position preserved");
 }
 
 /**
  * Tests if NavigationData::GetInverse throws an error if the NavigationData has no inverse
  * (e.g. after it is initialized, no rotation is stored -> the transformation cannot be inverted).
  */
 static void TestInverseError()
 {
   // initialize empty NavigationData (quaternion is zeroed)
   mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
   mitk::Quaternion quaternion;
   quaternion.fill(0);
   nd->SetOrientation(quaternion);
 
   MITK_TEST_FOR_EXCEPTION(mitk::Exception, nd->GetInverse());
 }
 
 /**
  * Tests if NavigationData::TransformPoint works.
  */
 static void TestTransform()
 {
   SetupNaviDataTests();
   mitk::NavigationData::Pointer navigationData = CreateNavidata(quaternion, offsetPoint);
 
   point = navigationData->TransformPoint(point);
 
   mitk::ScalarType resultingPointArray[] = {-2, 3, 8.123456};
   mitk::Point3D    resultingPoint        = resultingPointArray;
   MITK_TEST_CONDITION(mitk::Equal(resultingPoint, point), "Testing point transformation");
 }
 
 /**
  * Tests if the construction of a NavigationData object from an
  * affine transformation which is only composed of a rotation and translation works.
  */
 static void TestAffineConstructor()
 {
   SetupNaviDataTests();
   mitk::AffineTransform3D::Pointer affineTransform3D = CreateAffineTransform(rotation, offsetVector);
 
   mitk::NavigationData::Pointer navigationData = mitk::NavigationData::New(affineTransform3D);
 
 
   MITK_TEST_CONDITION(AreBasicNavigationMembersEqual(navigationData, true, 0.0, ""),
       "Testing affine constructor: dataValid, timeStamp and name have been initialized to default values");
 
   NavigationData::CovarianceMatrixType covMatrix; // empty covariance matrix
   MITK_TEST_CONDITION(AreCovarianceNavigationMembersEqual(navigationData, true, true, covMatrix),
       "Testing affine constructor: covariance matrix values have been correctly initialized"); // TODO: discuss with Alfred
   // why this is the desired initialization of the covariance information.
 
   MITK_TEST_CONDITION(mitk::Equal(navigationData->GetPosition(), offsetPoint), "Testing affine constructor: offset");
   MITK_TEST_CONDITION(mitk::Equal(navigationData->GetOrientation(), quaternion), "Testing affine constructor: quaternion");
 }
 
 /**
  * Tests if the construction of a NavigationData object throws an error when constructing from an
  * affine transformation which is orthogonal.
  */
 static void TestAffineConstructorErrorTransposedNotInverse()
 {
   SetupNaviDataTests();
   rotation.SetIdentity();
   rotation[1][0] = 2; // this matrix has determinant = 1 (triangular matrix with ones in diagonal) but transposed != inverse
   mitk::AffineTransform3D::Pointer affineTransform3D = CreateAffineTransform(rotation, offsetVector);
 
   MITK_TEST_FOR_EXCEPTION(mitk::Exception, mitk::NavigationData::New(affineTransform3D));
 }
 
 /**
  * Tests if the construction of a NavigationData object throws an error when constructing from an
  * affine transformation which is not normal.
  */
 static void TestAffineConstructorErrorDeterminantNonEqualOne()
 {
   SetupNaviDataTests();
   rotation.SetIdentity();
   rotation[0][0] = 2; // determinant for diagonal matrices is product of diagonal elements => det = 2
   mitk::AffineTransform3D::Pointer affineTransform3D = CreateAffineTransform(rotation, offsetVector);
 
   MITK_TEST_FOR_EXCEPTION(mitk::Exception, mitk::NavigationData::New(affineTransform3D));
 }
 
 
 /**
  * Tests if the error suppression mechanism works if a NavigationData object is created from a
  * invalid affine transformation (one that is not only rotation and translation).
  */
 static void TestAffineConstructorErrorCheckingFalse()
 {
   SetupNaviDataTests();
   rotation.SetIdentity();
   rotation[0][0] = 2; // determinant for diagonal matrices is product of diagonal elements => det = 2
   mitk::AffineTransform3D::Pointer affineTransform3D = CreateAffineTransform(rotation, offsetVector);
 
   bool exceptionSuppressed = true;
   try
   {
     mitk::NavigationData::New(affineTransform3D, false);
   }
   catch (mitk::Exception&)
   {
     exceptionSuppressed = false;
   }
 
   MITK_TEST_CONDITION(exceptionSuppressed, "Test affine constructor: exception can be suppressed.")
 }
 
 /**
  * Test if NavigationData::GetAffineTransform3D() returns the correct affine transformation.
  */
 static void TestAffineGetter()
 {
   SetupNaviDataTests();
   mitk::NavigationData::Pointer navigationData = CreateNavidata(quaternion, offsetPoint);
 
   mitk::AffineTransform3D::Pointer affineTransform = navigationData->GetAffineTransform3D();
 
   MITK_TEST_CONDITION(mitk::Equal(affineTransform->GetOffset(), offsetVector), "Testing AffineTransform3D getter: offset");
   MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(affineTransform->GetMatrix(), rotation), "Testing AffineTransform3D getter: rotation");
 }
 
 /**
 * This test tests the complete chain from affineTransform -> NavigationData -> affineTransform
 */
 static void TestAffineToNaviDataToAffine()
 {
   SetupNaviDataTests();
   mitk::AffineTransform3D::Pointer affineTransform3D = CreateAffineTransform(rotation, offsetVector);
 
   // there and back again: affineTransform -> NavigationData -> affineTransform
   mitk::NavigationData::Pointer navigationData = mitk::NavigationData::New(affineTransform3D);
   mitk::AffineTransform3D::Pointer affineTransform3D_2;
   affineTransform3D_2 = navigationData->GetAffineTransform3D();
 
   MITK_TEST_CONDITION(mitk::Equal(affineTransform3D->GetOffset(), affineTransform3D_2->GetOffset()), "Testing affine -> navidata -> affine chain: offset");
   MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(affineTransform3D->GetMatrix(), affineTransform3D_2->GetMatrix()), "Testing affine -> navidata -> affine chain: rotation");
 }
 
 
 static void TestCompose(bool pre = false)
 {
   SetupNaviDataTests();
   mitk::NavigationData::Pointer    nd = CreateNavidata(quaternion, offsetPoint);
   mitk::AffineTransform3D::Pointer at = CreateAffineTransform(rotation, offsetVector);
   // second transform for composition
   mitk::NavigationData::Pointer    nd2 = CreateNavidata(quaternion2, offsetPoint2);
   mitk::AffineTransform3D::Pointer at2 = CreateAffineTransform(rotation2, offsetVector2);
   // save point for affinetransform
   mitk::Point3D point2 = point;
 
 
   nd->Compose(nd2, pre);
   point  = nd->TransformPoint(point);
 
   at->Compose(at2, pre);
   point2 = at->TransformPoint(point2);
 
   MITK_TEST_CONDITION(mitk::Equal(point, point2), "Compose pre = " << pre << ": composition works ");
 
   bool covarianceValidityReset = !nd->GetHasOrientation() && !nd->GetHasPosition();
 
   MITK_TEST_CONDITION(covarianceValidityReset, "Compose pre = " << pre << ": covariance validities reset because not implemented yet.");
 }
 
 static void TestReverseCompose()
 {
   TestCompose(true);
 }
 
 /**
  * Tests the clone method.
  */
 static void TestClone()
 {
   SetupNaviDataTests();
   mitk::NavigationData::Pointer    nd = CreateNavidata(quaternion, offsetPoint);
   mitk::NavigationData::Pointer    myClone = nd->Clone();
   MITK_TEST_CONDITION(mitk::Equal(*nd,*myClone,mitk::eps,true), "Test if clone is equal to original object.");
 
   //change clone, original object should not change
   mitk::Point3D myPoint;
   mitk::FillVector3D(myPoint,121,32132,433);
   myClone->SetPosition(myPoint);
   MITK_TEST_CONDITION(!mitk::Equal(*nd,*myClone), "Test if clone could be modified without changing the original object.");
 }
 
 
 /**
 * This function is testing the Class mitk::NavigationData. For most tests we would need the MicronTracker hardware, so only a few
 * simple tests, which can run without the hardware are implemented yet (2009, January, 23rd). As soon as there is a working
 * concept to test the tracking classes which are very close to the hardware on all systems more tests are needed here.
 */
 int mitkNavigationDataTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("NavigationData");
 
   TestInstatiation();
   TestGetterSetter();
   TestGraft();
   TestPrintSelf();
   TestWrongInputs();
 
   TestAffineConstructor();
   TestAffineConstructorErrorDeterminantNonEqualOne();
   TestAffineConstructorErrorTransposedNotInverse();
   TestAffineConstructorErrorCheckingFalse();
 
   TestAffineGetter();
   TestAffineToNaviDataToAffine();
 
   TestTransform();
 
   //TestInverse(); Fails under MAC, see bug 18306
   TestDoubleInverse();
   TestInverseError();
 
   TestCompose();
   TestReverseCompose();
   TestClone();
 
   MITK_TEST_END();
 }
diff --git a/Modules/IGT/TrackingDevices/mitkItkNonUniformBSpline.h b/Modules/IGT/TrackingDevices/mitkItkNonUniformBSpline.h
index 95a9bc3b83..1c60854968 100644
--- a/Modules/IGT/TrackingDevices/mitkItkNonUniformBSpline.h
+++ b/Modules/IGT/TrackingDevices/mitkItkNonUniformBSpline.h
@@ -1,206 +1,206 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 
 /*********************************
-  This file was taken from ITK, CVS version 1.8 to circumvent a bug in ITK release 3.18 (see http://public.kitware.com/Bug/view.php?id=10633
+  This file was taken from ITK, CVS version 1.8 to circumvent a bug in ITK release 3.18
  *********************************/
 
 #ifndef __itkNonUniformBSpline_h
 #define __itkNonUniformBSpline_h
 
 #if defined(_MSC_VER)
 #pragma warning ( disable : 4786 )
 #endif
 
 #include <vector>
 
 #include "itkPoint.h"
 #include "itkObject.h"
 #include "itkObjectFactory.h"
 #include "itkArray.h"
 
 namespace itk {
 
 /**
  * \class NonUniformBSpline
  * \brief BSpline with nonuniform knot spacing.
  * \warning This class was taken from an earlier ITK version and slightly modified.
  * The original itkNonUniformBSpline is deprecated in ITK 4.3. Currently, the
  * mitkItkNonUniformBSpline is only used inside the virtual tracking device.
  *
  * This class is a bspline with nonuniform knot spacing. The
  * use can specify a set of points and a set of knots and the
  * spline will attempt to find the control points which will
  * cause the spline to interpolate the points.
  */
 
 template < unsigned int TDimension = 3 >
 class NonUniformBSpline
   : public Object
 {
 public:
   /**
   Typedefs
   */
   typedef NonUniformBSpline                            Self;
   typedef Object                                       Superclass;
   typedef SmartPointer < Self >                        Pointer;
   typedef SmartPointer < const Self >                  ConstPointer;
   typedef double                                       ScalarType;
   typedef itk::Point< ScalarType, TDimension >         PointType;
   typedef std::vector < PointType >                    PointListType;
   typedef PointListType *                              PointListPointer;
   typedef std::vector < double >                       KnotListType;
   typedef std::vector<double>                          CoordinateListType;
   typedef itk::Point<double, TDimension >              ControlPointType;
   typedef std::vector< ControlPointType >              ControlPointListType;
   typedef ControlPointListType *                       ControlPointListPointer;
   typedef std::vector<double>                          ChordLengthListType;
 
   /** Method for creation through the object factory. */
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
   /** Method for creation through the object factory. */
   itkTypeMacro( NonUniformBSpline, Object );
 
   /**
    * Set points which the spline will attempt to interpolate.
    */
   void SetPoints( PointListType & newPoints );
 
   /**
    * Get the points the spline is trying to interpolate.
    */
   const PointListType & GetPoints() const;
 
   /**
    * Set the knot vector. Knots may be nonuniformly spaced.
    * Knots will be rescaled to be between 0 and 1.
    */
   void SetKnots( KnotListType & newKnots);
 
   /**
    * Get the knot vector.
    */
   const KnotListType & GetKnots() const;
 
   /**
    * Computes the chord lengths based on the points.
    */
   void ComputeChordLengths();
 
   /**
    * Methods for evaluating the spline.
    * The parameterization is always between 0 and 1.
    */
   PointType  EvaluateSpline(const Array<double> & p) const;
   PointType  EvaluateSpline( double t ) const;
 
   /**
    * Compute the control points.
    */
   void ComputeControlPoints();
 
   /**
    * Set the control points for the spline.
    */
   void SetControlPoints( ControlPointListType& ctrlpts );
 
   /**
    * Get the control points for the spline
    */
   const ControlPointListType & GetControlPoints() const;
 
   /**
    * Evaluate the basis functions directly.
    * order - order of the basis function, i.e. 3 = cubic.
    * i - basis function number, zero based.
    * t - parameter of the spline.
    */
   double NonUniformBSplineFunctionRecursive(unsigned int order, unsigned int i, double t) const;
 
   /**
    * Set the order of the spline.
    */
   itkSetMacro( SplineOrder, unsigned int );
   itkGetConstReferenceMacro( SplineOrder, unsigned int );
 
 
 protected:
 
   /**
    * Constructor
    */
   NonUniformBSpline();
 
   /**
    * Virtual destructor
    */
   ~NonUniformBSpline() override;
 
   /**
    * Method to print the object.
    */
   void PrintSelf( std::ostream& os, Indent indent ) const override;
 
   /**
    * Points that the spline attempts to intepolate.
    */
   PointListType         m_Points;
 
   /**
    * The knots of spline.
    */
   KnotListType          m_Knots;
 
   /**
    * The control points of the spline.
    */
   ControlPointListType  m_ControlPoints;
 
   /**
    * The chord length computed from m_Points.
    */
   ChordLengthListType   m_ChordLength;
 
   /**
    * The cumulative chord length computed from m_Points
    */
   ChordLengthListType   m_CumulativeChordLength;
 
   /**
    * The order of the spline.
    */
   unsigned int          m_SplineOrder;
 
   /**
    * The spatial dimension. Saved from the template parameter.
    */
   unsigned int          m_SpatialDimension;
 
 };
 
 } // end namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "mitkItkNonUniformBSpline.txx"
 #endif
 
 
 #endif // __itkNonUniformBSpline_h
diff --git a/Modules/IGT/TrackingDevices/mitkItkNonUniformBSpline.txx b/Modules/IGT/TrackingDevices/mitkItkNonUniformBSpline.txx
index 95c61f3a0b..44e8532bca 100644
--- a/Modules/IGT/TrackingDevices/mitkItkNonUniformBSpline.txx
+++ b/Modules/IGT/TrackingDevices/mitkItkNonUniformBSpline.txx
@@ -1,433 +1,433 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 
 /*********************************
-  This file was taken from ITK, CVS version 1.13 to circumvent a bug in ITK release 3.18 (see http://public.kitware.com/Bug/view.php?id=10633
+  This file was taken from ITK, CVS version 1.13 to circumvent a bug in ITK release 3.18
  *********************************/
 
 #ifndef __itkNonUniformBSpline_txx
 #define __itkNonUniformBSpline_txx
 
 #if defined(_MSC_VER)
 #pragma warning ( disable : 4786 )
 #endif
 
 #include "mitkItkNonUniformBSpline.h"
 
 #include "vnl/vnl_vector.h"
 #include "vnl/vnl_matrix.h"
 #include "vnl/algo/vnl_lsqr.h"
 #include "vnl/vnl_linear_system.h"
 
 
 // #define DEBUG_SPLINE
 
 namespace itk
 {
 
 /** Constructor */
 template< unsigned int TDimension >
 NonUniformBSpline< TDimension >
 ::NonUniformBSpline()
 {
   // Cubic bspline => 4th order
   m_SplineOrder = 3;
   m_SpatialDimension = TDimension;
 }
 
 /** Destructor */
 template< unsigned int TDimension >
 NonUniformBSpline< TDimension >
 ::~NonUniformBSpline()
 {
 }
 
 /** Print the object */
 template< unsigned int TDimension >
 void
 NonUniformBSpline< TDimension >
 ::PrintSelf( std::ostream& os, Indent indent ) const
 {
   Superclass::PrintSelf( os, indent );
   os << indent << "NonUniformBSpline(" << this << ")" << std::endl;
 
   os << indent << "Chord lengths : " << std::endl;
   for (ChordLengthListType::const_iterator iter = m_CumulativeChordLength.begin();
        iter != m_CumulativeChordLength.end();
        iter++)
     {
     os << indent << indent << *iter << std::endl;
     }
   os << indent << "Knots : " << std::endl;
   for (KnotListType::const_iterator kiter = m_Knots.begin();
        kiter != m_Knots.end();
        kiter++)
     {
     os << indent << indent << *kiter << std::endl;
     }
   os << indent << "Control Points : " << std::endl;
   for (typename ControlPointListType::const_iterator cpiter = m_ControlPoints.begin();
        cpiter != m_ControlPoints.end();
        cpiter++)
     {
     os << indent << indent << *cpiter << std::endl;
     }
 }
 
 
 /** Set the list of points composing the tube */
 template< unsigned int TDimension >
 void
 NonUniformBSpline< TDimension >
 ::SetPoints( PointListType & points )
 {
   m_Points.clear();
 
   typename PointListType::iterator it,end;
   it = points.begin();
   end = points.end();
   while(it != end)
     {
     m_Points.push_back(*it);
     it++;
     }
 
   this->Modified();
 }
 
 /** Set the list of points composing the tube */
 template< unsigned int TDimension >
 void
 NonUniformBSpline< TDimension >
 ::SetKnots( KnotListType & knots )
 {
   m_Knots.clear();
 
   int len = knots.size();
   double max_knot = knots[len - 1];
 
   typename KnotListType::iterator it;
   typename KnotListType::iterator end;
 
   it = knots.begin();
   end = knots.end();
 
   while(it != end)
     {
     m_Knots.push_back(*it/max_knot);
     it++;
     }
 
   this->Modified();
 }
 
 template< unsigned int TDimension >
 double
 NonUniformBSpline< TDimension >
 ::NonUniformBSplineFunctionRecursive(unsigned int order, unsigned int i, double t) const
 {
   if (order == 1)
     {
     if (m_Knots[i] <= t && t < m_Knots[i+1])
       {
       return 1;
       }
     else
       {
       return 0;
       }
     }
 
   //
   // Be careful, we must use the passed in parameter for the order since this
   // function is recursive.
   //
   double numer1 = (t - m_Knots[i]) * NonUniformBSplineFunctionRecursive(order-1, i, t);
   double denom1 = (m_Knots[i+order-1] - m_Knots[i]);
   double val1 = numer1 / denom1;
   if (denom1 == 0 && numer1 == 0)
     val1 = 0;
   else if (denom1 == 0)
     std::cout << "Error : " << denom1 << ", " << numer1 << std::endl;
 
   double numer2 = (m_Knots[i+order] - t) * NonUniformBSplineFunctionRecursive(order-1, i+1, t);
   double denom2 = (m_Knots[i + order] - m_Knots[i+1]);
   double val2 = numer2 / denom2;
   if (denom2 == 0 && numer2 == 0)
     val2 = 0;
   else if (denom2 == 0)
     std::cout << "Error : " << denom2 << ", " << numer2 << std::endl;
 
   return val1 + val2;
 }
 
 template< unsigned int TDimension >
 void
 NonUniformBSpline< TDimension >
 ::ComputeChordLengths()
 {
   m_ChordLength.clear();
   m_CumulativeChordLength.clear();
 
   m_ChordLength.push_back(0);
   m_CumulativeChordLength.push_back(0);
 
   double total_chord_length = 0.0;
   ChordLengthListType temp;
 
   for (::size_t i = 0; i < m_Points.size()-1; i++)
     {
     PointType pt = m_Points[i];
     PointType pt2 = m_Points[i+1];
 
     double chord = pt.EuclideanDistanceTo(pt2);
     m_ChordLength.push_back(chord);
     total_chord_length = total_chord_length + chord;
     temp.push_back(total_chord_length);
     }
 
   for (ChordLengthListType::iterator aiter = temp.begin();
        aiter != temp.end();
        aiter++)
     {
     m_CumulativeChordLength.push_back(*aiter/total_chord_length);
     }
 
   //
   // Debug printouts
   //
 #ifdef DEBUG_SPLINE
   std::cout << "Total chord length : " << total_chord_length << std::endl;
 
   std::cout << "Chord length : " << std::endl;
   for (ChordLengthListType::iterator aiter2 = m_ChordLength.begin();
        aiter2 != m_ChordLength.end();
        aiter2++)
     {
     std::cout << *aiter2 << std::endl;
     }
 
   std::cout << "Cumulative chord length : " << std::endl;
   for (ChordLengthListType::iterator aiter3 = m_CumulativeChordLength.begin();
        aiter3 != m_CumulativeChordLength.end();
        aiter3++)
     {
     std::cout << *aiter3 << std::endl;
     }
   std::cout << std::endl;
 #endif
 }
 
 template< unsigned int TDimension >
 void
 NonUniformBSpline< TDimension >
 ::SetControlPoints( ControlPointListType& ctrlpts )
 {
   m_ControlPoints.clear();
   for (typename ControlPointListType::iterator iter = ctrlpts.begin();
        iter != ctrlpts.end();
        iter++)
     {
     m_ControlPoints.push_back(*iter);
     }
   this->Modified();
 }
 
 
 template< unsigned int TDimension >
 const typename
 NonUniformBSpline< TDimension >::ControlPointListType &
 NonUniformBSpline< TDimension >::GetControlPoints() const
 {
   return this->m_ControlPoints;
 }
 
 
 template< unsigned int TDimension >
 const typename
 NonUniformBSpline< TDimension >::KnotListType &
 NonUniformBSpline< TDimension >::GetKnots() const
 {
   return this->m_Knots;
 }
 
 
 template< unsigned int TDimension >
 const typename
 NonUniformBSpline< TDimension >::PointListType &
 NonUniformBSpline< TDimension >::GetPoints() const
 {
   return this->m_Points;
 }
 
 
 template< unsigned int TDimension >
 void
 NonUniformBSpline< TDimension >::ComputeControlPoints()
 {
   unsigned int dim = m_Points[0].GetPointDimension();
 
 #ifdef DEBUG_SPLINE
   std::cout << "Points have dimension : " << dim  << std::endl;
 #endif
 
   //
   // +1 in cols for radius
   //
   vnl_matrix<double> data_matrix(m_Points.size(), dim);
 
   //
   // Form data point matrix
   //
   int rr = 0;
   for (typename PointListType::iterator iter = m_Points.begin();
        iter != m_Points.end();
        iter++)
     {
     PointType pt = (*iter);
     for (unsigned int i = 0; i < dim; i++)
       {
       data_matrix(rr, i) = pt.GetVnlVector()[i];
       }
     rr++;
     }
 
 #ifdef DEBUG_SPLINE
   std::cout << std::endl << "Data matrix" << std::endl;
   std::cout << data_matrix << std::endl;
 #endif
 
   //
   // Form basis function matrix
   //
   //int num_basis_functions = 2 * m_SplineOrder - 1;
   //int num_basis_functions = m_Points.size();
   int num_rows = m_Points.size();
 
   //
   // Assumes multiplicity k (m_SplineOrder at the ends).
   //
   int num_cols = m_Knots.size() - m_SplineOrder;
 
   vnl_matrix<double> N_matrix(num_rows, num_cols);
 
   //N_matrix(0, 0) = 1.0;
 
   for (int r = 0; r < num_rows; r++)
     {
     for (int c = 0; c < num_cols; c++)
       {
       double t = m_CumulativeChordLength[r];
       N_matrix(r, c) = NonUniformBSplineFunctionRecursive(m_SplineOrder, c, t);
       }
     }
 
   N_matrix(num_rows-1, num_cols-1) = 1.0;
 
 #ifdef DEBUG_SPLINE
   std::cout << "Basis function matrix : " << std::endl;
   std::cout << N_matrix << std::endl;
 #endif
 
 //FIXME: Use the LSQR linear solver here:
   vnl_matrix<double> B;
 
 // = vnl_matrix_inverse<double>(N_matrix.transpose() * N_matrix) * N_matrix.transpose() * data_matrix;
 
 //  vnl_linear_system ls( N_matrix.rows(), N_matrix.cols() );
 
 //  vnl_lsqr solver( ls );
 
 
 //#ifdef DEBUG_SPLINE
   std::cout << "Control point matrix : " << std::endl;
   std::cout << B << std::endl;
 //#endif
 
   m_ControlPoints.clear();
 
   for ( unsigned int j = 0; j < B.rows(); j++ )
     {
     vnl_vector<double> v = B.get_row(j);
     itk::Vector<double> iv;
     iv.SetVnlVector(v);
     itk::Point<double, TDimension> pt;
     for ( unsigned int d = 0; d < dim; d++ )
       {
       pt[d] = v(d);
       }
     m_ControlPoints.push_back(pt);
     }
   return;
 }
 
 template< unsigned int TDimension >
 typename NonUniformBSpline<TDimension>::PointType
 NonUniformBSpline< TDimension >
 ::EvaluateSpline(const itk::Array<double> & p) const
 {
   double t = p[0];
 
   return EvaluateSpline(t);
 }
 
 template< unsigned int TDimension >
 typename NonUniformBSpline<TDimension>::PointType
 NonUniformBSpline< TDimension >
 ::EvaluateSpline(double t) const
 {
   int i = 0;
 
   vnl_vector<double> result(TDimension);
   result.fill(0);
 
   for (typename ControlPointListType::const_iterator cpiter = m_ControlPoints.begin();
        cpiter != m_ControlPoints.end();
        cpiter++)
     {
     ControlPointType pt = *cpiter;
     vnl_vector<double> v = pt.GetVnlVector();
 
     const double N =  this->NonUniformBSplineFunctionRecursive(m_SplineOrder, i, t);
 
     for( unsigned j = 0; j < TDimension; j++ )
       {
       result[j] += N * v[j];
       }
 
     i++;
     }
 
   double array[TDimension];
   for ( unsigned int d = 0; d < TDimension; d++ )
     {
     array[d] = result[d];
     }
 
   ControlPointType sum(array);
 #ifdef DEBUG_SPLINE
   std::cout << "Result : " << result << std::endl;
   std::cout << "Sum : " << sum << std::endl;
 #endif
 
   return sum;
 }
 
 } // end namespace itk
 
 #endif
diff --git a/Modules/IGT/TrackingDevices/mitkOptitrackTrackingDevice.h b/Modules/IGT/TrackingDevices/mitkOptitrackTrackingDevice.h
index 2ddbc7cfa8..f2b45db6fc 100644
--- a/Modules/IGT/TrackingDevices/mitkOptitrackTrackingDevice.h
+++ b/Modules/IGT/TrackingDevices/mitkOptitrackTrackingDevice.h
@@ -1,301 +1,301 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef OptitrackTrackingDevice_H_HEADER_INCLUDED
 #define OptitrackTrackingDevice_H_HEADER_INCLUDED
 
 #include <MitkIGTExports.h>
 #include <mitkTrackingDevice.h>
 #include <mitkTrackingTypes.h>
 #include <mitkIGTTimeStamp.h>
 #include <itksys/SystemTools.hxx>
 #include <string>
 #include <cstdlib>
 #include <cstdio>
 #include <ctime>
 #include <thread>
 #include <mutex>
 
 /**
 * \brief IGT Exceptions
 */
 #include "mitkIGTIOException.h"
 #include "mitkIGTTimeStamp.h"
 #include "mitkIGTException.h"
 
 /**
 * \brief OptitrackTrackingTools
 */
 #include "mitkOptitrackTrackingTool.h"
 
 
 namespace mitk
 {
   /** Documentation:
   *   \brief An object of this class represents the Optitrack device. You can add tools to this
   *          device, then open the connection and start tracking. The tracking device will then
   *          continuously update the tool coordinates. Remember that it will be necessary to
   *       to have a license for using the Optitrack System.
-  *       See  http://www.naturalpoint.com/ for details.
+  *       See  https://www.naturalpoint.com/ for details.
   *   \author E. Marinetto (emarinetto@hggm.es) Instituto de Investigación Sanitaria Gregorio Marañón, Madrid, Spain. & M. Noll (matthias.noll@igd.fraunhofer.de) Cognitive Computing & Medical Imaging | Fraunhofer IGD
   *   \ingroup IGT
   */
   class MITKIGT_EXPORT OptitrackTrackingDevice : public mitk::TrackingDevice
   {
 
   friend class OptitrackTrackingTool;
 
   public:
     mitkClassMacro(OptitrackTrackingDevice, mitk::TrackingDevice);
     itkNewMacro(Self);
 
     /**
     * @returns Returns true if the Optitrack tracker is installed on this build (means activated in CMAKE). False if not.
     */
     bool IsDeviceInstalled() override;
 
     // Define the Type of Tracker as DefinitionOfTool (MITK)
     typedef mitk::TrackingDeviceType OptiTrackTrackingDeviceType;
 
     /**
     * \brief Open the Connection with the Tracker. Calls LoadCalibration function and set the system up with the calibration file.
     * Remember that you have to set a calibration file first to open a correct connection to the Optical Tracking System.
     * \return Returns true if the connection is well done. Throws an exception if an error occures related to the Optitrack API messages.
     * @throw mitk::IGTException Throws an exception if InitializeCameras or LoadCalibration failed.
     */
     bool OpenConnection() override;
 
     /**
     * \brief Close the Connection with the Tracker. Also CleanUp the Optitrack variables using the API: TT_CleanUp and TT_ShutDown.
     * Sometimes API does not work properly and some problems during the Clean Up has been reported.
     * \return Returns true if the cleaning up and shutdown worked correctly. Throws an exception if an error occures related to the Optitrack API messages.
     * @throw mitk::IGTException Throws an exception if the System cannot ShutDown now or was not initialized.
     */
     bool CloseConnection() override;
 
     /**
     * \brief Start to Track the tools already defined. If no tools are defined for this tracker, it returns an error.
     * Tools can be added using either AddToolByDescriptionFile or AddToolsByConfigurationFiles
     * \return Returns true at least one tool was defined and the tracking is correct
     * @throw mitk::IGTException Throws an exception if the System is not in State Ready .
     */
     bool StartTracking() override;
 
     /**
     * \brief Stop the Tracking Thread and tools will not longer be updated.
     * \return Returns true if Tracking thread could be stopped.
     * @throw mitk::IGTException Throws an exception if System is not in State Tracking.
     */
     bool StopTracking() override;
 
     /**
     * \brief Return the tool pointer of the tool number toolNumber
     * \param toolNumber The number of the tool which should be given back.
     * \return Returns the tool which the number "toolNumber". Returns nullptr, if there is
     * no tool with this number.
     */
     TrackingTool* GetTool(unsigned int toolNumber) const override;
 
     /**
     * \brief Return the tool pointer of the tool number toolNumber
     * \param toolNumber The number of the tool which should be given back.
     * \return Returns the tool which the number "toolNumber". Returns nullptr, if there is
     * no tool with this number.
     * @throw mitk::IGTException Throws an exception if there is the required tool does not exist.
     */
     OptitrackTrackingTool* GetOptitrackTool(unsigned int toolNumber) const;
 
     /**
     * \brief Returns the number of defined tools
     * \return Returns the number of defined tools in the Optitrack device.
     */
     unsigned int GetToolCount() const override;
 
 /** @brief Sets the directory where the calibration file of the MicronTracker can be found. */
     itkSetMacro(Exp,int);
 
   /** @brief Gets the current calibration directory. */
     itkGetMacro(Exp,int);
 
 /** @brief Sets the directory where the calibration file of the MicronTracker can be found. */
     itkSetMacro(Led,int);
 
   /** @brief Gets the current calibration directory. */
     itkGetMacro(Led,int);
 
 /** @brief Sets the directory where the calibration file of the MicronTracker can be found. */
     itkSetMacro(Thr,int);
 
   /** @brief Gets the current calibration directory. */
     itkGetMacro(Thr,int);
 
     /** @brief Sets the file where the calibration of the OptitrackTracker can be found. */
    void SetCalibrationPath(std::string calibrationPath);
 
     /** @brief Gets the current calibration file. */
     itkGetMacro(calibrationPath,std::string);
 
     /**
     * \brief Start the Tracking Thread for the tools
     */
     void ThreadStartTracking();
 
     /**
     * \brief Update each tool location in the list m_AllTools
     * @throw mitk::IGTException Throws an exception if the getting data operation failed for a defined tool
     */
     void TrackTools();
 
     /**
     * \brief Load the Calibration file to the Optitrack System and set the cameras in calibrated locations
     * \return Returns true if the calibration was uploaded correctly
     * @throw mitk::IGTException Throws an exception if Calibration Path is empty, the System cannot load a calibration file or System is not ready for load a calibration file because it has not been initialized yet
     */
     bool LoadCalibration();
 
     /**
     * \brief Set the Cameras Exposure, Threshold and Intensity of IR LEDs. By Default it set the Video type to 4: Precision Mode for tracking
     * //== VideoType:
         * //==     0 = Segment Mode
         * //==     1 = Grayscale Mode
         * //==     2 = Object Mode
         * //==     4 = Precision Mode
         * //==     6 = MJPEG Mode     (V100R2 only)
     * \return Returns true if all cameras were set up correctly
     * @throw mitk::IGTException Throws an exception if System is not Initialized
     */
     bool SetCameraParams(int exposure, int threshold, int intensity, int videoType = 4);
 
     /**
     * \brief Initialize the Optitrack System
     * \return Returns true if system was initialized correctly
     * @throw mitk::IGTException Throws an exception if the Optitrack Tracking System cannot be initialized
     */
     bool InitializeCameras();
 
     /**
     * \brief Add a new tool using a text file which described the tool.
     * The file must to have the next structure
     *    ToolName
     *    \#NumberOfMarkers
     *    X Y Z - for the first marker
     *    X Y Z - for the second marker
     *    ...
     *    X Y Z - for the last marker, the number \#NumberOfMarkers
     *    X Y Z - for the PIVOT point
     * \return Returns true if system was initialized correctly
     * @throw mitk::IGTException Throws an exception if Tool could not be added or System is not Initialized
     */
     bool AddToolByDefinitionFile(std::string fileName); // ^????? We should give an example of defined tool
 
     /**
     * \brief This function load a file with Tools definitions provided for the software
     * \return Returns true if file is correctly loaded with all the tools
     * @throw mitk::IGTException Throws an exception if there is an error during the Initialization
     */
 //    bool AddToolByConfigurationFil(std::string fileName); // For next release....
 
   protected:
     /**
     * \brief Constructor & Destructor of the class
     */
     OptitrackTrackingDevice();
     ~OptitrackTrackingDevice() override;
 
 
   private:
     /**
     * \brief The calibration file path. This file is produced by TrackingTools/Motive software.
     * This variable is used to determine what will be the calibration file absolute path.
     */
     std::string m_calibrationPath;
 
     /**
     * \brief The Cameras Exposition
     */
     int m_Exp;
 
     /**
     * \brief The Cameras LED power
     */
     int m_Led;
 
     /**
     * \brief The Cameras Thr
     */
     int m_Thr;
 
     /**
     * \brief Described if the system was initialized at least once during execution. This is due
     * to some reported problems during the clean up , shutdown and initialization again.
     */
     bool m_initialized;
 
     /**
     * \brief Vector of pointers pointing to all defined tools
     */
     std::vector<mitk::OptitrackTrackingTool::Pointer> m_AllTools;
 
     /**
     * \brief Mutex for coordinated access of tool container
     */
     mutable std::mutex m_ToolsMutex;
 
     std::thread m_Thread;
 
 
 /* TODO:
 
 // For Tracking
 -bool AddToolByConfigurationFil(std::string fileName);
 TTAPI   NPRESULT TT_LoadTrackables (const char *filename); //== Load Trackables ======----
 TTAPI   NPRESULT TT_SaveTrackables (const char *filename); //== Save Trackables ======----
 TTAPI   NPRESULT TT_AddTrackables  (const char *filename); //== Add  Trackables ======----
 TTAPI   void     TT_ClearTrackableList();             //== Clear all trackables   =====---
 TTAPI   NPRESULT TT_RemoveTrackable(int Index);       //== Remove single trackable ====---
 TTAPI   void     TT_SetTrackableEnabled(int index, bool enabled);    //== Set Tracking   ====---
 TTAPI   bool     TT_TrackableEnabled(int index);                     //== Get Tracking   ====---
 TTAPI   int      TT_TrackableMarkerCount(int index);             //== Get marker count   ====---
 TTAPI   void     TT_TrackableMarker(int RigidIndex,              //== Get Trackable mrkr ====---
                         int MarkerIndex, float *x, float *y, float *z);
 
 //For projects
 TTAPI   NPRESULT TT_LoadProject(const char *filename); //== Load Project File ==========--
 TTAPI   NPRESULT TT_SaveProject(const char *filename); //== Save Project File ==========--
 
 // For VRPN connection
 TTAPI   NPRESULT TT_StreamVRPN(bool enabled, int port);//== Start/stop VRPN Stream ===----
 
 // For frame testing
 TTAPI   int      TT_FrameMarkerCount();               //== Returns Frame Markers Count ---
 TTAPI   float    TT_FrameMarkerX(int index);          //== Returns X Coord of Marker -----
 TTAPI   float    TT_FrameMarkerY(int index);          //== Returns Y Coord of Marker -----
 TTAPI   float    TT_FrameMarkerZ(int index);          //== Returns Z Coord of Marker -----
 TTAPI   int      TT_FrameMarkerLabel(int index);      //== Returns Label of Marker -------
 TTAPI   double   TT_FrameTimeStamp();                 //== Time Stamp of Frame (seconds) -
 
 // For cameras handling
 TTAPI   int      TT_CameraCount();                    //== Returns Camera Count =====-----
 TTAPI   float    TT_CameraXLocation(int index);       //== Returns Camera's X Coord =-----
 TTAPI   float    TT_CameraYLocation(int index);       //== Returns Camera's Y Coord =-----
 TTAPI   float    TT_CameraZLocation(int index);       //== Returns Camera's Z Coord =-----
 TTAPI   float    TT_CameraOrientationMatrix(int camera, int index); //== Orientation -----
 
 
 */
 
 
 };
 
 
 }
 #endif
diff --git a/Modules/IGT/TrackingDevices/mitkOptitrackTrackingTool.h b/Modules/IGT/TrackingDevices/mitkOptitrackTrackingTool.h
index 4a2f45c2ca..d66038fa97 100644
--- a/Modules/IGT/TrackingDevices/mitkOptitrackTrackingTool.h
+++ b/Modules/IGT/TrackingDevices/mitkOptitrackTrackingTool.h
@@ -1,213 +1,213 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef OptiTrackTrackingTool_H_HEADER_INCLUDED_
 #define OptiTrackTrackingTool_H_HEADER_INCLUDED_
 
 #include <MitkIGTExports.h>
 #include "mitkTrackingDevice.h"
 #include "mitkTrackingTool.h"
 #include "mitkIGTTimeStamp.h"
 #include <cstdlib>
 #include <cstdio>
 #include <ctime>
 #include <itksys/SystemTools.hxx>
 #include "mitkCommon.h"
 #include <mitkTrackingTool.h>
 #include <mitkVector.h>
 #include "mitkIGTException.h"
 
 
 
 /**
 * \brief Function to get the Error messages from API
 */
 #include <mitkOptitrackErrorMessages.h>
 
 
 namespace mitk
 {
 
   //class OptitrackTrackingDevice;
 
   /** Documentation:
   *   \brief An object of this class represents the a Tool tracked by Optitrack System. You can define
   *  the tool by the a definition file like in the example in ****. Remember that it will be necessary to
   *  to have a license for using the Optitrack System.
-  *  See  http://www.naturalpoint.com/ for details.
+  *  See  https://www.naturalpoint.com/ for details.
   *   \author E. Marinetto (emarinetto@hggm.es) Instituto de Investigación Sanitaria Gregorio Marañón, Madrid, Spain. & M. Noll (matthias.noll@igd.fraunhofer.de) Cognitive Computing & Medical Imaging | Fraunhofer IGD
   *   \ingroup IGT
   */
   class MITKIGT_EXPORT OptitrackTrackingTool : public TrackingTool
   {
   public:
     friend class OptitrackTrackingDevice;
     mitkClassMacro(mitk::OptitrackTrackingTool, mitk::TrackingTool);
     itkNewMacro(Self);
 
 
 
     /**
     * \brief Define the tool by a calibration File.
     * The file must to have the next structure. Makers locations must to have "%fe %fe %fe\n" format and in (mm). See http://www.cplusplus.com/reference/cstdio/fscanf/
     *    ToolName
     *    \#NumberOfMarkers
     *    X Y Z - for the first marker
     *    X Y Z - for the second marker
     *    ...
     *    X Y Z - for the last marker, the number \#NumberOfMarkers
     *    X Y Z - for the PIVOT point
     * \return Returns true if the tool was set correctly
     * @throw mitk::IGTException Throws an exception if there exist any problem during the configuration file reading.
     */
     bool SetToolByFileName(std::string nameFile);
 
     /**
     * \brief Ask API the next number of defined tool
     * \return Returns the next ID (int) for a new tool in the device list for API
     * @throw mitk::IGTException Throws an exception if get_IDnext failed
     */
     int get_IDnext();
 
     /**
     * \brief Delete the tool from the list of tools inside API Optitrack
     * \return Returns true if the deletion was correct
     * @throw mitk::IGTException Throws an exception if
     */
     bool DeleteTrackable();
 
     /**
     * \brief Set the position to a given one
     * @throw mitk::IGTException Throws an exception if
     */
     using Superclass::SetPosition;
     void SetPosition(mitk::Point3D position, ScalarType eps=0.0);
 
     /**
     * \brief Set the orientation to a given one using a quaternion nomenclature
     * @throw mitk::IGTException Throws an exception if
     */
     using Superclass::SetOrientation;
     void SetOrientation(mitk::Quaternion orientation, ScalarType eps=0.0);
 
     /**
     * \brief Get the position of the tool
     * @throw mitk::IGTException Throws an exception if
     */
     void GetPosition(mitk::Point3D& position) const override;
 
     /**
     * \brief Get the orientation of the tool using quaternion nomenclature
     * @throw mitk::IGTException Throws an exception if
     */
     void GetOrientation(mitk::Quaternion& orientation) const override;
 
     /**
     * \brief Set the tool enabled for tracking.
   * \return Return true if the enabling was successfull
     * @throw mitk::IGTException Throws an exception if
     */
     bool Enable() override;
 
     /**
     * \brief Set the tool disabled for tracking.
   * \return Return true if the disabling was successfull
     * @throw mitk::IGTException Throws an exception if
     */
     bool Disable() override;
 
     /**
     * \brief Check if the tool is enabled (true) or not.
   * \return Return true if the tool is enabled for tracking
     * @throw mitk::IGTException Throws an exception if
     */
     bool IsEnabled() const override;
 
     /**
     * \brief Check if the data of the tool is valid.
   * \return Return true if location data is valid
     * @throw mitk::IGTException Throws an exception if
     */
     bool IsDataValid() const override;
 
     /**
     * \brief Get the expectated error in the tracked tool
   * \return Return the error location
     * @throw mitk::IGTException Throws an exception if
     */
     float GetTrackingError() const override;
 
     /**
     * \brief Set the FLE (Fiducial Localization Error) for the tool
     * @throw mitk::IGTException Throws an exception if
     */
     void SetTrackingError(float FLEerror) override;
 
     /**
     * \brief Set the valid flag for tracking data to true
     * @throw mitk::IGTException Throws an exception if
     */
     void SetDataValid(bool _arg) override;
 
     /**
     * \brief Update location and orientation of the tool
     * @throw mitk::IGTException Throws an exception if
     */
     void updateTool();
 
     /**
     * \brief Constructor of the class
     */
     OptitrackTrackingTool();
 
     /**
     * \brief Destructor of the class
     */
     ~OptitrackTrackingTool() override;
 
     /**
     * \brief File of the configuration for the tool
     */
     std::string m_fileConfiguration;
 
     /**
     * \brief ID number from Optitrack API
     */
     int m_ID;
 
     /**
     * \brief List of Markers locations in calibration position and orientation
     */
     float* m_calibrationPoints;
 
     /**
     * \brief location of the pivot point during calibration
     */
     float* m_pivotPoint;
 
     /**
     * \brief Number of Markers that blong to the tool
     */
     int m_numMarkers;
 
     /**
     * \brief Expected value of the fiducial localization error (rms)
     */
   float m_FLE;
 
   private:
     OptitrackTrackingTool(const OptitrackTrackingTool&);
     const OptitrackTrackingTool& operator=(const OptitrackTrackingTool&);
 
   };
 }
 #endif /* OptiTrackTrackingTool_H_HEADER_INCLUDED_ */
diff --git a/Modules/ImageStatistics/itkMultiGaussianImageSource.h b/Modules/ImageStatistics/itkMultiGaussianImageSource.h
index 794809c8fc..c557a6f991 100644
--- a/Modules/ImageStatistics/itkMultiGaussianImageSource.h
+++ b/Modules/ImageStatistics/itkMultiGaussianImageSource.h
@@ -1,374 +1,374 @@
 /*=========================================================================
  *
  *  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
+ *         https://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.
  *
  *=========================================================================*/
 /*=========================================================================
  *
  *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
  *
  *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  *
  *  For complete copyright, license and disclaimer of warranty information
  *  please refer to the NOTICE file at the top of the ITK source tree.
  *
  *=========================================================================*/
 #ifndef __itkMultiGaussianImageSource_h
 #define __itkMultiGaussianImageSource_h
 
 #include "itkImageSource.h"
 #include "itkNumericTraits.h"
 #include "itkImageRegionIteratorWithIndex.h"
 #include "itkImageFileWriter.h"
 #include <itkMapContainer.h>
 
 
 namespace itk
 {
 /** \class MultiGaussianImageSource
 
 \brief Generate an 3-dimensional multigaussian image.
 
 This class defines an 3-dimensional Image, in which the value at one voxel equals the value of a multigaussian function evaluated at the voxel's coordinates. The multigaussian function is built as a sum of N gaussian function and is defined by the following parameters (\ref Generation-of-a-multigauss-image):
 
 1. CenterX, CenterY, CenterZ - vectors of the size of N determining the expectancy value at the x-, y- and the z-axis. That means: The i-th gaussian bell curve takes its maximal value at the voxel with index [CenterX(i); CenterY(i); Centerz(i)].
 
 2. SigmaX, SigmaY, SigmaZ - vectors of the size of N determining the deviation at the x-, y- and the z-axis. That means: The width of the i-th gaussian bell curve is determined by the deviation in the x-axis, which is SigmaX(i), in the y-axis is SigmaY(i) and in the z-axis is SigmaZ(i).
 
 3. Altitude - vector of the size of N determining the altitude: the i-th gaussian bell curve has a height of Altitude(i).
 This class allows by the method CalculateMidpointAndMeanValue() to find a sphere with a specified radius that has a maximal mean value over all sphere with that radius with midpoint inside or on the boundary of the image. Furthermore it can calculate the maximal und minimal pixel intensities and whose indices in the founded sphere.
 
 To serve as a test tool for ImageStatisticsCalculator, esp. the "hotspot search" feature of this class, MultiGaussianImageSource is also able to calculate the position of a sphere that maximizes the mean value of the voxels within the sphere (\ref Algorithm-for-calculating-statistic-in-a-sphere).
 
 \section Generation-of-a-multigauss-image Generation of a multigauss image
 
 A multigauss function consists of the sum of \f$ N \f$ gauss function. The \f$ i \f$-th \n (\f$0 \leq i \leq N \f$) gaussian is described with the following seven parameters (see above):
 - \f$ x_0^{(i)} \f$ is the expectancy value in the \f$ x \f$-Axis
 - \f$ y_0^{(i)} \f$ is the expectancy value in the \f$ y \f$-Axis
 - \f$ z_0^{(i)} \f$ is the expectancy value in the \f$ z \f$-Axis
 - \f$ \sigma_x^{(i)} \f$ is the deviation in the \f$ x \f$-Axis
 - \f$ \sigma_y^{(i)} \f$ is the deviation in the \f$ y \f$-Axis
 - \f$ \sigma_z^{(i)} \f$ is the deviation in the \f$ z \f$-Axis
 - \f$ a^{(i)} \f$ is the  altitude of the gaussian.
 
 A gauss function has the following form:
 
 \f{eqnarray}{
 \nonumber
 f^{(i)}(x,y,z) = a^{(i)}
 exp \left[ - \left(
 \frac{(x - x_0^{(i)})^2}{2 (\sigma_x^{(i)})^2} +
 \frac{(y - y_0^{(i)})^2}{2 (\sigma_y^{(i)})^2} +
 \frac{(z - z_0^{(i)})^2}{2 (\sigma_z^{(i)})^2}
 \right) \right].
 \f}
 
 A multigauss function has then the form:
 
 \f{align*}{
 f_N(x,y,z) =& \sum_{i=0}^{N}f^{(i)}(x,y,z)\\
 =&\sum_{0}^{N} a^{(i)}
 exp \left[ - \left(
 \frac{(x - x_0^{(i)})^2}{2 (\sigma_x^{(i)})^2} +
 \frac{(y - y_0^{(i)})^2}{2 (\sigma_y^{(i)})^2} +
 \frac{(z - z_0^{(i)})^2}{2 (\sigma_z^{(i)})^2}
 \right) \right].
 \f}
 
 The multigauss function \f$f_N\f$ will be evaluated at each voxel coordinate to become the voxel intensity.
 
 \section Algorithm-for-calculating-statistic-in-a-sphere Algorithm for calculating statistic in a sphere
 
 This section explains how we can find a sphere region which has a maximal mean value over all sphere regions with a fixed radius. Furthermore we want to calculate the maximal and minimal value in the wanted sphere.
 
 To calculate the mean value in a sphere we integrate the gaussians over the whole sphere. The antiderivative is unknown as an explicit function, but we have a value table for the distribution function of the normal distribution \f$ \Phi(x) \f$ for \f$ x \f$ between \f$ -3.99 \f$ and \f$ 3.99 \f$ with step size \f$ 0.01 \f$. The only problem is that we cannot integrate over a spherical region, because we have an 3-dim integral and therefore are the integral limits dependent from each other and we cannot evaluate \f$ \Phi \f$. So we approximate the sphere with cuboids inside the sphere and prisms on the boundary of the sphere. We calculate these cuboids with the octree recursive method: We start by subdividing the wrapping box of the sphere in eight cuboids. Further we subdivide each cuboid in eight cuboids and check for each of them, whether it is inside or outside the sphere or whether it intersects the sphere surface. We save those of them, which are inside the sphere and continue to subdivide the cuboids that intersect the sphere until the recursion breaks. In the last step we take the half of the cuboids on the boundary and this are the prisms. Now we can calculate and sum the integrals over the cuboids and divide through the volume of the body to obtain the mean value.
 
 For each cuboid \f$ Q = [a_1, b_1]\times[a_2, b_2]\times[a_3, b_3] \f$ we apply  Fubini's theorem for integrable functions and become for the integral the following:
 
 \f{align*}{
 m_k =& \sum_{i=0}^{N} \int_{Q} f^{(i)}(x,y,z)dx\\
 =&\sum_{i=0}^{N} a^{(i)} \int_{Q}
 exp \left[ - \left(
 \frac{(x - x_0^{(i)})^2}{2 (\sigma_x^{(i)})^2} +
 \frac{(y - y_0^{(i)})^2}{2 (\sigma_y^{(i)})^2} +
 \frac{(z - z_0^{(i)})^2}{2 (\sigma_z^{(i)})^2}
 \right) \right] dx \\
 =& \sum_{i=0}^{N} a^{(i)} \int_{a_1}^{b_1} exp \left[ - \frac{(x - x_0^{(i)})^2}{2 (\sigma_x^{(i)})^2} \right] dx
  \int_{a_2}^{b_2}exp \left[ -\frac{(y - y_0^{(i)})^2}{2 (\sigma_y^{(i)})^2} \right]dx
  \int_{a_3}^{b_3}exp \left[ -\frac{(z - z_0^{(i)})^2}{2 (\sigma_z^{(i)})^2} \right]dx.
 \f}
 
 So we calculate three one dimensional integrals:
 \f{align*}{
 \int_{a}^{b} & exp \left[ - \frac{(x - x_0^{(i)})^2}{2 (\sigma_x^{(i)})^2} \right] dx \\
 =&\int_{-\infty}^{b} exp \left[ - \frac{(x - x_0^{(i)})^2}{2 (\sigma_x^{(i)})^2} \right] dx - \int_{-\infty}^{a} exp \left[ - \frac{(x - x_0^{(i)})^2}{2 (\sigma_x^{(i)})^2} \right] dx \\
 =& \sigma_x^{(i)} \left[\int_{-\infty}^{(a - x_0^{(i)})/ \sigma_x^{(i)}} e^{-\frac{t^2}{2}} dt
  - \int_{-\infty}^{(b - x_0^{(i)})/ \sigma_x^{(i)}} e^{-\frac{t^2}{2}}dt \right] \\
 =&\sigma_x^{(i)} \sqrt{(\pi)} \left[ \Phi \left( \frac{(a - x_0^{(i)})^2}{\sigma_x^{(i)}} \right) - \Phi \left ( \frac{(b - x_0^{(i)})^2}{\sigma_x^{(i)}} \right) \right].
 \f}
 
 and become for the integral over \f$ Q \f$:
 
 \f{align*}{
 m_k =& \sum_{i=0}^{N} \sigma_x^{(i)} \sigma_y^{(i)} \sigma_z^{(i)} \pi^{1.5}
  \left[ \Phi \left( \frac{(a_1 - x_0^{(i)})^2}{\sigma_x^{(i)}} \right) - \Phi \left ( \frac{(b_1 - x_0^{(i)})^2}{\sigma_x^{(i)}} \right) \right]\times \\
   &\left[ \Phi \left( \frac{(a_2 - y_0^{(i)})^2}{\sigma_y^{(i)}} \right) - \Phi \left ( \frac{(b_2 - y_0^{(i)})^2}{\sigma_y^{(i)}} \right) \right]\times
    \left[ \Phi \left( \frac{(a_3 - z_0^{(i)})^2}{\sigma_z^{(i)}} \right) - \Phi \left ( \frac{(b_3 - z_0^{(i)})^2}{\sigma_z^{(i)}} \right) \right].
 \f}
 
 For the integral over the prism we take the half of the integral over the corresponding cuboid.
 
 Altogether we find the mean value in the sphere as:
 \f{align*}{
 \left( \sum_{Q_k \text{ Cuboid}} m_k + \sum_{P_l \text{ Prism}} 0.5 m_l \right )/Volume(B),
 \f}
 
 where Volume(B) is the volume of the body that approximate the sphere.
 
 Now we know how to calculate the mean value in a sphere for given midpoint and radius. So we assume each voxel in the given image to be the sphere midpoint and we calculate the mean value as described above. If the new mean value is greater than the "maximum-until-now", we take the new value to be the "maximum-until-now". Then we go to the next voxel and make the same calculation and so on. At the same time we save the coordinates  of the midpoint voxel.
 
 After we found the midpoint and the maximal mean value, we can calculate the maximum and the minimum in the sphere: we just traverse all the voxels in the region and take the maximum and minimum value and the respective coordinates.
 
 \section  Input-and-output Input and output
 
 An example for an input in the command-line is:
 \verbatim
   mitkMultiGaussianTest C:/temp/outputFile C:/temp/inputFile.xml
 \endverbatim
 
 Here is outputFile the name of the gaussian image with extension .nrrd and at the same time the name of the output file with extension .xml, which is the same as the inputFile, only added the calculated mean value, max and min and the corresponding indexes in the statistic tag. Here we see an example for the input and output .xml file:
 
 \verbatim
 INPUT:
 
 <testcase>
   <testimage image-rows="20" image-columns="20" image-slices="20" numberOfGaussians="2" spacingX="1" spacingY="1" spacingZ="1" entireHotSpotInImage="1">
     <gaussian centerIndexX="4" centerIndexY="16" centerIndexZ="10" deviationX="7" deviationY="7" deviationZ="7" altitude="200"/>
     <gaussian centerIndexX="18" centerIndexY="2" centerIndexZ="10" deviationX="1" deviationY="1" deviationZ="1" altitude="210"/>
   </testimage>
   <segmentation numberOfLabels="1" hotspotRadiusInMM="6.2035">
     <roi label="1" maximumSizeX="20" minimumSizeX="0" maximumSizeY="20" minimumSizeY="0" maximumSizeZ="20" minimumSizeZ="0"/>
   </segmentation>
 </testcase>
 \endverbatim
 
 \verbatim
 OUTPUT:
 
 <testcase>
   <testimage image-rows="20" image-columns="20" image-slices="20" numberOfGaussians="2" spacingX="1" spacingY="1" spacingZ="1" entireHotSpotInImage="1">
     <gaussian centerIndexX="4" centerIndexY="16" centerIndexZ="10" deviationX="7" deviationY="7" deviationZ="7" altitude="200"/>
     <gaussian centerIndexX="18" centerIndexY="2" centerIndexZ="10" deviationX="1" deviationY="1" deviationZ="1" altitude="210"/>
   </testimage>
   <segmentation numberOfLabels="1" hotspotRadiusInMM="6.2035">
     <roi label="1" maximumSizeX="20" minimumSizeX="0" maximumSizeY="20" minimumSizeY="0" maximumSizeZ="20" minimumSizeZ="0"/>
   </segmentation>
   <statistic hotspotIndexX="6" hotspotIndexY="13" hotspotIndexZ="10" peak="141.544" mean="141.544" maximumIndexX="4" maximumIndexY="16" maximumIndexZ="10" maximum="200" minimumIndexX="9" minimumIndexY="8" minimumIndexZ="8"  minimum="77.4272"/>
 </testcase>
 \endverbatim
 
 \subsection  Parameter-for-the-input Parameter for the input
 
 In the tag \a testimage we describe the image that we generate. Image rows/columns/slices gives the number of rows/columns/slices of the image; \a numberOfGaussians is  the number of gauss functions (\f$ N \f$); spacing defines the extend of one voxel for each direction. The parameter \a entireHotSpotInImage determines whether the whole sphere is in the image included (\f$ = 1 \f$) or only the midpoint of the sphere is inside the image.
 
 NOTE: When the \a entireHotSpotInImage \f$ = 0 \f$ it is possible that we find the midpoint of the sphere on the border of the image. In this case we cut the approximation of the sphere, so that we become a body, which is completely inside the image, but not a "sphere" anymore. To that effect is the volume of the body decreased and that could lead to unexpected results.
 
 In the subtag \a gaussian we describe each gauss function as mentioned in the second section.
 
 In the tag \a segmentation we define the radius of the wanted sphere in mm (\a hotspotRadiusInMM ). We can also set the number of labels (\a numberOfLabels ) to be an positive number and this determines the number of regions of interest (ROI). In each ROI we find the sphere with the wanted properties and midpoint inside the ROI, but not necessarily the whole sphere. In the subtag \a roi we set label number and the index coordinates for the borders of the roi.
 
 */
 template< typename TOutputImage >
 class ITK_EXPORT MultiGaussianImageSource:public ImageSource< TOutputImage >
 {
 public:
   /** Standard class typedefs. */
   typedef MultiGaussianImageSource           Self;
   typedef ImageSource< TOutputImage > Superclass;
   typedef SmartPointer< Self >        Pointer;
   typedef SmartPointer< const Self >  ConstPointer;
 
   /** Typedef for the output image PixelType. */
   typedef typename TOutputImage::PixelType OutputImagePixelType;
 
   /** Typedef to describe the output image region type. */
   typedef typename TOutputImage::RegionType OutputImageRegionType;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self);
 
   /** Basic types from the OutputImageType */
   typedef typename TOutputImage::SizeType                     SizeType;
   typedef typename TOutputImage::IndexType                    IndexType;
   typedef typename TOutputImage::SpacingType                  SpacingType;
   typedef typename TOutputImage::PointType                    PointType;
   typedef typename SizeType::SizeValueType                    SizeValueType;
   typedef SizeValueType                                       SizeValueArrayType[TOutputImage::ImageDimension];
   typedef typename TOutputImage::SpacingValueType             SpacingValueType;
   typedef SpacingValueType                                    SpacingValueArrayType[TOutputImage::ImageDimension];
   typedef typename TOutputImage::PointValueType               PointValueType;
   typedef PointValueType                                      PointValueArrayType[TOutputImage::ImageDimension];
   typedef typename itk::ImageRegion<3> ::SizeValueType        SizeRegionType;
   /** Typedef to describe the sphere radius type. */
   typedef double                                              RadiusType;
   /** Typedef to describe the standard vector type. */
   typedef std::vector<double>                                 VectorType;
   /** Typedef to describe the itk vector type. */
   typedef Vector<double, TOutputImage::ImageDimension>        ItkVectorType;
   /** Typedef to describe the ImageRegionIteratorWithIndex type. */
   typedef ImageRegionIteratorWithIndex<TOutputImage>          IteratorType;
   /** Typedef to describe the Poiner type at the output image. */
   typedef typename TOutputImage::Pointer                      ImageType;
 
   typedef  MapContainer<unsigned int, PointType>              MapContainerPoints;
    typedef  MapContainer<unsigned int, double>                MapContainerRadius;
 
 
   /** Set/Get size of the output image. */
   itkSetMacro(Size, SizeType);
   virtual void SetSize(SizeValueArrayType sizeArray);
   virtual const SizeValueType * GetSize() const;
   /** Set/Get spacing of the output image. */
   itkSetMacro(Spacing, SpacingType);
   virtual void SetSpacing(SpacingValueArrayType spacingArray);
   virtual const SpacingValueType * GetSpacing() const;
   /** Set/Get origin of the output image. This programm works proper only with origin [0.0, 0.0, 0.0] */
   itkSetMacro(Origin, PointType);
   virtual void SetOrigin(PointValueArrayType originArray);
   virtual const PointValueType * GetOrigin() const;
   /** Get the number of gaussian functions in the output image. */
   virtual unsigned int GetNumberOfGaussians() const;
   /** Set the number of gaussian function. */
   virtual void SetNumberOfGausssians( unsigned int );
   /** Set/Get the radius of the sphere. */
   virtual RadiusType GetRadius() const;
   virtual void  SetRadius( RadiusType  radius );
   /** Get the maximal mean value in a sphere over all possible spheres with midpoint in the image. */
   virtual const OutputImagePixelType GetMaxMeanValue() const;
   /** Get the index of the midpoint of a sphere with the maximal mean value.*/
   virtual const IndexType GetSphereMidpoint() const;
   /** Calculates the value of the multigaussian function at a Point given by its coordinates [x, y, z]. */
   virtual double MultiGaussianFunctionValueAtPoint(double , double, double);
   /** Adds a multigaussian defined by the parameter: CenterX, CenterY, CenterZ, SigmaX, SigmaY, SigmaZ, Altitude.
    All parameters should have the same size, which determinates the number of the gaussian added. */
   virtual void AddGaussian( VectorType centerX, VectorType centerY, VectorType centerZ, VectorType sigmaX, VectorType sigmaY, VectorType sigmaZ, VectorType altitude);
   /** Calculates and set the index of the midpoint of the sphere with the maximal mean value as well as the mean value. */
   virtual void CalculateTheMidpointAndTheMeanValueWithOctree();
   /** Calculates and set the index an the value of maximulm and minimum in the wanted sphere. */
   virtual void CalculateMaxAndMinInSphere();
   /** Get the index in the sphere with maximal value. */
   virtual const IndexType GetMaxValueIndexInSphere() const;
   /** Get the maximal value in the sphere. */
   virtual const OutputImagePixelType GetMaxValueInSphere() const;
   /** Get the index in the sphere with minimal value. */
   virtual const IndexType GetMinValueIndexInSphere() const;
   /** Get the minimal value in the sphere. */
   virtual const OutputImagePixelType GetMinValueInSphere() const;
   /** Set the region of interest. */
   virtual void SetRegionOfInterest(ItkVectorType, ItkVectorType);
   /** Write a .mps file to visualise the point in the sphere. */
   virtual void WriteXMLToTestTheCuboidInsideTheSphere();
   /**This recursive method realise the octree method. It subdivide a cuboid in eight cuboids, when this cuboid crosses the boundary of sphere. If the cuboid is inside the sphere, it calculates the integral. */
   virtual void CalculateEdgesInSphere( PointType globalCoordinateMidpointCuboid, PointType globalCoordinateMidpointSphere, double cuboidRadius, int level);
   /**Calculate and return value of the integral of the gaussian in a cuboid region with the dimension 3: in the x-axis between xMin and xMax and in the y-axis between yMin and yMax and in the z-axis also between zMin and zMax. */
   virtual double MultiGaussianFunctionValueAtCuboid(double xMin, double xMax, double yMin, double yMax, double zMin, double zMax);
   /** Inseret the midpoints of cuboid in a vector m_Midpoints, so that we can visualise it. */
   virtual void InsertPoints( PointType globalCoordinateMidpointCuboid, double cuboidRadius);
   /** Start the octree recursion in eigth directions for the sphere with midpoint globalCoordinateMidpointSphere. */
   virtual void GenerateCuboidSegmentationInSphere( PointType globalCoordinateMidpointSphere );
   /** Get the  the values of the cumulative distribution function of the normal distribution. */
   virtual double FunctionPhi(double value);
   /** Check if a cuboid with midpoint globalCoordinateMidpointCuboid and side length sideLength intersect the sphere with midpoint globalCoordinateMidpointSphere boundary. */
   virtual  unsigned int IntersectTheSphere( PointType globalCoordinateMidpointCuboid, PointType globalCoordinateMidpointSphere, double sideLength);
   /** Set the tabel values of the distribution function of the normal distribution. */
   void SetNormalDistributionValues();
 
 
   /** Set the minimum possible pixel value. By default, it is
    * NumericTraits<TOutputImage::PixelType>::min(). */
   itkSetClampMacro( Min, OutputImagePixelType,
                     NumericTraits< OutputImagePixelType >::NonpositiveMin(),
                     NumericTraits< OutputImagePixelType >::max() );
   /** Check if a index is inside the image*/
   bool IsInImage(IndexType index);
 
   /** Get the minimum possible pixel value. */
   itkGetConstMacro(Min, OutputImagePixelType);
 
   /** Set the maximum possible pixel value. By default, it is
    * NumericTraits<TOutputImage::PixelType>::max(). */
   itkSetClampMacro( Max, OutputImagePixelType,
                     NumericTraits< OutputImagePixelType >::NonpositiveMin(),
                     NumericTraits< OutputImagePixelType >::max() );
 
   /** Get the maximum possible pixel value. */
   itkGetConstMacro(Max, OutputImagePixelType);
 
 protected:
   MultiGaussianImageSource();
   ~MultiGaussianImageSource() override;
   void PrintSelf(std::ostream & os, Indent indent) const override;
 
   void GenerateData() override;
   void GenerateOutputInformation() override;
 
 private:
   MultiGaussianImageSource(const MultiGaussianImageSource &); //purposely not implemented
   void operator=(const MultiGaussianImageSource &);    //purposely not implemented
 
   SizeType                                  m_Size;                  //size of the output image
   SpacingType                               m_Spacing;               //spacing
   PointType                                 m_Origin;                //origin
   OutputImagePixelType                      m_MaxValueInSphere;      //maximal value in the wanted sphere
   IndexType                                 m_MaxValueIndexInSphere; //index of the maximal value in the wanted sphere
   OutputImagePixelType                      m_MinValueInSphere;      //minimal value in the wanted sphere
   IndexType                                 m_MinValueIndexInSphere; //index of the minimal value in the wanted sphere
   unsigned int                              m_NumberOfGaussians;     //number of Gaussians
   RadiusType                                m_Radius;                //radius of the sphere
   unsigned int                              m_RadiusStepNumber;      //number of steps to traverse the sphere radius
   OutputImagePixelType                      m_MeanValue;             //mean value in the wanted sphere
   OutputImagePixelType                      m_ValueAtMidpoint;       //value at the midpoint of the wanted sphere
   IndexType                                 m_SphereMidpoint;        //midpoint of the wanted sphere
   VectorType                                m_SigmaX;                //deviation in the x-axis
   VectorType                                m_SigmaY;                //deviation in the y-axis
   VectorType                                m_SigmaZ;                //deviation in the z-axis
   VectorType                                m_CenterX;               //x-coordinate of the mean value of Gaussians
   VectorType                                m_CenterY;               //y-coordinate of the mean value of Gaussians
   VectorType                                m_CenterZ;               //z-coordinate of the mean value of Gaussians
   VectorType                                m_Altitude;              //amplitude
   ItkVectorType                             m_RegionOfInterestMax;   //maximal values for the coordinates in the region of interest
   ItkVectorType                             m_RegionOfInterestMin;   //minimal values for the coordinates in the region of interest
   typename TOutputImage::PixelType          m_Min;                   //minimum possible value
   typename TOutputImage::PixelType          m_Max;                   //maximum possible value
   PointType                                 m_GlobalCoordinate;      //physical coordiante of the sphere midpoint
   bool                                      m_WriteMPS;              //1 = write a MPS File to visualise the cuboid midpoints of one approximation of the sphere
   MapContainerPoints                        m_Midpoints;             //the midpoints of the cuboids
   MapContainerRadius                        m_RadiusCuboid;          //the radius ( = 0.5 * side length) of the cuboids (in the same order as the midpoints in m_Midpoints)
   double                                    m_Volume;                //the volume of the body, that approximize the sphere
   double                                    m_NormalDistValues [410];//normal distribution values
   double                                    m_meanValueTemp;         //= m_Volume * meanValue in each sphere
   // The following variables are deprecated, and provided here just for
   // backward compatibility. It use is discouraged.
   mutable PointValueArrayType               m_OriginArray;
   mutable SpacingValueArrayType             m_SpacingArray;
 };
 
 } // end namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkMultiGaussianImageSource.hxx"
 #endif
 
 #endif
diff --git a/Modules/ImageStatistics/itkMultiGaussianImageSource.hxx b/Modules/ImageStatistics/itkMultiGaussianImageSource.hxx
index 706ebb35c1..03086b02e9 100644
--- a/Modules/ImageStatistics/itkMultiGaussianImageSource.hxx
+++ b/Modules/ImageStatistics/itkMultiGaussianImageSource.hxx
@@ -1,998 +1,998 @@
 /*=========================================================================
 *
 *  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
+*         https://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.
 *
 *=========================================================================*/
 /*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
 #ifndef __itkMultiGaussianImageSource_hxx
 #define __itkMultiGaussianImageSource_hxx
 #include <iostream>
 #include <fstream>
 #include <ctime>
 #include "itkMultiGaussianImageSource.h"
 #include "itkImageRegionIterator.h"
 #include "itkObjectFactory.h"
 #include "itkProgressReporter.h"
 #include "itkDOMNodeXMLWriter.h"
 #include <cstdlib>
 
 namespace itk
 {
   /**
   *
   */
   template< class TOutputImage >
   MultiGaussianImageSource< TOutputImage >
     ::MultiGaussianImageSource()
   {
     //Initial image is 100 wide in each direction.
     for ( unsigned int i = 0; i < TOutputImage::GetImageDimension(); i++ )
     {
       m_Size[i] = 100;
       m_Spacing[i] = 1.0;
       m_Origin[i] = 0.0;
       m_SphereMidpoint[i] = 0;
     }
 
     m_NumberOfGaussians = 0;
     m_Radius = 1;
     m_RadiusStepNumber = 5;
     m_MeanValue = 0;
 
     m_Min = NumericTraits< OutputImagePixelType >::NonpositiveMin();
     m_Max = NumericTraits< OutputImagePixelType >::max();
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   MultiGaussianImageSource< TOutputImage >
     ::~MultiGaussianImageSource()
   {}
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::SetSize(SizeValueArrayType sizeArray)
   {
     const unsigned int count = TOutputImage::ImageDimension;
     unsigned int       i;
 
     for ( i = 0; i < count; i++ )
     {
       if ( sizeArray[i] != this->m_Size[i] )
       {
         break;
       }
     }
     if ( i < count )
     {
       this->Modified();
       for ( i = 0; i < count; i++ )
       {
         this->m_Size[i] = sizeArray[i];
       }
     }
   }
 
   template< class TOutputImage >
   const typename MultiGaussianImageSource< TOutputImage >::SizeValueType *
     MultiGaussianImageSource< TOutputImage >
     ::GetSize() const
   {
     return this->m_Size.GetSize();
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::SetSpacing(SpacingValueArrayType spacingArray)
   {
     const unsigned int count = TOutputImage::ImageDimension;
     unsigned int       i;
 
     for ( i = 0; i < count; i++ )
     {
       if ( spacingArray[i] != this->m_Spacing[i] )
       {
         break;
       }
     }
     if ( i < count )
     {
       this->Modified();
       for ( i = 0; i < count; i++ )
       {
         this->m_Spacing[i] = spacingArray[i];
       }
     }
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::SetOrigin(PointValueArrayType originArray)
   {
     const unsigned int count = TOutputImage::ImageDimension;
     unsigned int       i;
 
     for ( i = 0; i < count; i++ )
     {
       if ( originArray[i] != this->m_Origin[i] )
       {
         break;
       }
     }
     if ( i < count )
     {
       this->Modified();
       for ( i = 0; i < count; i++ )
       {
         this->m_Origin[i] = originArray[i];
       }
     }
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   const typename MultiGaussianImageSource< TOutputImage >::PointValueType *
     MultiGaussianImageSource< TOutputImage >
     ::GetOrigin() const
   {
     for ( unsigned int i = 0; i < TOutputImage::ImageDimension; i++ )
     {
       this->m_OriginArray[i] = this->m_Origin[i];
     }
     return this->m_OriginArray;
   }
 
   template< class TOutputImage >
   const typename MultiGaussianImageSource< TOutputImage >::SpacingValueType *
     MultiGaussianImageSource< TOutputImage >
     ::GetSpacing() const
   {
     for ( unsigned int i = 0; i < TOutputImage::ImageDimension; i++ )
     {
       this->m_SpacingArray[i] = this->m_Spacing[i];
     }
     return this->m_SpacingArray;
   }
   //-----------------------------------------------------------------------------------------------------------------------
   /**
   *
   */
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::PrintSelf(std::ostream & os, Indent indent) const
   {
     Superclass::PrintSelf(os, indent);
     os << indent << "Max: "
       << static_cast< typename NumericTraits< OutputImagePixelType >::PrintType >( m_Max )
       << std::endl;
     os << indent << "Min: "
       << static_cast< typename NumericTraits< OutputImagePixelType >::PrintType >( m_Min )
       << std::endl;
 
     os << indent << "Origin: [";
     unsigned int ii = 0;
     while( ii < TOutputImage::ImageDimension - 1 )
     {
       os << m_Origin[ii] << ", ";
       ++ii;
     }
     os << m_Origin[ii] << "]" << std::endl;
 
     os << indent << "Spacing: [";
     ii = 0;
     while( ii < TOutputImage::ImageDimension - 1 )
     {
       os << m_Spacing[ii] << ", ";
       ++ii;
     }
     os << m_Spacing[ii] << "]" << std::endl;
 
     os << indent << "Size: [";
     ii = 0;
     while( ii < TOutputImage::ImageDimension - 1 )
     {
       os << m_Size[ii] << ", ";
       ++ii;
     }
     os << m_Size[ii] << "]" << std::endl;
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   unsigned int
     MultiGaussianImageSource< TOutputImage >
     ::GetNumberOfGaussians() const
   {
     return this->m_NumberOfGaussians;
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   typename MultiGaussianImageSource< TOutputImage >::RadiusType
     MultiGaussianImageSource< TOutputImage >
     ::GetRadius() const
   {
     return this->m_Radius;
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::SetRadius( RadiusType  radius )
   {
     this->m_Radius = radius;
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::SetNumberOfGausssians( unsigned int n )
   {
     this->m_NumberOfGaussians = n;
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::SetRegionOfInterest( ItkVectorType roiMin, ItkVectorType roiMax )
   {
     m_RegionOfInterestMax = roiMax;
     m_RegionOfInterestMin = roiMin;
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   const typename MultiGaussianImageSource< TOutputImage >::OutputImagePixelType
     MultiGaussianImageSource< TOutputImage >
     ::GetMaxMeanValue() const
   {
     return m_MeanValue;
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   const typename MultiGaussianImageSource< TOutputImage >::OutputImagePixelType
     MultiGaussianImageSource< TOutputImage >
     ::GetMaxValueInSphere() const
   {
     return m_MaxValueInSphere;
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   const typename MultiGaussianImageSource< TOutputImage >::IndexType
     MultiGaussianImageSource< TOutputImage >
     ::GetMaxValueIndexInSphere() const
   {
     return  m_MaxValueIndexInSphere;
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   const typename MultiGaussianImageSource< TOutputImage >::OutputImagePixelType
     MultiGaussianImageSource< TOutputImage >
     ::GetMinValueInSphere() const
   {
     return m_MinValueInSphere;
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   const typename MultiGaussianImageSource< TOutputImage >::IndexType
     MultiGaussianImageSource< TOutputImage >
     ::GetMinValueIndexInSphere() const
   {
     return  m_MinValueIndexInSphere;
   }
   //-----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   const typename MultiGaussianImageSource< TOutputImage >::IndexType
     MultiGaussianImageSource< TOutputImage >
     ::GetSphereMidpoint() const
   {
     return m_SphereMidpoint;
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   /* Calculate and return value of the integral of the gaussian in a cuboid region with the dimension 3: in the x-axis between xMin and xMax and in the y-axis between yMin and yMax and in the z-axis also between zMin and zMax.  */
 
   template< class TOutputImage >
   double
     MultiGaussianImageSource< TOutputImage >
     ::MultiGaussianFunctionValueAtCuboid(double xMin, double xMax, double yMin, double yMax, double zMin, double zMax)
   {
     double mean = 0;
     double summand0, summand1, summand2, value, factor;
     for(unsigned int n = 0; n < m_NumberOfGaussians; ++n)
     {
       summand0 = FunctionPhi((xMax - m_CenterX[n]) / m_SigmaX[n] ) - FunctionPhi((xMin - m_CenterX[n]) / m_SigmaX[n] );
       summand1 = FunctionPhi((yMax - m_CenterY[n]) / m_SigmaY[n] ) - FunctionPhi((yMin - m_CenterY[n]) / m_SigmaY[n] );
       summand2 = FunctionPhi((zMax - m_CenterZ[n]) / m_SigmaZ[n] ) - FunctionPhi((zMin - m_CenterZ[n]) / m_SigmaZ[n] );
 
       value = summand0 * summand1 * summand2;
       factor = (m_SigmaX[n] * m_SigmaY[n] * m_SigmaZ[n] ) * pow(2.0 * itk::Math::pi, 1.5 );
       mean = mean + factor * value * m_Altitude[n];
     }
     return mean;
   }
   //---------------------------------------------------------------------------------------------------------------------
 
   /*
   Returns the linear interpolation of the values of the standard normal distribution function. This values could be seen in the vector m_NormalDistValues.
   */
   template< class TOutputImage >
   double
     MultiGaussianImageSource< TOutputImage >
     ::FunctionPhi(double value)
   {
     double phiAtValue;
 
     //linear interpolation between the values
     int indexValue = static_cast<int>( 100 * value);
     if( indexValue > 409 )
     {
       return phiAtValue = 1.0;
     }
     else if( indexValue < -409 )
     {
       return phiAtValue = 0.0;
     }
     else if( indexValue == 409 )
     {
       return phiAtValue = m_NormalDistValues[409];
     }
     else if( indexValue == -409 )
     {
       return phiAtValue = 1.0 - m_NormalDistValues[409];
     }
     else
     {
       bool negative = false;
       if (indexValue < 0.0)
       {
         negative = true;
         value = -value;
       }
       int indexUp = static_cast<int>( 100 * value) + 1;
       int indexDown = static_cast<int>( 100 * value);
       double alpha = 100.0 * value - static_cast<double>(indexDown);
       phiAtValue = (1.0 - alpha) * m_NormalDistValues[indexDown] + alpha * m_NormalDistValues[indexUp] ;
       if(negative)
       {
         phiAtValue = 1.0 - phiAtValue;
       }
       return  phiAtValue;
     }
   }
 
   //----------------------------------------------------------------------------------------------------------------------
   /*
   Set the midpoint of the cuboid in a vector m_Midpoints. This cuboids discretise the sphere with the octree method.
   Set the radius of the cuboid  ( = 0.5 * length of the side of  the cuboid ) in the vector m_RadiusCuboid.
   */
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::InsertPoints( PointType globalCoordinateMidpointCuboid, double cuboidRadius)
   {
     typename MapContainerPoints::ElementIdentifier id = m_Midpoints.Size();
     m_Midpoints.InsertElement(id, globalCoordinateMidpointCuboid);
     m_RadiusCuboid.InsertElement(id, cuboidRadius);
   }
 
   //----------------------------------------------------------------------------------------------------------------------
 
   /* This recursive method realise the octree method. It subdivide a cuboid in eight cuboids, when this cuboid crosses the boundary of sphere. If the cuboid is inside the sphere, it calculates the integral and, if uncommented,  insert the midpoint of the cuboid in the m_Midpoints vector.
   */
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::CalculateEdgesInSphere( PointType globalCoordinateMidpointCuboid, PointType globalCoordinateMidpointSphere, double cuboidRadius, int level )
   {
     double xMin, xMax, yMin, yMax, zMin, zMax;
     double cuboidRadiusRecursion = cuboidRadius;
     PointType newMidpoint;
 
     int intersect = IntersectTheSphere( globalCoordinateMidpointCuboid, globalCoordinateMidpointSphere, cuboidRadiusRecursion);
 
     if( intersect == 1 )
     {
       if (level < 4)
       {
         // cuboid intersect the sphere -> call CalculateEdgesInSphere (this method) for the subdivided cuboid
         cuboidRadiusRecursion = cuboidRadiusRecursion / 2.0;
         for(int i = -1; i < 2; i+=2)
         {
           for(int k = -1; k < 2; k+=2)
           {
             for(int j = -1; j < 2; j+=2)
             {
               newMidpoint[0] = globalCoordinateMidpointCuboid[0] + static_cast<double>(i) * cuboidRadiusRecursion;
               newMidpoint[1] = globalCoordinateMidpointCuboid[1] + static_cast<double>(k) * cuboidRadiusRecursion;
               newMidpoint[2] = globalCoordinateMidpointCuboid[2] + static_cast<double>(j) * cuboidRadiusRecursion;
 
               this->CalculateEdgesInSphere( newMidpoint, globalCoordinateMidpointSphere, cuboidRadiusRecursion, level + 1 );
             }
           }
         }
       }
       // last step of recursion -> on the boundary
       else
       {
         // Calculate the integral and take the half of it (because we are on the boundary)
         xMin = globalCoordinateMidpointCuboid[0] - cuboidRadius;
         xMax = globalCoordinateMidpointCuboid[0] + cuboidRadius;
         yMin = globalCoordinateMidpointCuboid[1] - cuboidRadius;
         yMax = globalCoordinateMidpointCuboid[1] + cuboidRadius;
         zMin = globalCoordinateMidpointCuboid[2] - cuboidRadius;
         zMax = globalCoordinateMidpointCuboid[2] + cuboidRadius;
 
         // size is in index coordinate -> multiply by the spacing -> global coordinate of the image boundary
         // yz Plane
         bool yzPlaneNotCrossYSection           = xMin >= m_Origin[0] && xMax <= m_Size[0] * m_Spacing[0];
         // xz Plane
         bool xzPlaneNotCrossYSection           = yMin >= m_Origin[1] && yMax <= m_Size[1] * m_Spacing[1];
         // xy Plane
         bool xyPlaneNotCrossZSection           = zMin >= m_Origin[2] && zMax <= m_Size[2] * m_Spacing[2];
 
         //check if the boundary of the integral is inside the image
         if( yzPlaneNotCrossYSection && xzPlaneNotCrossYSection && xyPlaneNotCrossZSection)
         {
 
           //double temp = this->MultiGaussianFunctionValueAtCuboid( xMin, xMax, yMin, yMax, zMin, zMax ) * 0.5;
           m_meanValueTemp  = m_meanValueTemp + this->MultiGaussianFunctionValueAtCuboid( xMin, xMax, yMin, yMax, zMin, zMax ) * 0.5;
           m_Volume = m_Volume + pow( 2.0 * cuboidRadius, 3.0) / 2.0;
         }
       }
     }
     else if(intersect == 2)
     {
       // cuboid in the sphere
 
       // To insert the midpoint and the radius of the cuboid in a vector, so that we can visualise the midpoints, uncomment the next line and the line  WriteXMLToTestTheCuboidInsideTheSphere();
       // InsertPoints(globalCoordinateMidpointCuboid, cuboidRadius);
 
       // Calculate the integral boundary
       xMin = globalCoordinateMidpointCuboid[0] - cuboidRadius;
       xMax = globalCoordinateMidpointCuboid[0] + cuboidRadius;
       yMin = globalCoordinateMidpointCuboid[1] - cuboidRadius;
       yMax = globalCoordinateMidpointCuboid[1] + cuboidRadius;
       zMin = globalCoordinateMidpointCuboid[2] - cuboidRadius;
       zMax = globalCoordinateMidpointCuboid[2] + cuboidRadius;
 
       // size is in index coordinate -> multiply by the spacing -> global coordinate of the image boundary
       // yz Plane
 //      bool yzPlaneAtOriginCrossXSection      = xMin <= m_Origin[0] && xMax >= m_Origin[0];
 //      bool yzPlaneAtImageBorderCrossXSection = xMin <= m_Size[0] * m_Spacing[0] && xMax >= m_Size[0] * m_Spacing[0];
       bool yzPlaneNotCrossYSection           = xMin >= m_Origin[0] && xMax <= m_Size[0] * m_Spacing[0];
       // xz Plane
 //      bool xzPlaneAtOriginCrossYSection      = yMin <= m_Origin[1] && yMax >= m_Origin[1];
 //      bool xzPlaneAtImageBorderCrossYSection = yMin <= m_Size[1] * m_Spacing[1]   && yMax >= m_Size[1] * m_Spacing[1];
       bool xzPlaneNotCrossYSection           = yMin >= m_Origin[1] && yMax <= m_Size[1] * m_Spacing[1];
       // xy Plane
 //      bool xyPlaneAtOriginCrossZSection      = zMin <= m_Origin[2] && zMax >= m_Origin[2];
 //      bool xyPlaneAtImageBorderCrossZSection = zMin <= m_Size[2] * m_Spacing[2]   && zMax >= m_Size[2] * m_Spacing[2];
       bool xyPlaneNotCrossZSection           = zMin >= m_Origin[2] && zMax <= m_Size[2] * m_Spacing[2];
 
       if( yzPlaneNotCrossYSection && xzPlaneNotCrossYSection && xyPlaneNotCrossZSection)
       {
         m_meanValueTemp  = m_meanValueTemp +  this->MultiGaussianFunctionValueAtCuboid( xMin, xMax, yMin, yMax, zMin, zMax );
         m_Volume = m_Volume + pow( 2.0 * cuboidRadius, 3.0);
       }
       // check if the boundary of the image intersect the cuboid and if yes, change the limits of the cuboid to be only inside the image;  therefor we cut the sphere and neglect the part of it outside the image
 
       else
         /*
          if( // one plane crosses the cuboid
         ( (yzPlaneAtOriginCrossXSection      && xzPlaneNotCrossYSection           && xyPlaneNotCrossZSection) ||
         (yzPlaneAtImageBorderCrossXSection   && xzPlaneNotCrossYSection           && xyPlaneNotCrossZSection) ||
 
         (yzPlaneNotCrossYSection             && xzPlaneAtOriginCrossYSection      && xyPlaneNotCrossZSection) ||
         (yzPlaneNotCrossYSection             && xzPlaneAtImageBorderCrossYSection && xyPlaneNotCrossZSection) ||
 
         (yzPlaneNotCrossYSection             && xzPlaneNotCrossYSection           && xyPlaneAtOriginCrossZSection) ||
         (yzPlaneNotCrossYSection             && xzPlaneNotCrossYSection           && xyPlaneAtImageBorderCrossZSection) )
         || // two plane cross the cuboid (on the image edges possible)
         ( (yzPlaneAtOriginCrossXSection      && xzPlaneAtOriginCrossYSection      && xyPlaneNotCrossZSection) ||
         ( (yzPlaneAtOriginCrossXSection      && xzPlaneNotCrossYSection           && xyPlaneAtOriginCrossZSection) ||
         (yzPlaneAtImageBorderCrossXSection   && xzPlaneAtImageBorderCrossYSection && xyPlaneNotCrossZSection) ||
         (yzPlaneAtImageBorderCrossXSection   && xzPlaneNotCrossYSection           && xyPlaneAtImageBorderCrossZSection) ||
 
         (yzPlaneNotCrossYSection             && xzPlaneAtOriginCrossYSection      && xyPlaneNotCrossZSection) ||
         (yzPlaneNotCrossYSection             && xzPlaneAtOriginCrossYSection      && xyPlaneAtOriginCrossZSection) ||
         (yzPlaneAtImageBorderCrossXSection   && xzPlaneAtImageBorderCrossYSection && xyPlaneNotCrossZSection) ||
         (yzPlaneNotCrossYSection             && xzPlaneAtImageBorderCrossYSection && xyPlaneAtImageBorderCrossZSection) ||
 
         (yzPlaneNotCrossYSection             && xzPlaneAtImageBorderCrossYSection && xyPlaneAtOriginCrossZSection) ||
         (yzPlaneAtOriginCrossXSection        && xzPlaneNotCrossYSection           && xyPlaneAtOriginCrossZSection) ||
         (yzPlaneNotCrossYSection             && xzPlaneAtImageBorderCrossYSection && xyPlaneAtImageBorderCrossZSection)) ||
         (yzPlaneAtImageBorderCrossXSection   && xzPlaneNotCrossYSection           && xyPlaneAtImageBorderCrossZSection) )
         )
         */
       {
         // x-Axis
         if(xMin <= m_Origin[0] && xMax >= m_Origin[0])
         {
           xMin = m_Origin[0];
         }else if(xMin <= m_Size[0] * m_Spacing[0]  && xMax >= m_Size[0] * m_Spacing[0])
         {
           xMax = m_Size[0] * m_Spacing[0];
         }
         // y-Axis
         if(yMin <= m_Origin[1] && yMax >= m_Origin[1])
         {
           yMin = m_Origin[1];
         }else if(yMin <= m_Size[1] * m_Spacing[1] && yMax >= m_Size[1] * m_Spacing[1])
         {
           yMax = m_Size[1] * m_Spacing[1];
         }
         // z-Axis
         if(zMin <= m_Origin[2] && zMax >= m_Origin[2])
         {
           zMin = m_Origin[2];
         }else if(zMin <= m_Size[2] * m_Spacing[2] && zMax >= m_Size[2] * m_Spacing[2])
         {
           zMax = m_Size[2] * m_Spacing[2];
         }
         m_meanValueTemp  = m_meanValueTemp + this->MultiGaussianFunctionValueAtCuboid( xMin, xMax, yMin, yMax, zMin, zMax );
         m_Volume = m_Volume + (xMax - xMin) * (yMax - yMin) * (zMax - zMin) ;
 
       }
     }
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   /* Start the octree recursion in eigth directions for the sphere with midpoint globalCoordinateMidpointSphere and, if uncommented, write this in a file, so that we can visualise it. */
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::GenerateCuboidSegmentationInSphere(PointType globalCoordinateMidpointSphere)
   {
     double cuboidRadius = m_Radius * 0.5;
     PointType newMidpoint;
     for(int i = -1; i < 2; i+=2)
     {
       for(int k = -1; k < 2; k+=2)
       {
         for(int j = -1; j < 2; j+=2)
         {
           newMidpoint[0] = globalCoordinateMidpointSphere[0] + static_cast<double>(i) * cuboidRadius;
           newMidpoint[1] = globalCoordinateMidpointSphere[1] + static_cast<double>(k) * cuboidRadius;
           newMidpoint[2] = globalCoordinateMidpointSphere[2] + static_cast<double>(j) * cuboidRadius;
 
           CalculateEdgesInSphere( newMidpoint, globalCoordinateMidpointSphere, cuboidRadius, 0);
         }
       }
     }
 
     if(m_WriteMPS)
     {
       m_WriteMPS = 0;
       // uncomment to write an .mps file to visualise the midpoints
       // std::cout << "Wrote .xml to visualise the midpoints." <<  std::endl;
       // WriteXMLToTestTheCuboidInsideTheSphere();
     }
   }
 
   //----------------------------------------------------------------------------------------------------------------------
   /* This class allows by the method CalculateTheMidpointAndTheMeanValueWithOctree() to find a sphere with a specified radius that has a maximal mean value over all sphere with that radius with midpoint inside or at the boundary of the image. We approximaze the sphere with the octree recursiv method.
   CalculateTheMidpointAndTheMeanValueWithOctree works as follows:
   1. The for-loops traverse the region of interest and assume the current point to be the wanted sphere midpoint.
   2. Calculate the mean value for that sphere.
   3. Compare with the until-now-found-maximum and take the bigger one. */
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::CalculateTheMidpointAndTheMeanValueWithOctree()
   {
 
     m_MeanValue = 0.0;
     double meanValueTemp;
 
     m_WriteMPS = 1;
     PointType globalCoordinateMidpointSphere;
     IndexType index;
     OutputImageRegionType  regionOfInterest;
     IndexType indexR;
     indexR.SetElement( 0, m_RegionOfInterestMin[0] );
     indexR.SetElement( 1, m_RegionOfInterestMin[1] );
     indexR.SetElement( 2, m_RegionOfInterestMin[2] );
     regionOfInterest.SetIndex(indexR);
     SizeType sizeROI;
     sizeROI.SetElement( 0, m_RegionOfInterestMax[0] - m_RegionOfInterestMin[0] + 1);
     sizeROI.SetElement( 1, m_RegionOfInterestMax[1] - m_RegionOfInterestMin[1] + 1);
     sizeROI.SetElement( 2, m_RegionOfInterestMax[2] - m_RegionOfInterestMin[2] + 1);
     regionOfInterest.SetSize(sizeROI);
     typename TOutputImage::Pointer image = this->GetOutput(0);
     IteratorType regionOfInterestIterator(image, regionOfInterest);
 
     for(regionOfInterestIterator.GoToBegin(); !regionOfInterestIterator.IsAtEnd(); ++regionOfInterestIterator)
     {
       index = regionOfInterestIterator.GetIndex();
       image->TransformIndexToPhysicalPoint(index, globalCoordinateMidpointSphere);
       m_Volume = 0.0;
       m_meanValueTemp = 0.0;
       this->GenerateCuboidSegmentationInSphere(globalCoordinateMidpointSphere);
       meanValueTemp = m_meanValueTemp / m_Volume;
       // std::cout << "index: " << index <<" meanvalue: " << meanValueTemp << std::endl;
       if(meanValueTemp > m_MeanValue)
       {
         m_GlobalCoordinate = globalCoordinateMidpointSphere;
         m_MeanValue = meanValueTemp;
         m_SphereMidpoint = index;
       }
     }
   }
 
   //----------------------------------------------------------------------------------------------------------------------
   /*
   Check if a cuboid intersect the sphere boundary. Returns 2, if  the cuboid is inside the sphere; returns 1, if the  cuboid intersects the sphere boundary and 0, if the cuboid is out of the sphere.
   */
   template< class TOutputImage >
   unsigned int
     MultiGaussianImageSource< TOutputImage >
     ::IntersectTheSphere( PointType globalCoordinateMidpointCuboid, PointType globalCoordinateMidpointSphere,  double cuboidRadius)
   {
     unsigned int intersect = 1;
     PointType cuboidEdge;
     int count = 0;
 
     for(int i = -1; i < 2; i+=2)
     {
       for(int k = -1; k < 2; k+=2)
       {
         for(int j = -1; j < 2; j+=2)
         {
           cuboidEdge[0] = globalCoordinateMidpointCuboid[0] + static_cast<double>(i) * cuboidRadius;
           cuboidEdge[1] = globalCoordinateMidpointCuboid[1] + static_cast<double>(k) * cuboidRadius;
           cuboidEdge[2] = globalCoordinateMidpointCuboid[2] + static_cast<double>(j) * cuboidRadius;
 
           if (globalCoordinateMidpointSphere.SquaredEuclideanDistanceTo(cuboidEdge) <= m_Radius * m_Radius)
           {
             ++count;
           }
         }
       }
     }
     if ( count == 0 )
     {
       // cuboid not in the sphere
       intersect = 0;
     }
     if (count == 8 )
     {
       // cuboid in the sphere
       intersect = 2;
     }
     return intersect;
   }
 
   //----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   double
     MultiGaussianImageSource< TOutputImage >
     ::MultiGaussianFunctionValueAtPoint(double x, double y, double z)
   {
     //this claculate the mean value in the voxel
     //integrate over the voxel with midpoint [x, y, z]
     double summand0, summand1, summand2/*, power*/, value = 0.0, factor;
     double xMin, xMax, yMin, yMax, zMin, zMax, mean;
     mean = 0.0;
     // the for-loop represent  the sum of the gaussian function
     xMin = x - m_Spacing[0] / 2.0;
     xMax = x + m_Spacing[0] / 2.0;
     yMin = y - m_Spacing[1] / 2.0;
     yMax = y + m_Spacing[1] / 2.0;
     zMin = z - m_Spacing[2] / 2.0;
     zMax = z + m_Spacing[2] / 2.0;
     for( unsigned int n = 0; n < m_NumberOfGaussians; ++n )
     {
       summand0 = FunctionPhi( (xMax - m_CenterX[n]) / m_SigmaX[n] ) - FunctionPhi( (xMin - m_CenterX[n]) / m_SigmaX[n] );
       summand1 = FunctionPhi( (yMax - m_CenterY[n]) / m_SigmaY[n] ) - FunctionPhi( (yMin - m_CenterY[n]) / m_SigmaY[n] );
       summand2 = FunctionPhi( (zMax - m_CenterZ[n]) / m_SigmaZ[n] ) - FunctionPhi( (zMin - m_CenterZ[n]) / m_SigmaZ[n] );
       value = summand0 * summand1 * summand2;
       factor = ( m_SigmaX[n] * m_SigmaY[n] * m_SigmaZ[n] ) * pow( 2.0 * itk::Math::pi, 1.5 );
       mean = mean + factor * value * m_Altitude[n];
     }
     value = mean / (m_Spacing[0] * m_Spacing[1] * m_Spacing[2] );
 
     /*
 
     //this calculate the value of the gaussian at the midpoint of the voxel:
     double summand0, summand1, summand2, power, value = 0.0;
     // the for-loop represent  the sum of the gaussian function
     for(unsigned int n =0; n < m_NumberOfGaussians; ++n)
     {
     summand0 = ( x - m_CenterX[n] ) / m_SigmaX[n];
     summand1 = ( y - m_CenterY[n] ) / m_SigmaY[n];
     summand2 = ( z - m_CenterZ[n] ) / m_SigmaZ[n];
 
     power = summand0 * summand0 + summand1 * summand1 + summand2 * summand2;
     value = value + m_Altitude[n] * pow(itk::Math::e, -0.5 * power);
     }
 
     */
    // std::cout << "X: " << xMin << " " << x << " "<< xMax << "   Y: "<< yMin << " " << y << " " << yMax << " Z: "<< zMin << " "<< z << " " << zMax << "   value:    " << value << std::endl;
     return value;
   }
 
   //----------------------------------------------------------------------------------------------------------------------
   template< class TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::AddGaussian( VectorType x, VectorType y, VectorType z, VectorType sx, VectorType sy, VectorType sz, VectorType altitude)
   {
     for(unsigned int i = 0; i < x.size();  ++i)
     {
 
       m_CenterX.push_back( x[i] );
       m_CenterY.push_back( y[i] );
       m_CenterZ.push_back( z[i] );
       m_SigmaX.push_back( sx[i] );
       m_SigmaY.push_back( sy[i] );
       m_SigmaZ.push_back( sz[i] );
       m_Altitude.push_back(altitude[i]);
     }
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   template< typename TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::GenerateOutputInformation()
   {
     TOutputImage *output;
     IndexType     index;
     index.Fill(0);
     output = this->GetOutput(0);
     typename TOutputImage::RegionType largestPossibleRegion;
     largestPossibleRegion.SetSize(this->m_Size);
     largestPossibleRegion.SetIndex(index);
     output->SetLargestPossibleRegion(largestPossibleRegion);
     output->SetSpacing(m_Spacing);
     output->SetOrigin(m_Origin);
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   template< typename TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::GenerateData()
   {
     itkDebugMacro(<< "Generating a  image of scalars ");
     double valueReal;
     IndexType index;
     typename TOutputImage::Pointer image = this->GetOutput(0);
     image = this->GetOutput(0);
     image->SetBufferedRegion( image->GetRequestedRegion() );
     image->Allocate();
     IteratorType imageIt(image, image->GetLargestPossibleRegion());
     PointType globalCoordinate;
     this->SetNormalDistributionValues();
     for(imageIt.GoToBegin(); !imageIt.IsAtEnd(); ++imageIt)
     {
       valueReal = 0.0;
       index = imageIt.GetIndex();
       image->TransformIndexToPhysicalPoint(imageIt.GetIndex(), globalCoordinate);
       valueReal = MultiGaussianFunctionValueAtPoint(globalCoordinate[0], globalCoordinate[1] ,globalCoordinate[2]);
       imageIt.Set(valueReal);
     }
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   /*This method is used to write a .mps file, so that we can visualize the midpoints of the approximated sphere as a scatterplot (for example with MITK Workbench).
   */
   template< typename TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::WriteXMLToTestTheCuboidInsideTheSphere()
   {
     std::stringstream                                                    ss;
 
 
     int numberSummand = 1.0;
 
     //write an  .mps test file
     itk::DOMNodeXMLWriter::Pointer                                       xmlWriter;
     typedef itk::DOMNode::Pointer                                        DOMNodeType;
     DOMNodeType                                                          domXML, domPointSetFile, domFileVersion, domPointSet, domPoint, domId, domX, domY, domZ;
 
     xmlWriter = itk::DOMNodeXMLWriter::New();
     domXML =  itk::DOMNode::New();
     domXML->SetName("?xml");
     domPointSetFile =  itk::DOMNode::New();
     domPointSetFile->SetName("point_set_file");
     //domFileVersion =  itk::DOMNode::New();
     //domFileVersion->SetName("file_version");
     domPointSet =  itk::DOMNode::New();
     domPointSet->SetName("point_set");
 
     ss.str("");
     ss << 1.0;
     domXML->SetAttribute("version", ss.str());
     domXML->AddChildAtBegin(domPointSetFile);
     //domPointSetFile -> AddChildAtBegin(domFileVersion);
     domPointSetFile -> AddChildAtBegin(domPointSet);
 
 
     unsigned int cap = m_Midpoints.Size();
     for(unsigned int  iter = 0 ; iter < cap; ++iter)
     {
       domPoint =  itk::DOMNode::New();
       domPoint->SetName("point");
       domX =  itk::DOMNode::New();
       domX->SetName("x");
       domY =  itk::DOMNode::New();
       domY->SetName("y");
       domZ =  itk::DOMNode::New();
       domZ->SetName("z");
       domId =  itk::DOMNode::New();
       domId->SetName("id");
 
 
       ss.str("");
       ss << numberSummand;
       domId->AddTextChildAtBegin(ss.str());
       domPoint -> AddChildAtEnd(domId);
 
       double scaleFactor = 10.0;
       PointType point = m_Midpoints.GetElement( numberSummand - 1 );
       ss.str("");
       ss <<  point[0] * scaleFactor;
       domX->AddTextChildAtBegin(ss.str());
       domPoint -> AddChildAtEnd(domX);
       ss.str("");
       ss << point[1] * scaleFactor;
       domY->AddTextChildAtBegin(ss.str());
       domPoint -> AddChildAtEnd(domY);
       ss.str("");
       ss << point[2] * scaleFactor;
       domZ->AddTextChildAtBegin(ss.str());
       domPoint -> AddChildAtEnd(domZ);
       domPointSet -> AddChildAtEnd(domPoint);
 
       numberSummand += 1.0;
     }
 
 
     // .mps (Data)
     ss.str("");
     ss << "C:/temp/CuboidsInTheSphere.mps";
     std::string name = ss.str();
     char * fileNamePointer = (char*) name.c_str();
     xmlWriter->SetFileName( fileNamePointer);
     xmlWriter->SetInput( domXML );
     xmlWriter->Update();
 
 
 
 
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   template< typename TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::CalculateMaxAndMinInSphere()
   {
     IndexType index;
     typename MultiGaussianImageSource< TOutputImage >::OutputImagePixelType value;
     m_MaxValueInSphere = std::numeric_limits<OutputImagePixelType>::min();
     m_MinValueInSphere = std::numeric_limits<OutputImagePixelType>::max();
     int radInt, sizeRegion;
     OutputImageRegionType  cuboidRegion;
     IndexType indexR;
     SizeType sizeR;
     int indexRegion, originAsIndex;
     for( unsigned int i = 0; i < 3; ++i )
     {
       radInt = static_cast<int>(m_Radius/m_Spacing[i]);
       indexRegion =  m_SphereMidpoint[i] - radInt;
       originAsIndex = static_cast<int>(m_Origin[i]/m_Spacing[i]);
       if( originAsIndex > indexRegion )
       {
         indexR.SetElement(i, originAsIndex );
       }
       else
       {
         indexR.SetElement(i, indexRegion );
       }
 
       sizeRegion = 2 *radInt + 1;
       int sizeOutputImage = m_Size[i];
       if( (indexR[i] + sizeRegion) > (originAsIndex + sizeOutputImage) )
       {
         std::cout << "Not the entire sphere is in the image!" << std::endl;
         sizeR.SetElement(i,  m_Size[i] - indexRegion );
       }
       else
       {
         sizeR.SetElement(i,  sizeRegion );
       }
     }
     cuboidRegion.SetIndex(indexR);
     cuboidRegion.SetSize(sizeR);
     typename TOutputImage::Pointer image = this->GetOutput(0);
     IteratorType cuboidRegionOfInterestIterator(image, cuboidRegion);
     PointType globalCoordinate;
     for(cuboidRegionOfInterestIterator.GoToBegin(); !cuboidRegionOfInterestIterator.IsAtEnd(); ++cuboidRegionOfInterestIterator)
     {
       index = cuboidRegionOfInterestIterator.GetIndex();
       if(IsInImage(index))
       {
         image->TransformIndexToPhysicalPoint(cuboidRegionOfInterestIterator.GetIndex(), globalCoordinate);
         if( m_GlobalCoordinate.EuclideanDistanceTo(globalCoordinate) <= m_Radius )
         {
           value = cuboidRegionOfInterestIterator.Get();
           if(m_MaxValueInSphere < value)
           {
             m_MaxValueInSphere = value;
             m_MaxValueIndexInSphere = index;
           }
           if(m_MinValueInSphere > value)
           {
             m_MinValueInSphere = value;
             m_MinValueIndexInSphere = index;
           }
         }
       }
     }
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   template< typename TOutputImage >
   bool
     MultiGaussianImageSource< TOutputImage >
     ::IsInImage(IndexType index)
   {
     bool isInImage = true;
     int originAsIndex;
     for( unsigned int i = 0; i < 3; ++i )
     {
       originAsIndex = static_cast<int>(m_Origin[i]/m_Spacing[i]);
       int sizeOfOutputImage = m_Size[i];
       if( index[i] < originAsIndex || index[i] > (originAsIndex + sizeOfOutputImage) )
         return false;
     }
     return isInImage;
   }
 
   //-----------------------------------------------------------------------------------------------------------------------
   template< typename TOutputImage >
   void
     MultiGaussianImageSource< TOutputImage >
     ::SetNormalDistributionValues()
   {
 
     double temp[410] = { 0.5 ,       0.50399 ,       0.50798,       0.51197,       0.51595,       0.51994,       0.52392,       0.5279,       0.53188,       0.53586,       0.53983,       0.5438,       0.54776,       0.55172,       0.55567,       0.55962,       0.56356,       0.56749,       0.57142,       0.57535,       0.57926,       0.58317,       0.58706,       0.59095,       0.59483 ,       0.59871,       0.60257,       0.60642,       0.61026,       0.61409,       0.61791,       0.62172,       0.62552,       0.6293,       0.63307,       0.63683,       0.64058,       0.64431,       0.64803,       0.65173,       0.65542,       0.6591,       0.66276,       0.6664,       0.67003,       0.67364,       0.67724,       0.68082,       0.68439,       0.68793,       0.69146,       0.69497,       0.69847,       0.70194,       0.7054,       0.70884,       0.71226,       0.71566,       0.71904,       0.7224,       0.72575,       0.72907,       0.73237,       0.73565,       0.73891,       0.74215,       0.74537,       0.74857,       0.75175,       0.7549,       0.75804,       0.76115,       0.76424,       0.7673,       0.77035,       0.77337,       0.77637,       0.77935,       0.7823,       0.78524,       0.78814,       0.79103,       0.79389,       0.79673,       0.79955,       0.80234,       0.80511,       0.80785,       0.81057,       0.81327,       0.81594,       0.81859,       0.82121,       0.82381,       0.82639,       0.82894,       0.83147,       0.83398,       0.83646,       0.83891,       0.84134,       0.84375,       0.84614,       0.84849,       0.85083,       0.85314,       0.85543,       0.85769,       0.85993,       0.86214,       0.86433,       0.8665,       0.86864,       0.87076,       0.87286,       0.87493,       0.87698,       0.879,       0.881,       0.88298,       0.88493,       0.88686,       0.88877,       0.89065,       0.89251,       0.89435,       0.89617,       0.89796,       0.89973,       0.90147,       0.9032,       0.9049,       0.90658,       0.90824,       0.90988,       0.91149,       0.91309,       0.91466,       0.91621,       0.91774,       0.91924,       0.92073,       0.9222,       0.92364,       0.92507,       0.92647,       0.92785,       0.92922,       0.93056,       0.93189,       0.93319,       0.93448,       0.93574,       0.93699,       0.93822,       0.93943,       0.94062,       0.94179,       0.94295,       0.94408,       0.9452,       0.9463,       0.94738,       0.94845,       0.9495,       0.95053,       0.95154,       0.95254,       0.95352,       0.95449,       0.95543,       0.95637,       0.95728,       0.95818,       0.95907,       0.95994,       0.9608,       0.96164,       0.96246,       0.96327,       0.96407,       0.96485,       0.96562,       0.96638,       0.96712,       0.96784,       0.96856,       0.96926,       0.96995,       0.97062,       0.97128,       0.97193,       0.97257,       0.9732,       0.97381,       0.97441,       0.975,       0.97558,       0.97615,       0.9767,       0.97725,       0.97778,       0.97831,       0.97882,       0.97932,       0.97982,       0.9803,       0.98077,       0.98124,       0.98169,       0.98214,       0.98257,       0.983,       0.98341,       0.98382,       0.98422,       0.98461,       0.985,       0.98537,       0.98574,       0.9861,       0.98645,       0.98679,       0.98713,       0.98745,       0.98778,       0.98809,       0.9884,       0.9887,       0.98899,       0.98928,       0.98956,       0.98983,       0.9901,       0.99036,       0.99061,       0.99086,       0.99111,       0.99134,       0.99158,       0.9918,       0.99202,       0.99224,       0.99245,       0.99266,       0.99286,       0.99305,       0.99324,       0.99343,       0.99361,       0.99379,       0.99396,       0.99413,       0.9943,       0.99446,       0.99461,       0.99477,       0.99492,       0.99506,       0.9952,       0.99534,       0.99547,       0.9956,       0.99573,       0.99585,       0.99598,       0.99609,       0.99621,       0.99632,       0.99643,       0.99653,       0.99664,       0.99674,       0.99683,       0.99693,       0.99702,       0.99711,       0.9972,       0.99728,       0.99736,       0.99744,       0.99752,       0.9976,       0.99767,       0.99774,       0.99781,       0.99788,       0.99795,       0.99801,       0.99807,       0.99813,       0.99819,       0.99825,       0.99831,       0.99836,       0.99841,       0.99846,       0.99851,       0.99856,       0.99861,       0.99865,       0.99869,       0.99874,       0.99878,       0.99882,       0.99886,       0.99889,       0.99893,       0.99896,       0.999,       0.99903,       0.99906,       0.9991,       0.99913,       0.99916,       0.99918,       0.99921,       0.99924,       0.99926,       0.99929,       0.99931,       0.99934,       0.99936,       0.99938,       0.9994,       0.99942,       0.99944,       0.99946,       0.99948,       0.9995,       0.99952,       0.99953,       0.99955,       0.99957,       0.99958,       0.9996,       0.99961,       0.99962,       0.99964,       0.99965,       0.99966,       0.99968,       0.99969,       0.9997,       0.99971,       0.99972,       0.99973,       0.99974,       0.99975,       0.99976,       0.99977,       0.99978,       0.99978,       0.99979,       0.9998,       0.99981,       0.99981,       0.99982,       0.99983,       0.99983,       0.99984,       0.99985,       0.99985,       0.99986,       0.99986,       0.99987,       0.99987,       0.99988,       0.99988,       0.99989,       0.99989,       0.9999,       0.9999,       0.9999,       0.99991,       0.99991,       0.99992,       0.99992,       0.99992,       0.99992,       0.99993,       0.99993,       0.99993,       0.99994,       0.99994,       0.99994,       0.99994,       0.99995,       0.99995,       0.99995,       0.99995,       0.99995,       0.99996,       0.99996,       0.99996,       0.99996,       0.99996,       0.99996,       0.99997,       0.99997,       0.99997,       0.99997,       0.99997,       0.99997,       0.99997,       0.99997,       0.99998,       0.99998,       0.99998,       0.99998     };
 
     for(int i=0; i < 410; i++)
     {
       m_NormalDistValues[i] = temp[i];
     }
 
   }
 
 
 } // end namespace itk
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     #endif
diff --git a/Modules/ImageStatistics/mitkitkMaskImageFilter.h b/Modules/ImageStatistics/mitkitkMaskImageFilter.h
index 68f2004590..e649aaf951 100644
--- a/Modules/ImageStatistics/mitkitkMaskImageFilter.h
+++ b/Modules/ImageStatistics/mitkitkMaskImageFilter.h
@@ -1,285 +1,285 @@
 /*=========================================================================
  *
  *  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
+ *         https://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 __itkMaskImageFilter2_h
 #define __itkMaskImageFilter2_h
 
 #include "itkBinaryFunctorImageFilter.h"
 #include "itkNumericTraits.h"
 #include "itkVariableLengthVector.h"
 #include <MitkImageStatisticsExports.h>
 
 namespace itk
 {
 namespace Functor
 {
 /**
  * \class MaskInput2
  * \brief
  * \ingroup ITKImageIntensity
  */
 template< typename TInput, typename TMask, typename TOutput = TInput >
 class MaskInput2
 {
 public:
   typedef typename NumericTraits< TInput >::AccumulateType AccumulatorType;
 
   MaskInput2()
   {
     m_MaskingValue = NumericTraits< TMask >::ZeroValue();
     InitializeOutsideValue( static_cast<TOutput*>( nullptr ) );
   }
   ~MaskInput2() {}
   bool operator!=(const MaskInput2 &) const
   {
     return false;
   }
 
   bool operator==(const MaskInput2 & other) const
   {
     return !( *this != other );
   }
 
   inline TOutput operator()(const TInput & A, const TMask & B) const
   {
     if ( B == m_MaskingValue )
       {
       return static_cast< TOutput >( A );
       }
     else
       {
       return m_OutsideValue;
       }
   }
 
   /** Method to explicitly set the outside value of the mask */
   void SetOutsideValue(const TOutput & outsideValue)
   {
     m_OutsideValue = outsideValue;
   }
 
   /** Method to get the outside value of the mask */
   const TOutput & GetOutsideValue() const
   {
     return m_OutsideValue;
   }
 
   /** Method to explicitly set the masking value */
   void SetMaskingValue(const TMask & maskingValue)
   {
     m_MaskingValue = maskingValue;
   }
   /** Method to get the masking value */
   const TMask & GetMaskingValue() const
   {
     return m_MaskingValue;
   }
 
 private:
 
   template < typename TPixelType >
   void InitializeOutsideValue( TPixelType * )
   {
     this->m_OutsideValue = NumericTraits< TPixelType >::ZeroValue();
   }
 
   template < typename TValue >
   void InitializeOutsideValue( VariableLengthVector<TValue> * )
   {
     // set the outside value to be of zero length
     this->m_OutsideValue = VariableLengthVector< TValue >(0);
   }
 
   TOutput m_OutsideValue;
   TMask   m_MaskingValue;
 };
 }
 /** \class MaskImageFilter
  * \brief Mask an image with a mask.
  *
  * This class is templated over the types of the
  * input image type, the mask image type and the type of the output image.
  * Numeric conversions (castings) are done by the C++ defaults.
  *
  * The pixel type of the input 2 image must have a valid definition of the
  * operator != with zero. This condition is required because internally this
  * filter will perform the operation
  *
  * \code{.unparsed}
  *        if pixel_from_mask_image == masking_value
  *             pixel_output_image = pixel_input_image
  *        else
  *             pixel_output_image = outside_value
  * \endcode
  *
  * The pixel from the input 1 is cast to the pixel type of the output image.
  *
  * Note that the input and the mask images must be of the same size.
  *
  *
  * \sa MaskNegatedImageFilter
  * \ingroup IntensityImageFilters
  * \ingroup MultiThreaded
  * \ingroup ITKImageIntensity
  */
 template< typename TInputImage, typename TMaskImage, typename TOutputImage = TInputImage >
 class MITKIMAGESTATISTICS_EXPORT MaskImageFilter2:
   public
   BinaryFunctorImageFilter< TInputImage, TMaskImage, TOutputImage,
                             Functor::MaskInput2<
                               typename TInputImage::PixelType,
                               typename TMaskImage::PixelType,
                               typename TOutputImage::PixelType >   >
 
 {
 public:
   /** Standard class typedefs. */
   typedef MaskImageFilter2 Self;
   typedef BinaryFunctorImageFilter< TInputImage, TMaskImage, TOutputImage,
                                     Functor::MaskInput2<
                                       typename TInputImage::PixelType,
                                       typename TMaskImage::PixelType,
                                       typename TOutputImage::PixelType >
                                     >                                 Superclass;
 
   typedef SmartPointer< Self >       Pointer;
   typedef SmartPointer< const Self > ConstPointer;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self);
 
   /** Runtime information support. */
   itkTypeMacro(MaskImageFilter2,
                BinaryFunctorImageFilter);
 
   /** Typedefs **/
   typedef TMaskImage MaskImageType;
 
   /** Set/Get the mask image. Pixels set in the mask image will retain
    *  the original value of the input image while pixels not set in
    *  the mask will be set to the "OutsideValue".
    */
   void SetMaskImage(const MaskImageType *maskImage)
   {
     // Process object is not const-correct so the const casting is required.
     this->SetNthInput( 1, const_cast< MaskImageType * >( maskImage ) );
   }
   const MaskImageType * GetMaskImage()
   {
     return static_cast<const MaskImageType*>(this->ProcessObject::GetInput(1));
   }
 
   /** Method to explicitly set the outside value of the mask. Defaults to 0 */
   void SetOutsideValue(const typename TOutputImage::PixelType & outsideValue)
   {
     if ( this->GetOutsideValue() != outsideValue )
       {
       this->Modified();
       this->GetFunctor().SetOutsideValue(outsideValue);
       }
   }
 
   const typename TOutputImage::PixelType & GetOutsideValue() const
   {
     return this->GetFunctor().GetOutsideValue();
   }
 
   /** Method to explicitly set the masking value of the mask. Defaults to 0 */
   void SetMaskingValue(const typename TMaskImage::PixelType & maskingValue)
   {
     if ( this->GetMaskingValue() != maskingValue )
       {
       this->Modified();
       this->GetFunctor().SetMaskingValue(maskingValue);
       }
   }
 
   /** Method to get the masking value of the mask. */
   const typename TMaskImage::PixelType & GetMaskingValue() const
   {
     return this->GetFunctor().GetMaskingValue();
   }
 
   void BeforeThreadedGenerateData() override
   {
     typedef typename TOutputImage::PixelType PixelType;
     this->CheckOutsideValue( static_cast<PixelType*>(nullptr) );
   }
 
 #ifdef ITK_USE_CONCEPT_CHECKING
   // Begin concept checking
   itkConceptMacro( MaskEqualityComparableCheck,
                    ( Concept::EqualityComparable< typename TMaskImage::PixelType > ) );
   itkConceptMacro( InputConvertibleToOutputCheck,
                    ( Concept::Convertible< typename TInputImage::PixelType,
                                            typename TOutputImage::PixelType > ) );
   // End concept checking
 #endif
 
 protected:
   MaskImageFilter2() {}
   ~MaskImageFilter2() override {}
 
   void PrintSelf(std::ostream & os, Indent indent) const override
   {
     Superclass::PrintSelf(os, indent);
     os << indent << "OutsideValue: "  << this->GetOutsideValue() << std::endl;
   }
 
 private:
   MaskImageFilter2(const Self &); //purposely not implemented
   void operator=(const Self &);  //purposely not implemented
 
   template < typename TPixelType >
   void CheckOutsideValue( const TPixelType * ) {}
 
   template < typename TValue >
   void CheckOutsideValue( const VariableLengthVector< TValue > * )
   {
     // Check to see if the outside value contains only zeros. If so,
     // resize it to have the same number of zeros as the output
     // image. Otherwise, check that the number of components in the
     // outside value is the same as the number of components in the
     // output image. If not, throw an exception.
     VariableLengthVector< TValue > currentValue =
       this->GetFunctor().GetOutsideValue();
     VariableLengthVector< TValue > zeroVector( currentValue.GetSize() );
     zeroVector.Fill( NumericTraits< TValue >::ZeroValue() );
 
     if ( currentValue == zeroVector )
       {
       zeroVector.SetSize( this->GetOutput()->GetVectorLength() );
       zeroVector.Fill( NumericTraits< TValue >::ZeroValue() );
       this->GetFunctor().SetOutsideValue( zeroVector );
       }
     else if ( this->GetFunctor().GetOutsideValue().GetSize() !=
               this->GetOutput()->GetVectorLength() )
       {
       itkExceptionMacro(
         << "Number of components in OutsideValue: "
         <<  this->GetFunctor().GetOutsideValue().GetSize()
         << " is not the same as the "
         << "number of components in the image: "
         << this->GetOutput()->GetVectorLength());
       }
   }
 
 };
 } // end namespace itk
 
 #endif
 
diff --git a/Modules/ImageStatistics/test.hxx b/Modules/ImageStatistics/test.hxx
index c96230c36e..1f7a271fbf 100644
--- a/Modules/ImageStatistics/test.hxx
+++ b/Modules/ImageStatistics/test.hxx
@@ -1,111 +1,111 @@
 *=========================================================================
  *
  *  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
+ *         https://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 __itkLabelStatisticsImageFilter_hxx
 #define __itkLabelStatisticsImageFilter_hxx
 #include "itkLabelStatisticsImageFilter.h"
 
 #include "itkImageRegionIterator.h"
 #include "itkImageRegionConstIteratorWithIndex.h"
 #include "itkProgressReporter.h"
 
 namespace itk
 {
 
 
 
 template< class TInputImage, class TLabelImage >
 typename ExtendedLabelStatisticsImageFilter< TInputImage, TLabelImage >::RealType
 ExtendedLabelStatisticsImageFilter< TInputImage, TLabelImage >
 ::GetKurtosis(LabelPixelType label) const
 {
   MapConstIterator mapIt;
 
   mapIt = m_LabelStatistics.find(label);
   if ( mapIt == m_LabelStatistics.end() )
     {
     // label does not exist, return a default value
     return NumericTraits< PixelType >::Zero;
     }
   else
     {
     return ( *mapIt ).second.m_Kurtosis;
     }
 }
 
 
 template< class TInputImage, class TLabelImage >
 typename ExtendedLabelStatisticsImageFilter< TInputImage, TLabelImage >::RealType
 ExtendedLabelStatisticsImageFilter< TInputImage, TLabelImage >
 ::GetSkewness(LabelPixelType label) const
 {
   MapConstIterator mapIt;
 
   mapIt = m_LabelStatistics.find(label);
   if ( mapIt == m_LabelStatistics.end() )
     {
     // label does not exist, return a default value
     return NumericTraits< PixelType >::Zero;
     }
   else
     {
     return ( *mapIt ).second.m_Skewness;
     }
 }
 
 
 
 
 template< class TInputImage, class TLabelImage >
 void
 ExtendedLabelStatisticsImageFilter< TInputImage, TLabelImage >::
  computeTheSkewnessAndCurtosis()
 {
 
    std::list< int > relevantLabels;
   bool maskNonEmpty = false;
   unsigned int i;
   for ( i = 1; i < 4096; ++i )
   {
     if ( labelStatisticsFilter->HasLabel( i ) )
     {
       relevantLabels.push_back( i );
       maskNonEmpty = true;
     }
   }
 
   if ( maskNonEmpty )
   {
       std::list< int >::iterator it;
     for ( it = relevantLabels.begin(), i = 0;
       it != relevantLabels.end();
       ++it, ++i )
     {
 
      // RealType Varinace = GetVariance( *it );
       //RealType Mean     = GetSigma( *it );
 
          m_LabelStatistics2;
 
     }
   }
 
 
 }
 
 } // end namespace itk
 #endif
\ No newline at end of file
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationRunnable.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationRunnable.cpp
index 7dc62e5227..7d8ad4cbc6 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationRunnable.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationRunnable.cpp
@@ -1,187 +1,183 @@
-/*===================================================================
+/*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
+Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
 
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
+============================================================================*/
 
 #include "QmitkImageStatisticsCalculationRunnable.h"
 
 #include "mitkImageStatisticsCalculator.h"
 #include <mitkImageMaskGenerator.h>
 #include <mitkPlanarFigureMaskGenerator.h>
 #include <mitkIgnorePixelMaskGenerator.h>
 #include "mitkStatisticsToImageRelationRule.h"
 #include "mitkStatisticsToMaskRelationRule.h"
 #include "mitkImageStatisticsContainerManager.h"
 #include "mitkProperties.h"
 
 QmitkImageStatisticsCalculationRunnable::QmitkImageStatisticsCalculationRunnable()
   : QmitkDataGenerationJobBase()
   , m_StatisticsImage(nullptr)
   , m_BinaryMask(nullptr)
   , m_PlanarFigureMask(nullptr)
   , m_IgnoreZeros(false)
   , m_HistogramNBins(100)
 {
 }
 
 QmitkImageStatisticsCalculationRunnable::~QmitkImageStatisticsCalculationRunnable()
 {
 }
 
 void QmitkImageStatisticsCalculationRunnable::Initialize(const mitk::Image *image,
   const mitk::Image *binaryImage,
   const mitk::PlanarFigure *planarFig)
 {
   this->m_StatisticsImage = image;
   this->m_BinaryMask = binaryImage;
   this->m_PlanarFigureMask = planarFig;
 }
 
 mitk::ImageStatisticsContainer* QmitkImageStatisticsCalculationRunnable::GetStatisticsData() const
 {
   return this->m_StatisticsContainer.GetPointer();
 }
 
 const mitk::Image* QmitkImageStatisticsCalculationRunnable::GetStatisticsImage() const
 {
   return this->m_StatisticsImage.GetPointer();
 }
 
 const mitk::Image* QmitkImageStatisticsCalculationRunnable::GetMaskImage() const
 {
   return this->m_BinaryMask.GetPointer();
 }
 
 const mitk::PlanarFigure* QmitkImageStatisticsCalculationRunnable::GetPlanarFigure() const
 {
   return this->m_PlanarFigureMask.GetPointer();
 }
 
 void QmitkImageStatisticsCalculationRunnable::SetIgnoreZeroValueVoxel(bool _arg)
 {
   this->m_IgnoreZeros = _arg;
 }
 
 bool QmitkImageStatisticsCalculationRunnable::GetIgnoreZeroValueVoxel() const
 {
   return this->m_IgnoreZeros;
 }
 
 void QmitkImageStatisticsCalculationRunnable::SetHistogramNBins(unsigned int nbins)
 {
   this->m_HistogramNBins = nbins;
 }
 
 unsigned int QmitkImageStatisticsCalculationRunnable::GetHistogramNBins() const
 {
   return this->m_HistogramNBins;
 }
 
 QmitkDataGenerationJobBase::ResultMapType QmitkImageStatisticsCalculationRunnable::GetResults() const
 {
   ResultMapType result;
   result.emplace("statistics", this->GetStatisticsData());
   return result;
 }
 
 bool QmitkImageStatisticsCalculationRunnable::RunComputation()
 {
   bool statisticCalculationSuccessful = true;
   mitk::ImageStatisticsCalculator::Pointer calculator = mitk::ImageStatisticsCalculator::New();
 
   if (this->m_StatisticsImage.IsNotNull())
   {
     calculator->SetInputImage(m_StatisticsImage);
   }
   else
   {
     statisticCalculationSuccessful = false;
   }
 
   // Bug 13416 : The ImageStatistics::SetImageMask() method can throw exceptions, i.e. when the dimensionality
   // of the masked and input image differ, we need to catch them and mark the calculation as failed
   // the same holds for the ::SetPlanarFigure()
   try
   {
     if (this->m_BinaryMask.IsNotNull())
     {
       mitk::ImageMaskGenerator::Pointer imgMask = mitk::ImageMaskGenerator::New();
       imgMask->SetInputImage(m_StatisticsImage);
       imgMask->SetImageMask(m_BinaryMask);
       calculator->SetMask(imgMask.GetPointer());
     }
     if (this->m_PlanarFigureMask.IsNotNull())
     {
       mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
       pfMaskGen->SetInputImage(m_StatisticsImage);
       pfMaskGen->SetPlanarFigure(m_PlanarFigureMask->Clone());
       calculator->SetMask(pfMaskGen.GetPointer());
     }
   }
   catch (const std::exception &e)
   {
     MITK_ERROR << "Error while configuring the statistics calculator: " << e.what();
     m_LastErrorMessage = e.what();
     statisticCalculationSuccessful = false;
   }
 
   if (this->m_IgnoreZeros)
   {
     mitk::IgnorePixelMaskGenerator::Pointer ignorePixelValueMaskGen = mitk::IgnorePixelMaskGenerator::New();
     ignorePixelValueMaskGen->SetIgnoredPixelValue(0);
     ignorePixelValueMaskGen->SetInputImage(m_StatisticsImage);
     calculator->SetSecondaryMask(ignorePixelValueMaskGen.GetPointer());
   }
   else
   {
     calculator->SetSecondaryMask(nullptr);
   }
 
   calculator->SetNBinsForHistogramStatistics(m_HistogramNBins);
 
   try
   {
     calculator->GetStatistics();
   }
   catch (const std::exception &e)
   {
     m_LastErrorMessage = "Failure while calculating the statistics: " + std::string(e.what());
     MITK_ERROR << m_LastErrorMessage;
     statisticCalculationSuccessful = false;
   }
 
   if (statisticCalculationSuccessful)
   {
     m_StatisticsContainer = calculator->GetStatistics();
 
     auto imageRule = mitk::StatisticsToImageRelationRule::New();
     imageRule->Connect(m_StatisticsContainer, m_StatisticsImage);
 
     if (nullptr != m_PlanarFigureMask)
     {
       auto maskRule = mitk::StatisticsToMaskRelationRule::New();
       maskRule->Connect(m_StatisticsContainer, m_PlanarFigureMask);
     }
 
     if (nullptr != m_BinaryMask)
     {
       auto maskRule = mitk::StatisticsToMaskRelationRule::New();
       maskRule->Connect(m_StatisticsContainer, m_BinaryMask);
     }
 
     m_StatisticsContainer->SetProperty(mitk::STATS_HISTOGRAM_BIN_PROPERTY_NAME.c_str(), mitk::UIntProperty::New(m_HistogramNBins));
     m_StatisticsContainer->SetProperty(mitk::STATS_IGNORE_ZERO_VOXEL_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(m_IgnoreZeros));
   }
   return statisticCalculationSuccessful;
 }
diff --git a/Modules/ModelFit/include/itkMaskedStatisticsImageFilter.h b/Modules/ModelFit/include/itkMaskedStatisticsImageFilter.h
index 36c057fcca..0ae9fb6a94 100644
--- a/Modules/ModelFit/include/itkMaskedStatisticsImageFilter.h
+++ b/Modules/ModelFit/include/itkMaskedStatisticsImageFilter.h
@@ -1,195 +1,195 @@
 /*=========================================================================
 *
 *  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
+*         https://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 __itkMaskedStatisticsImageFilter_h
 #define __itkMaskedStatisticsImageFilter_h
 
 #include "itkImageToImageFilter.h"
 #include "itkNumericTraits.h"
 #include "itkArray.h"
 #include "itkSimpleDataObjectDecorator.h"
 
 namespace itk
 {
   /** \class MaskedStatisticsImageFilter
   * \brief Compute min. max, variance and mean of an (masked) Image.
   *
   * MaskedStatisticsImageFilter computes the minimum, maximum, sum, mean, variance
   * sigma of an image.  The filter needs all of its input image.  It
   * behaves as a filter with an input and output. Thus it can be inserted
   * in a pipeline with other filters and the statistics will only be
   * recomputed if a downstream filter changes.
   *
   * The filter passes its input through unmodified.  The filter is
   * threaded. It computes statistics in each thread then combines them in
   * its AfterThreadedGenerate method.
   * \remark This filter differs from itk::StatisticsImageFilter by the fact that you can
   * specify an mask image. If set, only pixels within the mask (mask value > 0) are taken
   * into account for the statistics.
   *
   * \ingroup MathematicalStatisticsImageFilters
   * \ingroup ITKImageStatistics
   *
   */
   template< typename TInputImage , typename TMaskImage = ::itk::Image<unsigned char, TInputImage::ImageDimension> >
   class MaskedStatisticsImageFilter:
     public ImageToImageFilter< TInputImage, TInputImage >
   {
   public:
     /** Standard Self typedef */
     typedef MaskedStatisticsImageFilter                          Self;
     typedef ImageToImageFilter< TInputImage, TInputImage > Superclass;
     typedef SmartPointer< Self >                           Pointer;
     typedef SmartPointer< const Self >                     ConstPointer;
 
     /** Method for creation through the object factory. */
     itkNewMacro(Self);
 
     /** Runtime information support. */
     itkTypeMacro(MaskedStatisticsImageFilter, ImageToImageFilter);
 
     /** Image related typedefs. */
     typedef typename Superclass::InputImageType InputImageType;
     typedef typename Superclass::InputImagePointer InputImagePointer;
 
     typedef typename TInputImage::RegionType RegionType;
     typedef typename TInputImage::SizeType   SizeType;
     typedef typename TInputImage::IndexType  IndexType;
     typedef typename TInputImage::PixelType  PixelType;
 
     /** Image related typedefs. */
     itkStaticConstMacro(ImageDimension, unsigned int,
       TInputImage::ImageDimension);
 
     /** Type to use for computations. */
     typedef typename NumericTraits< PixelType >::RealType RealType;
 
     /** Smart Pointer type to a DataObject. */
     typedef typename DataObject::Pointer DataObjectPointer;
 
     /** Type of DataObjects used for scalar outputs */
     typedef SimpleDataObjectDecorator< RealType >  RealObjectType;
     typedef SimpleDataObjectDecorator< PixelType > PixelObjectType;
 
     typedef TMaskImage MaskImageType;
     typedef typename MaskImageType::ConstPointer     MaskImageConstPointer;
     typedef typename MaskImageType::RegionType  MaskImageRegionType;
 
     /** 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. */
     typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
     using Superclass::MakeOutput;
     DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) override;
 
     itkSetConstObjectMacro(Mask, MaskImageType);
     itkGetConstObjectMacro(Mask, MaskImageType);
 
 #ifdef ITK_USE_CONCEPT_CHECKING
     // Begin concept checking
     itkConceptMacro( InputHasNumericTraitsCheck,
       ( Concept::HasNumericTraits< PixelType > ) );
     // End concept checking
 #endif
 
   protected:
     MaskedStatisticsImageFilter();
     ~MaskedStatisticsImageFilter() override{}
     void PrintSelf(std::ostream & os, Indent indent) const override;
 
     /** Pass the input through unmodified. Do this by Grafting in the
     *  AllocateOutputs method.
     */
     void AllocateOutputs() override;
 
     /** Initialize some accumulators before the threads run. */
     void BeforeThreadedGenerateData() override;
 
     /** Do final mean and variance computation from data accumulated in threads.
     */
     void AfterThreadedGenerateData() override;
 
     /** Multi-thread version GenerateData. */
     void  ThreadedGenerateData(const RegionType &
       outputRegionForThread,
       ThreadIdType threadId) override;
 
     // Override since the filter needs all the data for the algorithm
     void GenerateInputRequestedRegion() override;
 
     // Override since the filter produces all of its output
     void EnlargeOutputRequestedRegion(DataObject *data) override;
 
   private:
     MaskedStatisticsImageFilter(const Self &); //purposely not implemented
     void operator=(const Self &);        //purposely not implemented
 
     Array< RealType >       m_ThreadSum;
     Array< RealType >       m_SumOfSquares;
     Array< SizeValueType >  m_Count;
     Array< PixelType >      m_ThreadMin;
     Array< PixelType >      m_ThreadMax;
     MaskImageConstPointer        m_Mask;
   }; // end of class
 } // end namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkMaskedStatisticsImageFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/ModelFit/include/itkMaskedStatisticsImageFilter.hxx b/Modules/ModelFit/include/itkMaskedStatisticsImageFilter.hxx
index 63a3902636..e320d71061 100644
--- a/Modules/ModelFit/include/itkMaskedStatisticsImageFilter.hxx
+++ b/Modules/ModelFit/include/itkMaskedStatisticsImageFilter.hxx
@@ -1,395 +1,395 @@
 /*=========================================================================
 *
 *  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
+*         https://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 __itkMaskedStatisticsImageFilter_hxx
 #define __itkMaskedStatisticsImageFilter_hxx
 #include "itkMaskedStatisticsImageFilter.h"
 
 
 #include "itkImageScanlineIterator.h"
 #include "itkProgressReporter.h"
 
 namespace itk
 {
   template< typename TInputImage, typename TMaskImage >
   MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::MaskedStatisticsImageFilter():m_ThreadSum(1), m_SumOfSquares(1), m_Count(1), m_ThreadMin(1), m_ThreadMax(1)
   {
     this->DynamicMultiThreadingOff();
 
     // 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< PixelObjectType * >( this->MakeOutput(i).GetPointer() );
       this->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< RealObjectType * >( this->MakeOutput(i).GetPointer() );
       this->ProcessObject::SetNthOutput( i, output.GetPointer() );
     }
 
     this->GetMinimumOutput()->Set( NumericTraits< PixelType >::max() );
     this->GetMaximumOutput()->Set( NumericTraits< PixelType >::NonpositiveMin() );
     this->GetMeanOutput()->Set( NumericTraits< RealType >::max() );
     this->GetSigmaOutput()->Set( NumericTraits< RealType >::max() );
     this->GetVarianceOutput()->Set( NumericTraits< RealType >::max() );
     this->GetSumOutput()->Set(NumericTraits< RealType >::Zero);
   }
 
   template< typename TInputImage, typename TMaskImage >
   DataObject::Pointer
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::MakeOutput(DataObjectPointerArraySizeType output)
   {
     switch ( output )
     {
     case 0:
       return TInputImage::New().GetPointer();
       break;
     case 1:
       return PixelObjectType::New().GetPointer();
       break;
     case 2:
       return PixelObjectType::New().GetPointer();
       break;
     case 3:
     case 4:
     case 5:
     case 6:
       return RealObjectType::New().GetPointer();
       break;
     default:
       // might as well make an image
       return TInputImage::New().GetPointer();
       break;
     }
   }
 
   template< typename TInputImage, typename TMaskImage >
   typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::PixelObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetMinimumOutput()
   {
     return static_cast< PixelObjectType * >( this->ProcessObject::GetOutput(1) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   const typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::PixelObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetMinimumOutput() const
   {
     return static_cast< const PixelObjectType * >( this->ProcessObject::GetOutput(1) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::PixelObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetMaximumOutput()
   {
     return static_cast< PixelObjectType * >( this->ProcessObject::GetOutput(2) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   const typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::PixelObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetMaximumOutput() const
   {
     return static_cast< const PixelObjectType * >( this->ProcessObject::GetOutput(2) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::RealObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetMeanOutput()
   {
     return static_cast< RealObjectType * >( this->ProcessObject::GetOutput(3) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   const typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::RealObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetMeanOutput() const
   {
     return static_cast< const RealObjectType * >( this->ProcessObject::GetOutput(3) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::RealObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetSigmaOutput()
   {
     return static_cast< RealObjectType * >( this->ProcessObject::GetOutput(4) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   const typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::RealObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetSigmaOutput() const
   {
     return static_cast< const RealObjectType * >( this->ProcessObject::GetOutput(4) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::RealObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetVarianceOutput()
   {
     return static_cast< RealObjectType * >( this->ProcessObject::GetOutput(5) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   const typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::RealObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetVarianceOutput() const
   {
     return static_cast< const RealObjectType * >( this->ProcessObject::GetOutput(5) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::RealObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetSumOutput()
   {
     return static_cast< RealObjectType * >( this->ProcessObject::GetOutput(6) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   const typename MaskedStatisticsImageFilter< TInputImage, TMaskImage >::RealObjectType *
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GetSumOutput() const
   {
     return static_cast< const RealObjectType * >( this->ProcessObject::GetOutput(6) );
   }
 
   template< typename TInputImage, typename TMaskImage >
   void
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::GenerateInputRequestedRegion()
   {
     Superclass::GenerateInputRequestedRegion();
     if ( this->GetInput() )
     {
       InputImagePointer image =
         const_cast< typename Superclass::InputImageType * >( this->GetInput() );
       image->SetRequestedRegionToLargestPossibleRegion();
     }
   }
 
   template< typename TInputImage, typename TMaskImage >
   void
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::EnlargeOutputRequestedRegion(DataObject *data)
   {
     Superclass::EnlargeOutputRequestedRegion(data);
     data->SetRequestedRegionToLargestPossibleRegion();
   }
 
   template< typename TInputImage, typename TMaskImage >
   void
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::AllocateOutputs()
   {
     // Pass the input through as the output
     InputImagePointer image =
       const_cast< TInputImage * >( this->GetInput() );
 
     this->GraftOutput(image);
 
     // Nothing that needs to be allocated for the remaining outputs
   }
 
   template< typename TInputImage, typename TMaskImage >
   void
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::BeforeThreadedGenerateData()
   {
     ThreadIdType numberOfThreads = this->GetNumberOfWorkUnits();
 
     // 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(NumericTraits< SizeValueType >::Zero);
     m_ThreadSum.Fill(NumericTraits< RealType >::Zero);
     m_SumOfSquares.Fill(NumericTraits< RealType >::Zero);
     m_ThreadMin.Fill( NumericTraits< PixelType >::max() );
     m_ThreadMax.Fill( NumericTraits< PixelType >::NonpositiveMin() );
   }
 
   template< typename TInputImage, typename TMaskImage >
   void
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::AfterThreadedGenerateData()
   {
     ThreadIdType    i;
     SizeValueType   count;
     RealType        sumOfSquares;
 
     ThreadIdType numberOfThreads = this->GetNumberOfWorkUnits();
 
     PixelType minimum;
     PixelType maximum;
     RealType  mean;
     RealType  sigma;
     RealType  variance;
     RealType  sum;
 
     sum = sumOfSquares = NumericTraits< RealType >::Zero;
     count = 0;
 
     // Find the min/max over all threads and accumulate count, sum and
     // sum of squares
     minimum = NumericTraits< PixelType >::max();
     maximum = NumericTraits< PixelType >::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];
       }
     }
     // compute statistics
     mean = sum / static_cast< RealType >( count );
 
     // unbiased estimate
     variance = ( sumOfSquares - ( sum * sum / static_cast< RealType >( count ) ) )
       / ( static_cast< RealType >( count ) - 1 );
     sigma = std::sqrt(variance);
 
     // 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< typename TInputImage, typename TMaskImage >
   void
     MaskedStatisticsImageFilter< TInputImage, TMaskImage >
     ::ThreadedGenerateData(const RegionType & outputRegionForThread,
     ThreadIdType threadId)
   {
     const SizeValueType size0 = outputRegionForThread.GetSize(0);
     if( size0 == 0)
     {
       return;
     }
     RealType  realValue;
     PixelType value;
 
     RealType sum = NumericTraits< RealType >::Zero;
     RealType sumOfSquares = NumericTraits< RealType >::Zero;
     SizeValueType count = NumericTraits< SizeValueType >::Zero;
     PixelType min = NumericTraits< PixelType >::max();
     PixelType max = NumericTraits< PixelType >::NonpositiveMin();
 
     ImageScanlineConstIterator< TInputImage > it (this->GetInput(),  outputRegionForThread);
 
     // support progress methods/callbacks
     const size_t numberOfLinesToProcess = outputRegionForThread.GetNumberOfPixels() / size0;
     ProgressReporter progress( this, threadId, numberOfLinesToProcess );
 
     // do the work
     while ( !it.IsAtEnd() )
     {
       while ( !it.IsAtEndOfLine() )
       {
         bool isValid = true;
 
         if(m_Mask.IsNotNull())
         {
           typename InputImageType::IndexType index = it.GetIndex();
           typename InputImageType::PointType point;
           this->GetInput()->TransformIndexToPhysicalPoint(index, point);
           if (this->m_Mask->TransformPhysicalPointToIndex(point, index))
           {
             isValid = this->m_Mask->GetPixel(index) > 0.0;
           };
         }
 
         if (isValid)
         {
           value = it.Get();
           realValue = static_cast< RealType >( value );
           if ( value < min )
           {
             min = value;
           }
           if ( value > max )
           {
             max  = value;
           }
 
           sum += realValue;
           sumOfSquares += ( realValue * realValue );
           ++count;
         }
 
         ++it;
       }
       it.NextLine();
       progress.CompletedPixel();
     }
 
     m_ThreadSum[threadId] = sum;
     m_SumOfSquares[threadId] = sumOfSquares;
     m_Count[threadId] = count;
     m_ThreadMin[threadId] = min;
     m_ThreadMax[threadId] = max;
   }
 
   template< typename TImage, typename TMaskImage >
   void
     MaskedStatisticsImageFilter< TImage, TMaskImage >
     ::PrintSelf(std::ostream & os, Indent indent) const
   {
     Superclass::PrintSelf(os, indent);
 
     os << indent << "Minimum: "
       << static_cast< typename NumericTraits< PixelType >::PrintType >( this->GetMinimum() ) << std::endl;
     os << indent << "Maximum: "
       << static_cast< typename NumericTraits< PixelType >::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 itk
 #endif
diff --git a/Modules/ModelFit/src/Common/mitkFormulaParser.cpp b/Modules/ModelFit/src/Common/mitkFormulaParser.cpp
index eda29c8517..ab6f4e85e8 100644
--- a/Modules/ModelFit/src/Common/mitkFormulaParser.cpp
+++ b/Modules/ModelFit/src/Common/mitkFormulaParser.cpp
@@ -1,290 +1,288 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <boost/math/constants/constants.hpp>
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/phoenix.hpp>
 #include <boost/version.hpp>
 
 #include "mitkFormulaParser.h"
 #include "mitkFresnel.h"
 
 namespace qi = boost::spirit::qi;
 namespace ascii = boost::spirit::ascii;
 namespace phx = boost::phoenix;
 
 typedef std::string::const_iterator Iter;
 typedef ascii::space_type Skipper;
 
 namespace qi = boost::spirit::qi;
 
 namespace mitk
 {
   /*!
    *	@brief			Transforms the given number from degrees to radians and returns it.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] deg	A scalar value in degrees.
    *	@return			The given value in radians.
    */
   template<typename T>
   inline T deg2rad(const T deg)
   {
     return deg * boost::math::constants::pi<T>() / static_cast<T>(180);
   }
 
   /*!
    *	@brief			Returns the cosine of the given degree scalar.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	A scalar value in degrees whose cosine should be returned.
    *	@return			The cosine of the given degree scalar.
    */
   template<typename T>
   inline T cosd(const T t)
   {
     return std::cos(deg2rad(t));
   }
 
   /*!
    *	@brief			Returns the sine of the given degree scalar.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	A scalar value in degrees whose sine should be returned.
    *	@return			The sine of the given degree scalar.
    */
   template<typename T>
   inline T sind(const T t)
   {
     return std::sin(deg2rad(t));
   }
 
   /*!
    *	@brief			Returns the tangent of the given degree scalar.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	A scalar value in degrees whose tangent should be returned.
    *	@return			The tangent of the given degree scalar.
    */
   template<typename T>
   inline T tand(const T t)
   {
     return std::tan(deg2rad(t));
   }
 
   /*!
    *	@brief			Returns the fresnel integral sine at the given x-coordinate.
    *	@details		Code for "fresnel_s()" (fresnel.cpp and fresnel.h) taken as-is from the GNU
-   *					Scientific Library (http://www.gnu.org/software/gsl/), specifically from
-   *					http://www.network-theory.co.uk/download/gslextras/Fresnel/.
+   *					Scientific Library (https://www.gnu.org/software/gsl/).
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	The x-coordinate at which the fresnel integral sine should be returned.
    *	@return			The fresnel integral sine at the given x-coordinate.
    */
   template<typename T>
   T fresnelS(const T t)
   {
     T x = t / boost::math::constants::root_half_pi<T>();
     return static_cast<T>(fresnel_s(x) / boost::math::constants::root_two_div_pi<T>());
   }
 
   /*!
    *	@brief			Returns the fresnel integral cosine at the given x-coordinate.
    *	@details		Code for "fresnel_c()" (fresnel.cpp and fresnel.h) taken as-is from the GNU
-   *					Scientific Library (http://www.gnu.org/software/gsl/), specifically from
-   *					http://www.network-theory.co.uk/download/gslextras/Fresnel/.
+   *					Scientific Library (https://www.gnu.org/software/gsl/).
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	The x-coordinate at which the fresnel integral cosine should be returned.
    *	@return			The fresnel integral cosine at the given x-coordinate.
    */
   template<typename T>
   T fresnelC(const T t)
   {
     T x = t / boost::math::constants::root_half_pi<T>();
     return static_cast<T>(fresnel_c(x) / boost::math::constants::root_two_div_pi<T>());
   }
 
   /*!
    *	@brief		The grammar that defines the language (i.e. what is allowed) for the parser.
    */
   class Grammar : public qi::grammar<Iter, FormulaParser::ValueType(), Skipper>
   {
     /*!
      *	@brief	Helper structure that makes it easier to dynamically call any
      *			one-parameter-function by overloading the @c () operator.
      */
     struct func1_
     {
       // Required for Phoenix 3+
       template<typename Sig>
       struct result;
 
       /*!
        *	@brief				Helper structure that is needed for compatibility with
        *						@c boost::phoenix.
        *	@tparam Functor		Type of the functor (this struct).
        *	@tparam Function	Type of the function that should be called.
        *	@tparam Arg1		Type of the argument the function should be called with.
        *
        */
       template<typename Functor, typename Function, typename Arg1>
       struct result<Functor(Function, Arg1&)>
       {
         /*! @brief The result structure always needs this typedef */
         typedef Arg1 type;
       };
 
       /*!
        *	@brief				Calls the function @b f with the argument @b a1 and returns the
        *						result.
        *						The result always has the same type as the argument.
        *	@tparam Function	Type of the function that should be called.
        *	@tparam Arg1			Type of the argument the function should be called with.
        *	@param[in] f		The function that should be called.
        *	@param[in] a1		The argument the function should be called with.
        *	@return				The result of the called function.
        */
       template<typename Function, typename Arg1>
       Arg1 operator()(const Function f, const Arg1 a1) const
       {
         return f(a1);
       }
     };
 
     /*!
      *	@brief	Helper structure that maps strings to function calls so that parsing e.g.
      *			@c "cos(0)" actually calls the @c std::cos function with parameter @c 1 so it
      *			returns @c 0.
      */
     class unaryFunction_ :
       public qi::symbols<typename std::iterator_traits<Iter>::value_type, FormulaParser::ValueType(*)(FormulaParser::ValueType)>
     {
     public:
       /*!
        *	@brief Constructs the structure, this is where the mapping takes place.
        */
       unaryFunction_()
       {
         this->add
         ("abs", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::abs))
           ("exp", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::exp)) // @TODO: exp ignores division by zero
           ("sin", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::sin))
           ("cos", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::cos))
           ("tan", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::tan))
           ("sind", &sind)
           ("cosd", &cosd)
           ("tand", &tand)
           ("fresnelS", &fresnelS)
           ("fresnelC", &fresnelC);
       }
     } unaryFunction;
 
   public:
     /*!
      *	@brief							Constructs the grammar with the given formula parser.
      *	@param[in, out] formulaParser	The formula parser this grammar is for - so it can
      *									access its variable map.
      */
     Grammar(FormulaParser& formulaParser) : Grammar::base_type(start)
     {
       using qi::_val;
       using qi::_1;
       using qi::_2;
       using qi::char_;
       using qi::alpha;
       using qi::alnum;
       using qi::double_;
       using qi::as_string;
 
       phx::function<func1_> func1;
 
       start = expression > qi::eoi;
 
       expression = term[_val = _1]
         >> *(('+' >> term[_val += _1])
           | ('-' >> term[_val -= _1]));
 
       term = factor[_val = _1]
         >> *(('*' >> factor[_val *= _1])
           | ('/' >> factor[_val /= _1]));
 
       factor = primary[_val = _1];
       /*!	@TODO:	Repair exponentiation */
       //>> *('^' >> factor[phx::bind<FormulaParser::ValueType, FormulaParser::ValueType, FormulaParser::ValueType>(std::pow, _val, _1)]);
 
       variable = as_string[alpha >> *(alnum | char_('_'))]
         [_val = phx::bind(&FormulaParser::lookupVariable, &formulaParser, _1)];
 
       primary = double_[_val = _1]
         | '(' >> expression[_val = _1] >> ')'
         | ('-' >> primary[_val = -_1])
         | ('+' >> primary[_val = _1])
         | (unaryFunction >> '(' >> expression >> ')')[_val = func1(_1, _2)]
         | variable[_val = _1];
     }
 
     /*! the rules of the grammar. */
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> start;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> expression;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> term;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> factor;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> variable;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> primary;
   };
 
 
   FormulaParser::FormulaParser(const VariableMapType* variables) : m_Variables(variables)
   {}
 
   FormulaParser::ValueType FormulaParser::parse(const std::string& input)
   {
     std::string::const_iterator iter = input.begin();
     std::string::const_iterator end = input.end();
     FormulaParser::ValueType result = static_cast<FormulaParser::ValueType>(0);
 
     try
     {
       if (!qi::phrase_parse(iter, end, Grammar(*this), ascii::space, result))
       {
         mitkThrowException(FormulaParserException) << "Could not parse '" << input <<
           "': Grammar could not be applied to the input " << "at all.";
       }
     }
     catch (qi::expectation_failure<Iter>& e)
     {
       std::string parsed = "";
 
       for (Iter i = input.begin(); i != e.first; i++)
       {
         parsed += *i;
       }
       mitkThrowException(FormulaParserException) << "Error while parsing '" << input <<
         "': Unexpected character '" << *e.first << "' after '" << parsed << "'";
     }
 
     return result;
   };
 
   FormulaParser::ValueType FormulaParser::lookupVariable(const std::string var)
   {
     if (m_Variables == nullptr)
     {
       mitkThrowException(FormulaParserException) << "Map of variables is empty";
     }
 
     try
     {
       return m_Variables->at(var);
     }
     catch (std::out_of_range&)
     {
       mitkThrowException(FormulaParserException) << "No variable '" << var << "' defined in lookup";
     }
   };
 
 }
diff --git a/Modules/OpenCVVideoSupport/mitkMovieGeneratorOpenCV.cpp b/Modules/OpenCVVideoSupport/mitkMovieGeneratorOpenCV.cpp
index 50701f6003..44a9a8dfa2 100644
--- a/Modules/OpenCVVideoSupport/mitkMovieGeneratorOpenCV.cpp
+++ b/Modules/OpenCVVideoSupport/mitkMovieGeneratorOpenCV.cpp
@@ -1,131 +1,129 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkMovieGeneratorOpenCV.h"
 //#include <GL/gl.h>
 #include "mitkGL.h"
 #include <iostream>
 
 
 mitk::MovieGeneratorOpenCV::MovieGeneratorOpenCV()
 {
   m_initialized = false;
   m_aviWriter   = nullptr;
   m_dwRate = 20;
 
   m_FourCCCodec = nullptr;
   m_RemoveColouredFrame = true;
 }
 
 
 void mitk::MovieGeneratorOpenCV::SetFileName( const char *fileName )
 {
 
   m_sFile = fileName;
 }
 
 void mitk::MovieGeneratorOpenCV::SetFrameRate(unsigned int rate)
 {
   m_dwRate = static_cast<int>(rate);
 }
 
 void mitk::MovieGeneratorOpenCV::SetRemoveColouredFrame(bool RemoveColouredFrame)
 {
   m_RemoveColouredFrame = RemoveColouredFrame;
 }
 
 bool mitk::MovieGeneratorOpenCV::InitGenerator()
 {
   m_width = m_renderer->GetRenderWindow()->GetSize()[0];  // changed from glGetIntegerv( GL_VIEWPORT, viewport );
   m_height = m_renderer->GetRenderWindow()->GetSize()[1]; // due to sometimes strange dimensions
 
   if(m_RemoveColouredFrame)
   {
     m_width  -= 10;  //remove colored boarders around renderwindows
     m_height -= 10;
   }
 
   m_width -= m_width % 4; // some video codecs have prerequisites to the image dimensions
   m_height -= m_height % 4;
 
   m_currentFrame = cvCreateImage(cvSize(m_width,m_height),8,3); // creating image with widget size, 8 bit per pixel and 3 channel r,g,b
   m_currentFrame->origin = 1; // avoid building a video with bottom up
 
   /*
   m_sFile = Name of the output video file.
   CV_FOURCC = 4-character code of codec used to compress the frames. For example, CV_FOURCC('P','I','M','1') is MPEG-1 codec,
   CV_FOURCC('M','J','P','G') is motion-jpeg codec etc.
    CV_FOURCC('P','I','M','1')    = MPEG-1 codec
   CV_FOURCC('M','J','P','G')    = motion-jpeg codec (does not work well)
   CV_FOURCC('M', 'P', '4', '2') = MPEG-4.2 codec
   CV_FOURCC('D', 'I', 'V', '3') = MPEG-4.3 codec
   CV_FOURCC('D', 'I', 'V', 'X') = MPEG-4 codec
   CV_FOURCC('U', '2', '6', '3') = H263 codec
   CV_FOURCC('I', '2', '6', '3') = H263I codec
   CV_FOURCC('F', 'L', 'V', '1') = FLV1 codec
 
-  List of FOURCC codes is available at http://msdn2.microsoft.com/en-us/library/ms867195.aspx
-
   Under Win32 it is possible to pass -1 in order to choose compression
   method and additional compression parameters from dialog.
   m_dwRate = Framerate of the created video stream.
   frame_size Size of video frames. InitGenerator
   1 = If it is not zero, the encoder will expect and encode color frames, otherwise it will work with grayscale frames
   (the flag is currently supported on Windows only).*/
 
   if(m_FourCCCodec != nullptr)
   {
     #ifdef WIN32
       m_aviWriter = cvCreateVideoWriter(m_sFile.c_str(),CV_FOURCC(m_FourCCCodec[0],m_FourCCCodec[1],m_FourCCCodec[2],
                                         m_FourCCCodec[3]),m_dwRate,cvSize(m_width,m_height),1); //initializing video writer
     #else
       m_aviWriter = cvCreateVideoWriter(m_sFile.c_str(),CV_FOURCC(m_FourCCCodec[0],m_FourCCCodec[1],m_FourCCCodec[2],
                                         m_FourCCCodec[3]),m_dwRate,cvSize(m_width,m_height)); //initializing video writer
     #endif
   }
   else
   {
     #ifdef WIN32
       m_aviWriter = cvCreateVideoWriter(m_sFile.c_str(),-1,m_dwRate,cvSize(m_width,m_height),1); //initializing video writer
     #else
       m_aviWriter = cvCreateVideoWriter(m_sFile.c_str(),CV_FOURCC('X','V','I','D'),m_dwRate,cvSize(m_width,m_height)); //initializing video writer
     #endif
   }
 
 
   if(!m_aviWriter)
   {
     std::cout << "errors initializing video writer...correct video file path? on linux: ffmpeg must be included in OpenCV.";
     return false;
   }
 
   return true;
 }
 
 
 bool mitk::MovieGeneratorOpenCV::AddFrame( void *data )
 {
   //cvSetImageData(m_currentFrame,data,m_width*3);
   memcpy(m_currentFrame->imageData,data,m_width*m_height*3);
   cvWriteFrame(m_aviWriter,m_currentFrame);
   return true;
 }
 
 
 bool mitk::MovieGeneratorOpenCV::TerminateGenerator()
 {
   if (m_aviWriter)
   {
     cvReleaseVideoWriter(&m_aviWriter);
   }
   return true;
 }
diff --git a/Modules/OpenCVVideoSupport/mitkOpenCVVideoSource.h b/Modules/OpenCVVideoSupport/mitkOpenCVVideoSource.h
index e0bc23ccfc..332673a6cf 100644
--- a/Modules/OpenCVVideoSupport/mitkOpenCVVideoSource.h
+++ b/Modules/OpenCVVideoSupport/mitkOpenCVVideoSource.h
@@ -1,197 +1,195 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef _mitk_OpenCVVideo_Source_h_
 #define _mitk_OpenCVVideo_Source_h_
 
 #include "mitkConfig.h"
 
 #include "mitkVideoSource.h"
 #include "mitkUndistortCameraImage.h"
 
 // HighGui camera interface: a convenient way for grabbing from a video capture (on windows VfW is used)
 #include <opencv2/highgui.hpp>
 
 // For Providing ITK Image Interface
 #include "itkRGBPixel.h"
 #include "itkImage.h"
 #include "itkImageRegionIterator.h"
 #include "mitkOpenCVImageSource.h"
 
 namespace mitk
 {
  /**
  * Interface for acquiring video data using Intel's OPENCV library.
  * Video data may either be provided from a file or a grabbing device.
  * At the moment, OPENCV includes two separated modules for this grabbing, but only HighGui is
  * used here.
  * Initialize via SetVideoFileInput() or SetVideoCameraInput(), start processing with StartCapturing();
  */
   class MITKOPENCVVIDEOSUPPORT_EXPORT OpenCVVideoSource :
       virtual public VideoSource, virtual public OpenCVImageSource
   {
   public:
     typedef itk::RGBPixel< unsigned char >    CharPixelType;
     typedef itk::FixedArray <float,3>         HSVPixelType;
     typedef itk::Image< CharPixelType , 2 >   RGBPixelImageType;
     typedef itk::Image<HSVPixelType,2> HSVPixelImageType;
     typedef itk::ImageRegionIterator< RGBPixelImageType > RGBConstIteratorType;
     typedef itk::ImageRegionIterator< HSVPixelImageType > HSVConstIteratorType;
 
     mitkClassMacro( OpenCVVideoSource, VideoSource );
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     ////##Documentation
     ////## @brief sets a video file as input device. One video frame is being processed by updating the renderwindow.
     ////## Notice: Which codecs and file formats are supported depends on the back end library.
     ////## Common Function that currently uses HighGui Lib for video playback
     virtual void SetVideoFileInput(const char * filename, bool repeatVideo, bool useCVCAMLib = false);
     ////##Documentation
     ////##@brief Initializes capturing video from camera.
     ////## Common Function for use either with HIGHGUI or with CVCAM library
     ////## On windows: if you use CVCAM Library, you can pass -1 as camera index for a selection menu
     virtual void SetVideoCameraInput(int cameraindex, bool useCVCAMLib = false);
     ////##Documentation
     ////## The function GetVideoCaptureProperty retrieves the specified property of camera or video file from HIGHGUI LIBRARY.
     ////## Video input has to be initialized before call, that means: at least one frame has to be grabbed already.
     ////## The property_id identifier can be the following:
     ////## CV_CAP_PROP_POS_MSEC film current position in milliseconds or video capture timestamp
     ////## CV_CAP_PROP_POS_FRAMES 0-based index of the frame to be decoded/captured next
     ////## CV_CAP_PROP_POS_AVI_RATIO relative position of video file (0 - start of the film, 1 - end of the film)
     ////## CV_CAP_PROP_FRAME_WIDTH width of frames in the video stream
     ////## CV_CAP_PROP_FRAME_HEIGHT height of frames in the video stream
     ////## CV_CAP_PROP_FPS frame rate
     ////## CV_CAP_PROP_FOURCC 4-character code of codec
     ////## CV_CAP_PROP_FRAME_COUNT number of frames in video file
-    ////## See OpenCV Highgui documentation for more details ( http://opencvlibrary.sourceforge.net/HighGui )
     virtual double GetVideoCaptureProperty(int property_id);
     ////##Documentation
     ////## @brief sets the specified property of video capturing from HIGHGUI LIBRARY.
     ////## Notice: Some properties only can be set using a video file as input devices, others using a camera.
-    ////## See OpenCV Highgui documentation for more details ( http://opencvlibrary.sourceforge.net/HighGui )
     virtual int SetVideoCaptureProperty(int property_id, double value);
 
     virtual void GetCurrentFrameAsOpenCVImage(IplImage * image);
     ///
     /// \return a copy of the image as opencv 2 Mat
     ///
     cv::Mat GetImage() override;
     virtual const IplImage * GetCurrentFrame();
     ////##Documentation
     ////## @brief returns the current video data as an ITK image.
     virtual void GetCurrentFrameAsItkHSVPixelImage(HSVPixelImageType::Pointer &Image);
     ////##Documentation
     ////## @brief assigns the grabbing devices for acquiring the next frame.
     void FetchFrame() override;
     ////##Documentation
     ////## @brief returns a pointer to the image data array for opengl rendering.
     unsigned char * GetVideoTexture() override;
     ////##Documentation
     ////## @brief starts the video capturing.
     void StartCapturing() override;
     ////##Documentation
     ////## @brief stops the video capturing.
     void StopCapturing() override;
     ////##Documentation
     ////## @brief rotate image according to the set angle.
     virtual IplImage* FlipImage(IplImage* input);
     ////##Documentation
     ////## @brief EnableOnlineImageUndistortion allows for an online image undistortion directly after capturing an image.
     ////## The function has to be called after setting up the video input; the result is made accessible via the normal
     ////## GetCurrentFrame... functions.
     virtual void EnableOnlineImageUndistortion(mitk::Point3D focal, mitk::Point3D principal, mitk::Point4D distortion);
      ////##Documentation
     ////## @brief DisableOnlineImageUndistortion is used to disable the automatic image undistortion.
     virtual void DisableOnlineImageUndistortion();
     ///
     /// \return true if image undistorsion is enabled
     ///
     virtual bool OnlineImageUndistortionEnabled() const;
 
     void PauseCapturing() override;
     ///
     /// Returns the video file name (maybe empty if a grabbing device is used)
     ///
     itkGetConstMacro( VideoFileName, std::string );
 
     virtual void SetEnableXAxisFlip(bool enable);
     virtual void SetEnableYAxisFlip(bool enable);
 
     ///
     /// Returns the GrabbingDeviceNumber (maybe -1 if a video file is used)
     ///
     itkGetConstMacro( GrabbingDeviceNumber, short );
 
     itkGetMacro( RepeatVideo, bool );
     itkSetMacro( RepeatVideo, bool );
 
 
   protected:
     OpenCVVideoSource();
     ~OpenCVVideoSource() override;
 
     ///
     /// Resets the whole class for capturing from a new device
     ///
     void Reset();
 
     ////##Documentation
     ////## @brief internally used for converting the current video frame to a texture for opengl rendering,
     ////## so that GetVideoTexture() can be used.
     void UpdateVideoTexture();
 
     // Helper functions
     void sleep(unsigned int ms);
     void RGBtoHSV(float r, float g, float b, float &h, float &s, float &v);
 
     // HighGUI Library capture device
     CvCapture    * m_VideoCapture;
 
     // current Video image
     IplImage     * m_CurrentImage;
     unsigned char* m_CurrentVideoTexture;
 
     IplImage     * m_PauseImage;
 
     ///
     /// saves the video file name (is empty if a grabbing device is used or if this is not initialized)
     std::string m_VideoFileName;
 
     ///
     /// saves the grabbing device number (is -1 if a videofilename is used or if this is not initialized)
     short m_GrabbingDeviceNumber;
 
     // Repeat a video file
     bool m_RepeatVideo;
 
     // Switch between CVCAM Lib and HighGui Lib
     bool m_UseCVCAMLib;
 
     // On-the-fly undistortion of the captured video image
     bool m_UndistortImage;
     mitk::UndistortCameraImage::Pointer m_UndistortCameraImage;
 
     /**
     * Flag to enable or disable video flipping by X Axis.
     **/
     bool m_FlipXAxisEnabled;
 
     /**
     * Flag to enable or disable video flipping by Y Axis.
     **/
     bool m_FlipYAxisEnabled;
   };
 }
 #endif // Header
 
 
diff --git a/Modules/PlanarFigure/src/DataManagement/mitkPlanarPolygon.cpp b/Modules/PlanarFigure/src/DataManagement/mitkPlanarPolygon.cpp
index bd1fc94fd3..b0222f645e 100644
--- a/Modules/PlanarFigure/src/DataManagement/mitkPlanarPolygon.cpp
+++ b/Modules/PlanarFigure/src/DataManagement/mitkPlanarPolygon.cpp
@@ -1,271 +1,271 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkPlanarPolygon.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 
 // stl related includes
 #include <algorithm>
 
 mitk::PlanarPolygon::PlanarPolygon()
   : FEATURE_ID_CIRCUMFERENCE(this->AddFeature("Circumference", "mm")), FEATURE_ID_AREA(this->AddFeature("Area", "mm2"))
 {
   // Polygon has at least two control points
   this->ResetNumberOfControlPoints(2);
   this->SetNumberOfPolyLines(1);
 
   // Polygon is closed by default
   this->SetProperty("closed", mitk::BoolProperty::New(true));
   this->SetProperty("subdivision", mitk::BoolProperty::New(false));
 }
 
 void mitk::PlanarPolygon::SetClosed(bool closed)
 {
   this->SetProperty("closed", mitk::BoolProperty::New(closed));
 
   if (!closed)
   {
     // For non-closed polygons: use "Length" as feature name; disable area
     this->SetFeatureName(FEATURE_ID_CIRCUMFERENCE, "Length");
     this->DeactivateFeature(FEATURE_ID_AREA);
   }
   else
   {
     // For closed polygons: use "Circumference" as feature name; enable area
     this->SetFeatureName(FEATURE_ID_CIRCUMFERENCE, "Circumference");
     this->ActivateFeature(FEATURE_ID_AREA);
   }
 
   this->Modified();
 }
 
 void mitk::PlanarPolygon::GeneratePolyLine()
 {
   this->ClearPolyLines();
 
   for (ControlPointListType::size_type i = 0; i < m_ControlPoints.size(); ++i)
     this->AppendPointToPolyLine(0, this->GetControlPoint(i));
 }
 
 void mitk::PlanarPolygon::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
   // A polygon does not require helper objects
 }
 
 void mitk::PlanarPolygon::EvaluateFeaturesInternal()
 {
   // Calculate circumference
   double circumference = 0.0;
   unsigned int i, j;
 
   const PolyLineType polyLine = m_PolyLines[0];
 
   if (polyLine.empty())
     return;
 
   for (i = 0; i < (polyLine.size() - 1); ++i)
   {
     circumference += static_cast<Point2D>(polyLine[i]).EuclideanDistanceTo(static_cast<Point2D>(polyLine[i + 1]));
   }
 
   if (this->IsClosed())
   {
     circumference += static_cast<Point2D>(polyLine[i]).EuclideanDistanceTo(static_cast<Point2D>(polyLine.front()));
   }
 
   this->SetQuantity(FEATURE_ID_CIRCUMFERENCE, circumference);
 
   // Calculate polygon area (if closed)
   double area = 0.0;
   bool intersection = false;
 
   if (this->IsClosed() && (this->GetPlaneGeometry() != nullptr))
   {
     // does PlanarPolygon overlap/intersect itself?
     const unsigned int numberOfPoints = polyLine.size();
     if (numberOfPoints >= 4)
     {
       for (i = 0; i < (numberOfPoints - 1); ++i)
       {
         // line 1
         const Point2D p0 = polyLine[i];
         const Point2D p1 = polyLine[i + 1];
 
         // check for intersection with all other lines
         for (j = i + 1; j < (numberOfPoints - 1); ++j)
         {
           const Point2D p2 = polyLine[j];
           const Point2D p3 = polyLine[j + 1];
           intersection = CheckForLineIntersection(p0, p1, p2, p3);
           if (intersection)
             break;
         }
         if (intersection)
           break; // only because the inner loop might have changed "intersection"
 
         // last line from p_x to p_0
         const Point2D p2 = polyLine.front();
         const Point2D p3 = polyLine.back();
 
         intersection = CheckForLineIntersection(p0, p1, p2, p3);
         if (intersection)
           break;
       }
     }
 
     // calculate area
     for (i = 0; i < polyLine.size(); ++i)
     {
       const Point2D p0 = polyLine[i];
       const Point2D p1 = polyLine[(i + 1) % polyLine.size()];
 
       area += p0[0] * p1[1] - p1[0] * p0[1];
     }
     area /= 2.0;
   }
 
   // set area if appropiate (i.e. closed and not intersected)
   if (this->IsClosed() && !intersection)
   {
     SetQuantity(FEATURE_ID_AREA, fabs(area));
     this->ActivateFeature(FEATURE_ID_AREA);
   }
   else
   {
     SetQuantity(FEATURE_ID_AREA, 0);
     this->DeactivateFeature(FEATURE_ID_AREA);
   }
 }
 
 void mitk::PlanarPolygon::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
 
   if (this->IsClosed())
     os << indent << "Polygon is closed\n";
   else
     os << indent << "Polygon is not closed\n";
 }
 
 // based on
-// http://flassari.is/2008/11/line-line-intersection-in-cplusplus/
+// https://flassari.is/2008/11/line-line-intersection-in-cplusplus/
 bool mitk::PlanarPolygon::CheckForLineIntersection(const mitk::Point2D &p1,
                                                    const mitk::Point2D &p2,
                                                    const mitk::Point2D &p3,
                                                    const mitk::Point2D &p4,
                                                    Point2D &intersection) const
 {
   // do not check for intersections with control points
   if (p1 == p2 || p1 == p3 || p1 == p4 || p2 == p3 || p2 == p4 || p3 == p4)
     return false;
 
   // Store the values for fast access and easy
   // equations-to-code conversion
   const double x1 = p1[0], x2 = p2[0], x3 = p3[0], x4 = p4[0];
   const double y1 = p1[1], y2 = p2[1], y3 = p3[1], y4 = p4[1];
 
   const double d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
   // If d is zero, there is no intersection
   // if (d < mitk::eps) return false;
   if (d == 0)
     return false;
 
   // Get the x and y
   const double pre = (x1 * y2 - y1 * x2);
   const double post = (x3 * y4 - y3 * x4);
   const double x = (pre * (x3 - x4) - (x1 - x2) * post) / d;
   const double y = (pre * (y3 - y4) - (y1 - y2) * post) / d;
 
   double tolerance = 0.001;
   // Check if the x coordinates are within both lines, including tolerance
   if (x < (std::min(x1, x2) - tolerance) || x > (std::max(x1, x2) + tolerance) || x < (std::min(x3, x4) - tolerance) ||
       x > (std::max(x3, x4) + tolerance))
   {
     return false;
   }
 
   // Check if the y coordinates are within both lines, including tolerance
   if (y < (std::min(y1, y2) - tolerance) || y > (std::max(y1, y2) + tolerance) || y < (std::min(y3, y4) - tolerance) ||
       y > (std::max(y3, y4) + tolerance))
   {
     return false;
   }
 
   // point of intersection
   Point2D ret;
   ret[0] = x;
   ret[1] = y;
   intersection = ret;
   return true;
 }
 
 bool mitk::PlanarPolygon::CheckForLineIntersection(const mitk::Point2D &p1,
                                                    const mitk::Point2D &p2,
                                                    const mitk::Point2D &p3,
                                                    const mitk::Point2D &p4) const
 {
   mitk::Point2D intersection;
   return mitk::PlanarPolygon::CheckForLineIntersection(p1, p2, p3, p4, intersection);
 }
 
 std::vector<mitk::Point2D> mitk::PlanarPolygon::CheckForLineIntersection(const mitk::Point2D &p1,
                                                                          const mitk::Point2D &p2) const
 {
   std::vector<mitk::Point2D> intersectionList;
 
   ControlPointListType polyLinePoints;
   const PolyLineType tempList = m_PolyLines[0];
   for (auto iter = tempList.cbegin(); iter != tempList.cend(); ++iter)
   {
     polyLinePoints.push_back(*iter);
   }
 
   for (ControlPointListType::size_type i = 0; i < polyLinePoints.size() - 1; i++)
   {
     const mitk::Point2D pnt1 = polyLinePoints[i];
     const mitk::Point2D pnt2 = polyLinePoints[i + 1];
     mitk::Point2D intersection;
 
     if (mitk::PlanarPolygon::CheckForLineIntersection(p1, p2, pnt1, pnt2, intersection))
     {
       intersectionList.push_back(intersection);
     }
   }
 
   if (this->IsClosed())
   {
     mitk::Point2D intersection;
     const mitk::Point2D lastControlPoint = polyLinePoints.back();
     const mitk::Point2D firstControlPoint = polyLinePoints.front();
 
     if (mitk::PlanarPolygon::CheckForLineIntersection(lastControlPoint, firstControlPoint, p1, p2, intersection))
     {
       intersectionList.push_back(intersection);
     }
   }
 
   return intersectionList;
 }
 
 bool mitk::PlanarPolygon::Equals(const mitk::PlanarFigure &other) const
 {
   const auto *otherPolygon = dynamic_cast<const mitk::PlanarPolygon *>(&other);
   if (otherPolygon)
   {
     return Superclass::Equals(other);
   }
   else
   {
     return false;
   }
 }
diff --git a/Modules/QtWidgetsExt/src/QmitkAboutDialogGUI.ui b/Modules/QtWidgetsExt/src/QmitkAboutDialogGUI.ui
index 0d101e0c9b..e0a3b8db25 100644
--- a/Modules/QtWidgetsExt/src/QmitkAboutDialogGUI.ui
+++ b/Modules/QtWidgetsExt/src/QmitkAboutDialogGUI.ui
@@ -1,175 +1,175 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkAboutDialog</class>
  <widget class="QDialog" name="QmitkAboutDialog">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>534</width>
     <height>421</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>About</string>
   </property>
   <property name="autoFillBackground">
    <bool>false</bool>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <widget class="QLabel" name="m_CaptionLabel">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="font">
           <font>
            <family>MS Sans Serif</family>
            <pointsize>48</pointsize>
            <weight>75</weight>
            <bold>true</bold>
           </font>
          </property>
          <property name="text">
           <string>MITK</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft</set>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="m_RevisionLabel">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string>Revision: hash
 Description:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="m_ToolkitVersionsLabel">
          <property name="text">
           <string>ITK x.x.x, VTK x.x.x, Qt x.x.x</string>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeType">
         <enum>QSizePolicy::Expanding</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <layout class="QVBoxLayout" name="verticalLayout_3">
        <item>
         <widget class="QLabel" name="m_LogoLabel">
          <property name="maximumSize">
           <size>
            <width>272</width>
            <height>54</height>
           </size>
          </property>
          <property name="text">
           <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a href=&quot;http://www.mitk.org&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;&lt;img src=&quot;:/QtWidgetsExt/defaultWatermarkSmall.png&quot; /&gt;&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
          <property name="scaledContents">
           <bool>true</bool>
          </property>
          <property name="openExternalLinks">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QScrollArea" name="scrollArea">
      <property name="widgetResizable">
       <bool>true</bool>
      </property>
      <widget class="QWidget" name="m_ScrollArea">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>514</width>
         <height>221</height>
        </rect>
       </property>
       <layout class="QGridLayout" name="gridLayout">
        <item row="0" column="0">
         <widget class="QLabel" name="m_AboutLabel">
          <property name="text">
-          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;The Medical Imaging Interaction Toolkit (MITK) [1] has been developed by the Division of Computer-Assisted Medical Interventions and the Division of Medical Image Computing of the German Cancer Research Center (DKFZ) [2,3].&lt;/span&gt;&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;[1] &lt;/span&gt;&lt;a href=&quot;http://www.mitk.org/&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;mitk.org&lt;br/&gt;&lt;/span&gt;&lt;/a&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;[2] &lt;/span&gt;&lt;a href=&quot;https://www.dkfz.de/en/cami/index.php&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;dkfz.de/en/cami&lt;br/&gt;&lt;/span&gt;&lt;/a&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;[3] &lt;/span&gt;&lt;a href=&quot;https://www.dkfz.de/en/mic/index.php&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;dkfz.de/en/mic&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;To contact the MITK team, see &lt;/span&gt;&lt;a href=&quot;http://www.mitk.org/wiki/Contact&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;mitk.org/wiki/contact&lt;/span&gt;&lt;/a&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;.&lt;/span&gt;&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-size:10pt; font-weight:600;&quot;&gt;Third Party Libraries&lt;br/&gt;&lt;/span&gt;&lt;a href=&quot;http://docs.mitk.org/nightly/thirdpartylibs.html&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;docs.mitk.org/nightly/thirdpartylibs.html&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;The Medical Imaging Interaction Toolkit (MITK) [1] has been developed by the Division of Computer-Assisted Medical Interventions and the Division of Medical Image Computing of the German Cancer Research Center (DKFZ) [2,3].&lt;/span&gt;&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;[1] &lt;/span&gt;&lt;a href=&quot;http://www.mitk.org/&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;mitk.org&lt;br/&gt;&lt;/span&gt;&lt;/a&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;[2] &lt;/span&gt;&lt;a href=&quot;https://www.dkfz.de/en/cami/index.php&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;dkfz.de/en/cami&lt;br/&gt;&lt;/span&gt;&lt;/a&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;[3] &lt;/span&gt;&lt;a href=&quot;https://www.dkfz.de/en/mic/index.php&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;dkfz.de/en/mic&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;To contact the MITK team, see &lt;/span&gt;&lt;a href=&quot;http://www.mitk.org/wiki/Contact&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;mitk.org/wiki/contact&lt;/span&gt;&lt;/a&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;.&lt;/span&gt;&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-size:10pt; font-weight:600;&quot;&gt;Third Party Libraries&lt;br/&gt;&lt;/span&gt;&lt;a href=&quot;https://docs.mitk.org/nightly/thirdpartylibs.html&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline; color:#5555ff;&quot;&gt;docs.mitk.org/nightly/thirdpartylibs.html&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
          <property name="openExternalLinks">
           <bool>true</bool>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item>
     <widget class="QDialogButtonBox" name="m_ButtonBox">
      <property name="standardButtons">
       <set>QDialogButtonBox::Close</set>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.h b/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.h
index d6f2757e67..e285c97cc3 100644
--- a/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.h
+++ b/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.h
@@ -1,281 +1,278 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 
 #ifndef __itkContourExtractor2DImageFilter_h
 #define __itkContourExtractor2DImageFilter_h
 
 #include "itkConceptChecking.h"
 #include "itkImageToPathFilter.h"
 #include "itkNumericTraits.h"
 #include "itkPolyLineParametricPath.h"
 #include <deque>
 #include <list>
 #include <unordered_map>
 
 namespace itk
 {
   /** \class ContourExtractor2DImageFilter
    * \brief Computes a list of PolyLineParametricPath objects from the contours in
    * a 2D image.
    *
    * Uses the "marching squares" method to compute a the iso-valued contours of
    * the input 2D image for a given intensity value. Multiple outputs may be
    * produced because an image can have multiple contours at a given level, so it
    * is advised to call GetNumberOfOutputs() and GetOutput(n) to retrieve all of
    * the contours. The contour value to be extracted can be set with
    * SetContourValue(). Image intensities will be linearly interpolated to provide
    * sub-pixel resolution for the output contours.
    *
    * The marching squares algorithm is a special case of the marching cubes
    * algorithm (Lorensen, William and Harvey E. Cline. Marching Cubes: A High
    * Resolution 3D Surface Construction Algorithm. Computer Graphics (SIGGRAPH 87
-   * Proceedings) 21(4) July 1987, p. 163-170). A simple explanation is available
-   * here: http://www.essi.fr/~lingrand/MarchingCubes/algo.html
+   * Proceedings) 21(4) July 1987, p. 163-170).
    *
    * There is a single ambiguous case in the marching squares algorithm: if a
    * given 2x2-pixel square has two high-valued and two low-valued pixels, each
    * pair diagonally adjacent. (Where high- and low-valued is with respect to the
    * contour value sought.) In this case, either the high-valued pixels can be
    * connected into the same "object" (where groups of pixels encircled by a given
    * contour are considered an object), or the low-valued pixels can be connected.
    * This is the "face connected" versus "face + vertex connected" (or 4- versus
    * 4-connected) distinction: high-valued pixels most be treated as one, and
    * low-valued as the other. By default, high-valued pixels are treated as
    * "face-connected" and low-valued pixels are treated as "face + vertex"
    * connected. To reverse this, call VertexConnectHighPixelsOn();
    *
    * Outputs are not guaranteed to be closed paths: contours which intersect the
    * image edge will be left open. All other paths will be closed. (The
    * closed-ness of a path can be tested by checking whether the beginning point
    * is the same as the end point.)
    *
    * Produced paths are oriented. Following the path from beginning to end, image
    * intensity values lower than the contour value are to the left of the path and
    * intensity values grater than the contour value are to the right. In other
    * words, the image gradient at a path segment is (approximately) in the direct
    * of that segment rotated right by 90 degrees, because the image intensity
    * values increase from left-to-right across the segment. This means that the
    * generated contours will circle clockwise around "hills" of
    * above-contour-value intensity, and counter-clockwise around "depressions" of
    * below-contour-value intensity. This convention can be reversed by calling
    * ReverseContourOrientationOn().
    *
    * By default the input image's largest possible region will be processed; call
    * SetRequestedRegion() to process a different region, or ClearRequestedRegion()
    * to revert to the default value. Note that the requested regions are usually
    * set on the output; however since paths have no notion of a "region", this
    * must be set at the filter level.
    *
    * This class was contributed to the Insight Journal by Zachary Pincus.
-   *       http://insight-journal.org/midas/handle.php?handle=1926/165
    *
    * \sa Image
    * \sa Path
    * \sa PolyLineParametricPath
    *
    */
   template <class TInputImage>
   class ITK_EXPORT ContourExtractor2DImageFilter : public ImageToPathFilter<TInputImage, PolyLineParametricPath<2>>
   {
   public:
     /** Extract dimension from input and output image. */
     itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension);
 
     /** Convenient typedefs for simplifying declarations. */
     typedef TInputImage InputImageType;
     typedef PolyLineParametricPath<2> OutputPathType;
 
     /** Standard class typedefs. */
     typedef ContourExtractor2DImageFilter Self;
     typedef ImageToPathFilter<InputImageType, OutputPathType> Superclass;
     typedef SmartPointer<Self> Pointer;
     typedef SmartPointer<const Self> ConstPointer;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       /** Run-time type information (and related methods). */
       itkTypeMacro(ContourExtractor2DImageFilter, ImageToPathFilter);
 
     /** Image and path typedef support. */
     typedef typename InputImageType::Pointer InputImagePointer;
     typedef typename InputImageType::PixelType InputPixelType;
     typedef typename InputImageType::IndexType InputIndexType;
     typedef typename InputImageType::OffsetType InputOffsetType;
     typedef typename InputImageType::RegionType InputRegionType;
     typedef typename OutputPathType::Pointer OutputPathPointer;
     typedef typename OutputPathType::VertexType VertexType;
     typedef typename OutputPathType::VertexListType VertexListType;
 
     /** Real type associated to the input pixel type. */
     typedef typename NumericTraits<InputPixelType>::RealType InputRealType;
 
     typedef typename VertexListType::ConstPointer VertexListConstPointer;
     /** Control the orientation of the contours with reference to the image
    * gradient. (See class documentation.) */
     itkSetMacro(ReverseContourOrientation, bool);
     itkGetConstReferenceMacro(ReverseContourOrientation, bool);
     itkBooleanMacro(ReverseContourOrientation);
 
     /** Control whether high- or low-valued pixels are vertex-connected.
       * Default is for low-valued pixels to be vertex-connected.
       * (See class documentation.) */
     itkSetMacro(VertexConnectHighPixels, bool);
     itkGetConstReferenceMacro(VertexConnectHighPixels, bool);
     itkBooleanMacro(VertexConnectHighPixels);
 
     /** Control whether the largest possible input region is used, or if a
       * custom requested region is to be used. */
     void SetRequestedRegion(const InputRegionType region);
     itkGetConstReferenceMacro(RequestedRegion, InputRegionType);
     void ClearRequestedRegion();
 
     /** Set/Get the image intensity value that the contours should follow.
      *  This is the equivalent of an iso-value in Marching Squares. */
     itkSetMacro(ContourValue, InputRealType);
     itkGetConstReferenceMacro(ContourValue, InputRealType);
 
 #ifdef ITK_USE_CONCEPT_CHECKING
     /** Begin concept checking */
     itkConceptMacro(DimensionShouldBe2, (Concept::SameDimension<itkGetStaticConstMacro(InputImageDimension), 2>));
     itkConceptMacro(InputPixelTypeComparable, (Concept::Comparable<InputPixelType>));
     itkConceptMacro(InputHasPixelTraitsCheck, (Concept::HasPixelTraits<InputPixelType>));
     itkConceptMacro(InputHasNumericTraitsCheck, (Concept::HasNumericTraits<InputPixelType>));
 /** End concept checking */
 #endif
 
   protected:
     ContourExtractor2DImageFilter();
     ~ContourExtractor2DImageFilter() override;
     void PrintSelf(std::ostream &os, Indent indent) const override;
 
     void GenerateData() override;
 
     /** ContourExtractor2DImageFilter manually controls the input requested
       * region via SetRequestedRegion and ClearRequestedRegion, so it must
       * override the superclass method. */
     void GenerateInputRequestedRegion() override;
 
   private:
     VertexType InterpolateContourPosition(InputPixelType fromValue,
                                           InputPixelType toValue,
                                           InputIndexType fromIndex,
                                           InputOffsetType toOffset);
     void AddSegment(const VertexType from, const VertexType to);
     void FillOutputs();
     ContourExtractor2DImageFilter(const Self &); // purposely not implemented
     void operator=(const Self &);                // purposely not implemented
 
     InputRealType m_ContourValue;
     bool m_ReverseContourOrientation;
     bool m_VertexConnectHighPixels;
     bool m_UseCustomRegion;
     InputRegionType m_RequestedRegion;
     unsigned int m_NumberOfContoursCreated;
 
     // Represent each contour as deque of vertices to facilitate addition of
     // nodes at beginning or end. At the end of the processing, we will copy
     // the contour into a PolyLineParametricPath.
     // We subclass the deque to store an additional bit of information: an
     // identification number for each growing contour. We use this number so
     // that when it becomes necessary to merge two growing contours, we can
     // merge the newer one into the older one. This helps because then we can
     // guarantee that the output contour list is ordered from left to right,
     // top to bottom (in terms of the first pixel of the contour encountered
     // by the marching squares). Currently we make no guarantees that this
     // pixel is the first pixel in the contour list, just that the contours
     // are so ordered in the output. Ensuring this latter condition (first
     // pixel traversed = first pixel in contour) would be possible by either
     // changing the merging rules, which would make the contouring operation
     // slower, or by storing additional data as to which pixel was first.
     class ContourType : public std::deque<VertexType>
     {
     public:
       unsigned int m_ContourNumber;
     };
 
     // Store all the growing contours in a list. We may need to delete contours
     // from anywhere in the sequence (when we merge them together), so we need to
     // use a list instead of a vector or similar.
     typedef std::list<ContourType> ContourContainer;
     typedef typename ContourContainer::iterator ContourRef;
 
     // declare the hash function we are using for the hash_map.
     struct VertexHash
     {
       typedef typename VertexType::CoordRepType CoordinateType;
       inline size_t operator()(const VertexType &k) const
       {
         // Xor the hashes of the vertices together, after multiplying the
         // first by some number, so that identical (x,y) vertex indices
         // don't all hash to the same bucket. This is a decent if not
         // optimal hash.
         const size_t hashVertex1 = this->float_hash(k[0] * 0xbeef);
         const size_t hashVertex2 = this->float_hash(k[1]);
         const size_t hashValue = hashVertex1 ^ hashVertex2;
         return hashValue;
       }
 
-      // Define hash function for floats. Based on method from
-      // http://www.brpreiss.com/books/opus4/html/page217.html
+      // Define hash function for floats.
       inline size_t float_hash(const CoordinateType &k) const
       {
         if (k == 0)
         {
           return 0;
         }
         int exponent;
         CoordinateType mantissa = std::frexp(k, &exponent);
         size_t value = static_cast<size_t>(std::fabs(mantissa));
         value = (2 * value - 1) * ~0U;
         return value;
       }
     };
 
     // We use a hash to associate the endpoints of each contour with the
     // contour itself. This makes it easy to look up which contour we should add
     // a new arc to.
     // We can't store the contours themselves in the hashtable because we
     // need to have two tables (one to hash from beginpoint -> contour and one
     // for endpoint -> contour), and sometimes will remove a contour from the
     // tables (if it has been closed or merged with another contour). So in the
     // hash table we store a reference to the contour. Because sometimes we will
     // need to merge contours, we need to be able to quickly remove contours
     // from our list when they have been merged into another. Thus, we store
     // an iterator pointing to the contour in the list.
 
     typedef std::unordered_map<VertexType, ContourRef, VertexHash> VertexToContourMap;
     typedef typename VertexToContourMap::iterator VertexMapIterator;
     typedef typename VertexToContourMap::value_type VertexContourRefPair;
 
     // The contours we find in the image are stored here
     ContourContainer m_Contours;
 
     // And indexed by their beginning and ending points here
     VertexToContourMap m_ContourStarts;
     VertexToContourMap m_ContourEnds;
   };
 
 } // end namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkContourExtractor2DImageFilter.txx"
 #endif
 
 #endif
diff --git a/Modules/Segmentation/Algorithms/mitkVtkImageOverwrite.cpp b/Modules/Segmentation/Algorithms/mitkVtkImageOverwrite.cpp
index b014ba9ee6..86a132b724 100644
--- a/Modules/Segmentation/Algorithms/mitkVtkImageOverwrite.cpp
+++ b/Modules/Segmentation/Algorithms/mitkVtkImageOverwrite.cpp
@@ -1,883 +1,883 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*=========================================================================
 
   Program:   Visualization Toolkit
   Module:    mitkVtkImageOverwrite.cpp
 
   Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
   All rights reserved.
-  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+  See Copyright.txt or https://vtk.org/about/#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 notice for more information.
 
 =========================================================================*/
 #include "mitkVtkImageOverwrite.h"
 
 #include "vtkDataSetAttributes.h"
 #include "vtkGarbageCollector.h"
 #include "vtkImageData.h"
 #include "vtkImageStencilData.h"
 #include "vtkInformation.h"
 #include "vtkInformationVector.h"
 #include "vtkMath.h"
 #include "vtkObjectFactory.h"
 #include "vtkStreamingDemandDrivenPipeline.h"
 #include "vtkTransform.h"
 
 #include "vtkTemplateAliasMacro.h"
 // turn off 64-bit ints when templating over all types
 #undef VTK_USE_INT64
 #define VTK_USE_INT64 0
 #undef VTK_USE_UINT64
 #define VTK_USE_UINT64 0
 
 #include <cfloat>
 #include <climits>
 #include <cmath>
 
 vtkStandardNewMacro(mitkVtkImageOverwrite);
 
 //--------------------------------------------------------------------------
 // The 'floor' function on x86 and mips is many times slower than these
 // and is used a lot in this code, optimize for different CPU architectures
 template <class F>
 inline int vtkResliceFloor(double x, F &f)
 {
 #if defined mips || defined sparc || defined __ppc__
   x += 2147483648.0;
   unsigned int i = static_cast<unsigned int>(x);
   f = x - i;
   return static_cast<int>(i - 2147483648U);
 #elif defined i386 || defined _M_IX86
   union {
     double d;
     unsigned short s[4];
     unsigned int i[2];
   } dual;
   dual.d = x + 103079215104.0;        // (2**(52-16))*1.5
   f = dual.s[0] * 0.0000152587890625; // 2**(-16)
   return static_cast<int>((dual.i[1] << 16) | ((dual.i[0]) >> 16));
 #elif defined ia64 || defined __ia64__ || defined IA64
   x += 103079215104.0;
   long long i = static_cast<long long>(x);
   f = x - i;
   return static_cast<int>(i - 103079215104LL);
 #else
   double y = floor(x);
   f = x - y;
   return static_cast<int>(y);
 #endif
 }
 
 inline int vtkResliceRound(double x)
 {
 #if defined mips || defined sparc || defined __ppc__
   return static_cast<int>(static_cast<unsigned int>(x + 2147483648.5) - 2147483648U);
 #elif defined i386 || defined _M_IX86
   union {
     double d;
     unsigned int i[2];
   } dual;
   dual.d = x + 103079215104.5; // (2**(52-16))*1.5
   return static_cast<int>((dual.i[1] << 16) | ((dual.i[0]) >> 16));
 #elif defined ia64 || defined __ia64__ || defined IA64
   x += 103079215104.5;
   long long i = static_cast<long long>(x);
   return static_cast<int>(i - 103079215104LL);
 #else
   return static_cast<int>(floor(x + 0.5));
 #endif
 }
 
 //----------------------------------------------------------------------------
 mitkVtkImageOverwrite::mitkVtkImageOverwrite()
 {
   m_Overwrite_Mode = false;
   this->GetOutput()->AllocateScalars(VTK_UNSIGNED_INT, 1); // VTK6_TODO where should the image be allocated?
 }
 
 //----------------------------------------------------------------------------
 mitkVtkImageOverwrite::~mitkVtkImageOverwrite()
 {
 }
 
 //----------------------------------------------------------------------------
 // constants for different boundary-handling modes
 
 #define VTK_RESLICE_BACKGROUND 0 // use background if out-of-bounds
 #define VTK_RESLICE_WRAP 1       // wrap to opposite side of image
 #define VTK_RESLICE_MIRROR 2     // mirror off of the boundary
 #define VTK_RESLICE_BORDER 3     // use a half-voxel border
 #define VTK_RESLICE_nullptr 4       // do nothing to *outPtr if out-of-bounds
 
 //----------------------------------------------------------------------------
 // rounding functions for each type, where 'F' is a floating-point type
 
 #if (VTK_USE_INT8 != 0)
 template <class F>
 inline void vtkResliceRound(F val, vtkTypeInt8 &rnd)
 {
   rnd = vtkResliceRound(val);
 }
 #endif
 
 #if (VTK_USE_UINT8 != 0)
 template <class F>
 inline void vtkResliceRound(F val, vtkTypeUInt8 &rnd)
 {
   rnd = vtkResliceRound(val);
 }
 #endif
 
 #if (VTK_USE_INT16 != 0)
 template <class F>
 inline void vtkResliceRound(F val, vtkTypeInt16 &rnd)
 {
   rnd = vtkResliceRound(val);
 }
 #endif
 
 #if (VTK_USE_UINT16 != 0)
 template <class F>
 inline void vtkResliceRound(F val, vtkTypeUInt16 &rnd)
 {
   rnd = vtkResliceRound(val);
 }
 #endif
 
 #if (VTK_USE_INT32 != 0)
 template <class F>
 inline void vtkResliceRound(F val, vtkTypeInt32 &rnd)
 {
   rnd = vtkResliceRound(val);
 }
 #endif
 
 #if (VTK_USE_UINT32 != 0)
 template <class F>
 inline void vtkResliceRound(F val, vtkTypeUInt32 &rnd)
 {
   rnd = vtkResliceRound(val);
 }
 #endif
 
 #if (VTK_USE_FLOAT32 != 0)
 template <class F>
 inline void vtkResliceRound(F val, vtkTypeFloat32 &rnd)
 {
   rnd = val;
 }
 #endif
 
 #if (VTK_USE_FLOAT64 != 0)
 template <class F>
 inline void vtkResliceRound(F val, vtkTypeFloat64 &rnd)
 {
   rnd = val;
 }
 #endif
 
 //----------------------------------------------------------------------------
 // clamping functions for each type
 
 #if (VTK_USE_INT8 != 0)
 template <class F>
 inline void vtkResliceClamp(F val, vtkTypeInt8 &clamp)
 {
   if (val < -128.0)
   {
     val = -128.0;
   }
   if (val > 127.0)
   {
     val = 127.0;
   }
   vtkResliceRound(val, clamp);
 }
 #endif
 
 #if (VTK_USE_UINT8 != 0)
 template <class F>
 inline void vtkResliceClamp(F val, vtkTypeUInt8 &clamp)
 {
   if (val < 0)
   {
     val = 0;
   }
   if (val > 255.0)
   {
     val = 255.0;
   }
   vtkResliceRound(val, clamp);
 }
 #endif
 
 #if (VTK_USE_INT16 != 0)
 template <class F>
 inline void vtkResliceClamp(F val, vtkTypeInt16 &clamp)
 {
   if (val < -32768.0)
   {
     val = -32768.0;
   }
   if (val > 32767.0)
   {
     val = 32767.0;
   }
   vtkResliceRound(val, clamp);
 }
 #endif
 
 #if (VTK_USE_UINT16 != 0)
 template <class F>
 inline void vtkResliceClamp(F val, vtkTypeUInt16 &clamp)
 {
   if (val < 0)
   {
     val = 0;
   }
   if (val > 65535.0)
   {
     val = 65535.0;
   }
   vtkResliceRound(val, clamp);
 }
 #endif
 
 #if (VTK_USE_INT32 != 0)
 template <class F>
 inline void vtkResliceClamp(F val, vtkTypeInt32 &clamp)
 {
   if (val < -2147483648.0)
   {
     val = -2147483648.0;
   }
   if (val > 2147483647.0)
   {
     val = 2147483647.0;
   }
   vtkResliceRound(val, clamp);
 }
 #endif
 
 #if (VTK_USE_UINT32 != 0)
 template <class F>
 inline void vtkResliceClamp(F val, vtkTypeUInt32 &clamp)
 {
   if (val < 0)
   {
     val = 0;
   }
   if (val > 4294967295.0)
   {
     val = 4294967295.0;
   }
   vtkResliceRound(val, clamp);
 }
 #endif
 
 #if (VTK_USE_FLOAT32 != 0)
 template <class F>
 inline void vtkResliceClamp(F val, vtkTypeFloat32 &clamp)
 {
   clamp = val;
 }
 #endif
 
 #if (VTK_USE_FLOAT64 != 0)
 template <class F>
 inline void vtkResliceClamp(F val, vtkTypeFloat64 &clamp)
 {
   clamp = val;
 }
 #endif
 
 //----------------------------------------------------------------------------
 // Perform a wrap to limit an index to [0,range).
 // Ensures correct behaviour when the index is negative.
 
 inline int vtkInterpolateWrap(int num, int range)
 {
   if ((num %= range) < 0)
   {
     num += range; // required for some % implementations
   }
   return num;
 }
 
 //----------------------------------------------------------------------------
 // Perform a mirror to limit an index to [0,range).
 
 inline int vtkInterpolateMirror(int num, int range)
 {
   if (num < 0)
   {
     num = -num - 1;
   }
   int count = num / range;
   num %= range;
   if (count & 0x1)
   {
     num = range - num - 1;
   }
   return num;
 }
 
 //----------------------------------------------------------------------------
 // If the value is within one half voxel of the range [0,inExtX), then
 // set it to "0" or "inExtX-1" as appropriate.
 
 inline int vtkInterpolateBorder(int &inIdX0, int &inIdX1, int inExtX, double fx)
 {
   if (inIdX0 >= 0 && inIdX1 < inExtX)
   {
     return 0;
   }
   if (inIdX0 == -1 && fx >= 0.5)
   {
     inIdX1 = inIdX0 = 0;
     return 0;
   }
   if (inIdX0 == inExtX - 1 && fx < 0.5)
   {
     inIdX1 = inIdX0;
     return 0;
   }
 
   return 1;
 }
 
 inline int vtkInterpolateBorderCheck(int inIdX0, int inIdX1, int inExtX, double fx)
 {
   if ((inIdX0 >= 0 && inIdX1 < inExtX) || (inIdX0 == -1 && fx >= 0.5) || (inIdX0 == inExtX - 1 && fx < 0.5))
   {
     return 0;
   }
 
   return 1;
 }
 
 //----------------------------------------------------------------------------
 // Do nearest-neighbor interpolation of the input data 'inPtr' of extent
 // 'inExt' at the 'point'.  The result is placed at 'outPtr'.
 // If the lookup data is beyond the extent 'inExt', set 'outPtr' to
 // the background color 'background'.
 // The number of scalar components in the data is 'numscalars'
 template <class F, class T>
 static int vtkNearestNeighborInterpolation(T *&outPtr,
                                            const T *inPtr,
                                            const int inExt[6],
                                            const vtkIdType inInc[3],
                                            int numscalars,
                                            const F point[3],
                                            int mode,
                                            const T *background,
                                            mitkVtkImageOverwrite *self)
 {
   int inIdX0 = vtkResliceRound(point[0]) - inExt[0];
   int inIdY0 = vtkResliceRound(point[1]) - inExt[2];
   int inIdZ0 = vtkResliceRound(point[2]) - inExt[4];
 
   int inExtX = inExt[1] - inExt[0] + 1;
   int inExtY = inExt[3] - inExt[2] + 1;
   int inExtZ = inExt[5] - inExt[4] + 1;
 
   if (inIdX0 < 0 || inIdX0 >= inExtX || inIdY0 < 0 || inIdY0 >= inExtY || inIdZ0 < 0 || inIdZ0 >= inExtZ)
   {
     if (mode == VTK_RESLICE_WRAP)
     {
       inIdX0 = vtkInterpolateWrap(inIdX0, inExtX);
       inIdY0 = vtkInterpolateWrap(inIdY0, inExtY);
       inIdZ0 = vtkInterpolateWrap(inIdZ0, inExtZ);
     }
     else if (mode == VTK_RESLICE_MIRROR)
     {
       inIdX0 = vtkInterpolateMirror(inIdX0, inExtX);
       inIdY0 = vtkInterpolateMirror(inIdY0, inExtY);
       inIdZ0 = vtkInterpolateMirror(inIdZ0, inExtZ);
     }
     else if (mode == VTK_RESLICE_BACKGROUND || mode == VTK_RESLICE_BORDER)
     {
       do
       {
         *outPtr++ = *background++;
       } while (--numscalars);
       return 0;
     }
     else
     {
       return 0;
     }
   }
 
   inPtr += inIdX0 * inInc[0] + inIdY0 * inInc[1] + inIdZ0 * inInc[2];
 
   do
   {
     if (!self->IsOverwriteMode())
     {
       // just copy from input to output
       *outPtr++ = *inPtr++;
     }
     else
     {
       // copy from output to input in overwrite mode
       *(const_cast<T *>(inPtr)) = *outPtr++;
       inPtr++;
     }
   } while (--numscalars);
 
   return 1;
 }
 
 //--------------------------------------------------------------------------
 // get appropriate interpolation function according to scalar type
 template <class F>
 static void vtkGetResliceInterpFunc(mitkVtkImageOverwrite *self,
                                     int (**interpolate)(void *&outPtr,
                                                         const void *inPtr,
                                                         const int inExt[6],
                                                         const vtkIdType inInc[3],
                                                         int numscalars,
                                                         const F point[3],
                                                         int mode,
                                                         const void *background,
                                                         mitkVtkImageOverwrite *self))
 {
   int dataType = self->GetOutput()->GetScalarType();
 
   switch (dataType)
   {
     vtkTemplateAliasMacro(*((int (**)(VTK_TT * &outPtr,
                                       const VTK_TT *inPtr,
                                       const int inExt[6],
                                       const vtkIdType inInc[3],
                                       int numscalars,
                                       const F point[3],
                                       int mode,
                                       const VTK_TT *background,
                                       mitkVtkImageOverwrite *self))interpolate) = &vtkNearestNeighborInterpolation);
     default:
       interpolate = nullptr;
   }
 }
 
 //----------------------------------------------------------------------------
 // Some helper functions for 'RequestData'
 //----------------------------------------------------------------------------
 
 //--------------------------------------------------------------------------
 // pixel copy function, templated for different scalar types
 template <class T>
 struct vtkImageResliceSetPixels
 {
   static void Set(void *&outPtrV, const void *inPtrV, int numscalars, int n)
   {
     const T *inPtr = static_cast<const T *>(inPtrV);
     T *outPtr = static_cast<T *>(outPtrV);
     for (int i = 0; i < n; i++)
     {
       const T *tmpPtr = inPtr;
       int m = numscalars;
       do
       {
         *outPtr++ = *tmpPtr++;
       } while (--m);
     }
     outPtrV = outPtr;
   }
 
   // optimized for 1 scalar components
   static void Set1(void *&outPtrV, const void *inPtrV, int vtkNotUsed(numscalars), int n)
   {
     const T *inPtr = static_cast<const T *>(inPtrV);
     T *outPtr = static_cast<T *>(outPtrV);
     T val = *inPtr;
     for (int i = 0; i < n; i++)
     {
       *outPtr++ = val;
     }
     outPtrV = outPtr;
   }
 };
 
 // get a pixel copy function that is appropriate for the data type
 static void vtkGetSetPixelsFunc(mitkVtkImageOverwrite *self,
                                 void (**setpixels)(void *&out, const void *in, int numscalars, int n))
 {
   int dataType = self->GetOutput()->GetScalarType();
   int numscalars = self->GetOutput()->GetNumberOfScalarComponents();
 
   // TODO: this switch should be examined
   switch (numscalars)
   {
     case 1:
       switch (dataType)
       {
         vtkTemplateAliasMacro(*setpixels = &vtkImageResliceSetPixels<VTK_TT>::Set1);
         default:
           setpixels = nullptr;
       }
       // just to make the compiler happy, TODO: check!
       // FALLTHRU
     default:
       switch (dataType)
       {
         vtkTemplateAliasMacro(*setpixels = &vtkImageResliceSetPixels<VTK_TT>::Set);
         default:
           setpixels = nullptr;
       }
   }
 }
 
 //----------------------------------------------------------------------------
 // Convert background color from float to appropriate type
 template <class T>
 static void vtkAllocBackgroundPixelT(mitkVtkImageOverwrite *self, T **background_ptr, int numComponents)
 {
   *background_ptr = new T[numComponents];
   T *background = *background_ptr;
 
   for (int i = 0; i < numComponents; i++)
   {
     if (i < 4)
     {
       vtkResliceClamp(self->GetBackgroundColor()[i], background[i]);
     }
     else
     {
       background[i] = 0;
     }
   }
 }
 
 static void vtkAllocBackgroundPixel(mitkVtkImageOverwrite *self, void **rval, int numComponents)
 {
   switch (self->GetOutput()->GetScalarType())
   {
     vtkTemplateAliasMacro(vtkAllocBackgroundPixelT(self, (VTK_TT **)rval, numComponents));
   }
 }
 
 static void vtkFreeBackgroundPixel(mitkVtkImageOverwrite *self, void **rval)
 {
   switch (self->GetOutput()->GetScalarType())
   {
     vtkTemplateAliasMacro(delete[] * ((VTK_TT **)rval));
   }
 
   *rval = nullptr;
 }
 
 //----------------------------------------------------------------------------
 // helper function for clipping of the output with a stencil
 static int vtkResliceGetNextExtent(vtkImageStencilData *stencil,
                                    int &r1,
                                    int &r2,
                                    int rmin,
                                    int rmax,
                                    int yIdx,
                                    int zIdx,
                                    void *&outPtr,
                                    void *background,
                                    int numscalars,
                                    void (*setpixels)(void *&out, const void *in, int numscalars, int n),
                                    int &iter)
 {
   // trivial case if stencil is not set
   if (!stencil)
   {
     if (iter++ == 0)
     {
       r1 = rmin;
       r2 = rmax;
       return 1;
     }
     return 0;
   }
 
   // for clearing, start at last r2 plus 1
   int clear1 = r2 + 1;
   if (iter == 0)
   { // if no 'last time', start at rmin
     clear1 = rmin;
   }
 
   int rval = stencil->GetNextExtent(r1, r2, rmin, rmax, yIdx, zIdx, iter);
   int clear2 = r1 - 1;
   if (rval == 0)
   {
     clear2 = rmax;
   }
 
   setpixels(outPtr, background, numscalars, clear2 - clear1 + 1);
 
   return rval;
 }
 
 //----------------------------------------------------------------------------
 // This function simply clears the entire output to the background color,
 // for cases where the transformation places the output extent completely
 // outside of the input extent.
 static void vtkImageResliceClearExecute(
   mitkVtkImageOverwrite *self, vtkImageData *, void *, vtkImageData *outData, void *outPtr, int outExt[6], int id)
 {
   int numscalars;
   int idY, idZ;
   vtkIdType outIncX, outIncY, outIncZ;
   int scalarSize;
   unsigned long count = 0;
   unsigned long target;
   void *background;
   void (*setpixels)(void *&out, const void *in, int numscalars, int n);
 
   // for the progress meter
   target = static_cast<unsigned long>((outExt[5] - outExt[4] + 1) * (outExt[3] - outExt[2] + 1) / 50.0);
   target++;
 
   // Get Increments to march through data
   outData->GetContinuousIncrements(outExt, outIncX, outIncY, outIncZ);
   scalarSize = outData->GetScalarSize();
   numscalars = outData->GetNumberOfScalarComponents();
 
   // allocate a voxel to copy into the background (out-of-bounds) regions
   vtkAllocBackgroundPixel(self, &background, numscalars);
   // get the appropriate function for pixel copying
   vtkGetSetPixelsFunc(self, &setpixels);
 
   // Loop through output voxels
   for (idZ = outExt[4]; idZ <= outExt[5]; idZ++)
   {
     for (idY = outExt[2]; idY <= outExt[3]; idY++)
     {
       if (id == 0)
       { // update the progress if this is the main thread
         if (!(count % target))
         {
           self->UpdateProgress(count / (50.0 * target));
         }
         count++;
       }
       // clear the pixels to background color and go to next row
       setpixels(outPtr, background, numscalars, outExt[1] - outExt[0] + 1);
       outPtr = static_cast<void *>(static_cast<char *>(outPtr) + outIncY * scalarSize);
     }
     outPtr = static_cast<void *>(static_cast<char *>(outPtr) + outIncZ * scalarSize);
   }
 
   vtkFreeBackgroundPixel(self, &background);
 }
 
 //----------------------------------------------------------------------------
 // This function executes the filter for any type of data.  It is much simpler
 // in structure than vtkImageResliceOptimizedExecute.
 static void vtkImageResliceExecute(mitkVtkImageOverwrite *self,
                                    vtkImageData *inData,
                                    void *inPtr,
                                    vtkImageData *outData,
                                    void *outPtr,
                                    int outExt[6],
                                    int id)
 {
   int numscalars;
   int idX, idY, idZ;
   int idXmin, idXmax, iter;
   vtkIdType outIncX, outIncY, outIncZ;
   int scalarSize;
   int inExt[6];
   vtkIdType inInc[3];
   unsigned long count = 0;
   unsigned long target;
   double point[4];
   double f;
   double *inSpacing, *inOrigin, *outSpacing, *outOrigin, inInvSpacing[3];
   void *background;
   int (*interpolate)(void *&outPtr,
                      const void *inPtr,
                      const int inExt[6],
                      const vtkIdType inInc[3],
                      int numscalars,
                      const double point[3],
                      int mode,
                      const void *background,
                      mitkVtkImageOverwrite *self) = nullptr;
   void (*setpixels)(void *&out, const void *in, int numscalars, int n) = nullptr;
 
   // the 'mode' species what to do with the 'pad' (out-of-bounds) area
   int mode = VTK_RESLICE_BACKGROUND;
   if (self->GetMirror())
   {
     mode = VTK_RESLICE_MIRROR;
   }
   else if (self->GetWrap())
   {
     mode = VTK_RESLICE_WRAP;
   }
   else if (self->GetBorder())
   {
     mode = VTK_RESLICE_BORDER;
   }
 
   // the transformation to apply to the data
   vtkAbstractTransform *transform = self->GetResliceTransform();
   vtkMatrix4x4 *matrix = self->GetResliceAxes();
 
   // for conversion to data coordinates
   inOrigin = inData->GetOrigin();
   inSpacing = inData->GetSpacing();
   outOrigin = outData->GetOrigin();
   outSpacing = outData->GetSpacing();
 
   // save effor later: invert inSpacing
   inInvSpacing[0] = 1.0 / inSpacing[0];
   inInvSpacing[1] = 1.0 / inSpacing[1];
   inInvSpacing[2] = 1.0 / inSpacing[2];
 
   // find maximum input range
   inData->GetExtent(inExt);
 
   // for the progress meter
   target = static_cast<unsigned long>((outExt[5] - outExt[4] + 1) * (outExt[3] - outExt[2] + 1) / 50.0);
   target++;
 
   // Get Increments to march through data
   inData->GetIncrements(inInc);
   outData->GetContinuousIncrements(outExt, outIncX, outIncY, outIncZ);
   scalarSize = outData->GetScalarSize();
   numscalars = inData->GetNumberOfScalarComponents();
 
   // allocate a voxel to copy into the background (out-of-bounds) regions
   vtkAllocBackgroundPixel(self, &background, numscalars);
 
   // get the appropriate functions for interpolation and pixel copying
   vtkGetResliceInterpFunc(self, &interpolate);
   vtkGetSetPixelsFunc(self, &setpixels);
 
   // get the stencil
   vtkImageStencilData *stencil = self->GetStencil();
 
   // Loop through output voxels
   for (idZ = outExt[4]; idZ <= outExt[5]; idZ++)
   {
     for (idY = outExt[2]; idY <= outExt[3]; idY++)
     {
       if (id == 0)
       { // update the progress if this is the main thread
         if (!(count % target))
         {
           self->UpdateProgress(count / (50.0 * target));
         }
         count++;
       }
 
       iter = 0; // if there is a stencil, it is applied here
       while (vtkResliceGetNextExtent(
         stencil, idXmin, idXmax, outExt[0], outExt[1], idY, idZ, outPtr, background, numscalars, setpixels, iter))
       {
         for (idX = idXmin; idX <= idXmax; idX++)
         {
           // convert to data coordinates
           point[0] = idX * outSpacing[0] + outOrigin[0];
           point[1] = idY * outSpacing[1] + outOrigin[1];
           point[2] = idZ * outSpacing[2] + outOrigin[2];
 
           // apply ResliceAxes matrix
           if (matrix)
           {
             point[3] = 1.0;
             matrix->MultiplyPoint(point, point);
             f = 1.0 / point[3];
             point[0] *= f;
             point[1] *= f;
             point[2] *= f;
           }
 
           // apply ResliceTransform
           if (transform)
           {
             transform->InternalTransformPoint(point, point);
           }
 
           // convert back to voxel indices
           point[0] = (point[0] - inOrigin[0]) * inInvSpacing[0];
           point[1] = (point[1] - inOrigin[1]) * inInvSpacing[1];
           point[2] = (point[2] - inOrigin[2]) * inInvSpacing[2];
 
           // interpolate output voxel from input data set
           interpolate(outPtr, inPtr, inExt, inInc, numscalars, point, mode, background, self);
         }
       }
       outPtr = static_cast<void *>(static_cast<char *>(outPtr) + outIncY * scalarSize);
     }
     outPtr = static_cast<void *>(static_cast<char *>(outPtr) + outIncZ * scalarSize);
   }
 
   vtkFreeBackgroundPixel(self, &background);
 }
 
 void mitkVtkImageOverwrite::SetOverwriteMode(bool b)
 {
   m_Overwrite_Mode = b;
 }
 
 void mitkVtkImageOverwrite::SetInputSlice(vtkImageData *slice)
 {
   // set the output as input
   this->SetOutput(slice);
 }
 
 //----------------------------------------------------------------------------
 // This method is passed a input and output region, and executes the filter
 // algorithm to fill the output from the input or vice versa.
 void mitkVtkImageOverwrite::ThreadedRequestData(vtkInformation *vtkNotUsed(request),
                                                 vtkInformationVector **vtkNotUsed(inputVector),
                                                 vtkInformationVector *vtkNotUsed(outputVector),
                                                 vtkImageData ***inData,
                                                 vtkImageData **outData,
                                                 int outExt[6],
                                                 int id)
 {
   vtkDebugMacro(<< "Execute: inData = " << inData[0][0] << ", outData = " << outData[0]);
   // this filter expects that input is the same type as output.
   if (inData[0][0]->GetScalarType() != outData[0]->GetScalarType())
   {
     vtkErrorMacro(<< "Execute: input ScalarType, " << inData[0][0]->GetScalarType() << ", must match out ScalarType "
                   << outData[0]->GetScalarType());
     return;
   }
 
   int inExt[6];
   inData[0][0]->GetExtent(inExt);
   // check for empty input extent
   if (inExt[1] < inExt[0] || inExt[3] < inExt[2] || inExt[5] < inExt[4])
   {
     return;
   }
 
   // Get the output pointer
   void *outPtr = outData[0]->GetScalarPointerForExtent(outExt);
 
   if (this->HitInputExtent == 0)
   {
     vtkImageResliceClearExecute(this, inData[0][0], nullptr, outData[0], outPtr, outExt, id);
     return;
   }
 
   // Now that we know that we need the input, get the input pointer
   void *inPtr = inData[0][0]->GetScalarPointerForExtent(inExt);
 
   vtkImageResliceExecute(this, inData[0][0], inPtr, outData[0], outPtr, outExt, id);
 }
diff --git a/Modules/Segmentation/DataManagement/mitkExtrudedContour.h b/Modules/Segmentation/DataManagement/mitkExtrudedContour.h
index 767a870412..9f875a6321 100644
--- a/Modules/Segmentation/DataManagement/mitkExtrudedContour.h
+++ b/Modules/Segmentation/DataManagement/mitkExtrudedContour.h
@@ -1,126 +1,126 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKEXTRUDEDCONTOUR_H_HEADER_INCLUDED
 #define MITKEXTRUDEDCONTOUR_H_HEADER_INCLUDED
 
 #include "mitkBoundingObject.h"
 #include <MitkSegmentationExports.h>
 #include <mitkContour.h>
 #include <mitkPlaneGeometry.h>
 #include <vtkVersionMacros.h>
 
 class vtkLinearExtrusionFilter;
 class vtkPlanes;
 class vtkClipPolyData;
 class vtkLinearSubdivisionFilter;
 class vtkTriangleFilter;
 class vtkDecimatePro;
 class vtkPolygon;
 
 namespace mitk
 {
   //##Documentation
   //## @brief Data class containing a bounding-object created by
   //## extruding a Contour along a vector
   //##
   //## The m_Contour is extruded in the direction m_Vector until
   //## reaching m_ClippingGeometry.
   //## @ingroup Data
 
   /**
   * \deprecatedSince{2015_05} ExtrudedContour is deprecated. It will be removed in the next release.
-  *  Becomes obsolete. Refer to http://docs.mitk.org/nightly/InteractionMigration.html .
+  *  Becomes obsolete. Refer to https://docs.mitk.org/nightly/InteractionMigration.html .
   */
 
   class MITKSEGMENTATION_EXPORT ExtrudedContour : public BoundingObject
   {
   public:
     mitkClassMacro(ExtrudedContour, BoundingObject);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       mitk::ScalarType GetVolume() override;
     bool IsInside(const Point3D &p) const override;
     void UpdateOutputInformation() override;
 
     //##Documentation
     //## @brief Contour to extrude
     itkGetConstObjectMacro(Contour, mitk::Contour);
     itkSetObjectMacro(Contour, mitk::Contour);
 
     //##Documentation
     //## @brief Vector to specify the direction of the extrusion
     mitkGetVectorMacro(Vector, mitk::Vector3D);
     mitkSetVectorMacro(Vector, mitk::Vector3D);
     itkGetConstMacro(AutomaticVectorGeneration, bool);
     itkSetMacro(AutomaticVectorGeneration, bool);
     itkBooleanMacro(AutomaticVectorGeneration);
 
     //##Documentation
     //## @brief Optional vector to specify the orientation of the bounding-box
     mitkGetVectorMacro(RightVector, mitk::Vector3D);
     mitkSetVectorMacro(RightVector, mitk::Vector3D);
 
     //##Documentation
     //## @brief Optional geometry for clipping the extruded contour
     itkGetConstObjectMacro(ClippingGeometry, mitk::BaseGeometry);
     itkSetObjectMacro(ClippingGeometry, mitk::BaseGeometry);
 
     itk::ModifiedTimeType GetMTime() const override;
 
   protected:
     ExtrudedContour();
     ~ExtrudedContour() override;
 
     void BuildSurface();
     void BuildGeometry();
 
     mitk::Contour::Pointer m_Contour;
     mitk::Vector3D m_Vector;
     mitk::Vector3D m_RightVector;
     mitk::BaseGeometry::Pointer m_ClippingGeometry;
 
     bool m_AutomaticVectorGeneration;
 
     vtkPolygon *m_Polygon;
 
 #if ((VTK_MAJOR_VERSION > 4) || ((VTK_MAJOR_VERSION == 4) && (VTK_MINOR_VERSION >= 4)))
     double m_ProjectedContourBounds[6];
 #else
     float m_ProjectedContourBounds[6];
 #endif
 
     mitk::PlaneGeometry::Pointer m_ProjectionPlane;
     //##Documentation
     //## @brief For fast projection on plane
     float m_Right[3];
     float m_Down[3];
 
 #if ((VTK_MAJOR_VERSION > 4) || ((VTK_MAJOR_VERSION == 4) && (VTK_MINOR_VERSION >= 4)))
     double m_Normal[3];
 #else
     float m_Normal[3];
 #endif
     float m_Origin[3];
 
     vtkLinearExtrusionFilter *m_ExtrusionFilter;
     vtkTriangleFilter *m_TriangleFilter;
     vtkDecimatePro *m_Decimate;
     vtkLinearSubdivisionFilter *m_SubdivisionFilter;
     vtkPlanes *m_ClippingBox;
     vtkClipPolyData *m_ClipPolyDataFilter;
 
     itk::TimeStamp m_LastCalculateExtrusionTime;
   };
 }
 #endif /* MITKEXTRUDEDCONTOUR_H_HEADER_INCLUDED */
diff --git a/Modules/ToFProcessing/mitkToFCompositeFilter.h b/Modules/ToFProcessing/mitkToFCompositeFilter.h
index 3b7fa54bbb..81ce0f269b 100644
--- a/Modules/ToFProcessing/mitkToFCompositeFilter.h
+++ b/Modules/ToFProcessing/mitkToFCompositeFilter.h
@@ -1,196 +1,193 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef __mitkToFCompositeFilter_h
 #define __mitkToFCompositeFilter_h
 
 #include <mitkImage.h>
 #include "mitkImageToImageFilter.h"
 #include <MitkToFProcessingExports.h>
 #include <itkBilateralImageFilter.h>
 #include "opencv2/core.hpp"
 
 typedef itk::Image<float, 2> ItkImageType2D;
 typedef itk::Image<float, 3> ItkImageType3D;
 typedef itk::BilateralImageFilter<ItkImageType2D,ItkImageType2D> BilateralFilterType;
 
 namespace mitk
 {
   /**
   * @brief Applies a common filter-pipeline to the first input of this filter
   *
   * This class intends to allow quick preprocessing of (ToF) range data. Input 0 of this filter, holding the range image,
   * is processed using the following image processing filters:
   * - threshold filter
   * - mask segmentation
   * - temporal median filter
   * - spatial median filter
   * - bilateral filter
   *
   * @ingroup ToFProcessing
   */
   class MITKTOFPROCESSING_EXPORT ToFCompositeFilter : public ImageToImageFilter
   {
   public:
 
     mitkClassMacro( ToFCompositeFilter , ImageToImageFilter );
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
     itkSetMacro(SegmentationMask,mitk::Image::Pointer);
     itkSetMacro(ApplyTemporalMedianFilter,bool);
     itkGetConstMacro(ApplyTemporalMedianFilter,bool);
     itkSetMacro(ApplyAverageFilter,bool);
     itkGetConstMacro(ApplyAverageFilter,bool);
     itkSetMacro(ApplyMedianFilter,bool);
     itkGetConstMacro(ApplyMedianFilter,bool);
     itkSetMacro(ApplyThresholdFilter,bool);
     itkGetConstMacro(ApplyThresholdFilter,bool);
     itkSetMacro(ApplyMaskSegmentation,bool);
     itkGetConstMacro(ApplyMaskSegmentation,bool);
     itkSetMacro(ApplyBilateralFilter,bool);
     itkGetConstMacro(ApplyBilateralFilter,bool);
 
     using itk::ProcessObject::SetInput;
 
      /*!
     \brief sets the input of this filter
     \param distanceImage input is the distance image of e.g. a ToF camera
     */
     void SetInput( const InputImageType* distanceImage) override;
 
     /*!
     \brief sets the input of this filter at idx
     \param idx number of the current input
     \param distanceImage input is the distance image of e.g. a ToF camera
     */
     void SetInput(unsigned int idx,  const InputImageType* distanceImage) override;
 
     /*!
     \brief returns the input of this filter
     */
     Image* GetInput();
 
     /*!
     \brief returns the input with id idx of this filter
     */
     Image* GetInput(unsigned int idx);
     /*!
     \brief Sets the parameter of the temporal median filter
     \param tmporalMedianFilterNumOfFrames number of frames to be considered for calulating the temporal median
     */
     void SetTemporalMedianFilterParameter(int tmporalMedianFilterNumOfFrames);
     /*!
     \brief Sets the parameters (lower, upper threshold) of the threshold filter
     \param min lower threshold of the threshold filter
     \param max upper threshold of the threshold filter
     */
     void SetThresholdFilterParameter(int min, int max);
     /*!
     \brief Sets the parameters (domain sigma, range sigma, kernel radius) of the bilateral filter
     \param domainSigma Parameter controlling the smoothing effect of the bilateral filter. Default value: 2
     \param rangeSigma Parameter controlling the edge preserving effect of the bilateral filter. Default value: 60
     \param kernelRadius radius of the filter mask of the bilateral filter
     */
     void SetBilateralFilterParameter(double domainSigma, double rangeSigma, int kernelRadius);
 
   protected:
     /*!
     \brief standard constructor
     */
     ToFCompositeFilter();
     /*!
     \brief standard destructor
     */
     ~ToFCompositeFilter() override;
     void GenerateOutputInformation() override;
     /*!
     \brief method generating the output of this filter. Called in the updated process of the pipeline.
     This method generates the output of the ToFSurfaceSource: The generated surface of the 3d points
     */
     void GenerateData() override;
     /**
     * \brief Create an output for each input
     *
     * This Method sets the number of outputs to the number of inputs
     * and creates missing outputs objects.
     * \warning any additional outputs that exist before the method is called are deleted
     */
     void CreateOutputsForAllInputs();
     /*!
     \brief Applies a mask and/or threshold segmentation to the input image.
     All pixels with values outside the mask, below the lower threshold (min) and above the upper threshold (max)
     are assigned the pixel value 0
     */
     void ProcessSegmentation(IplImage* inputIplImage);
     /*!
     \brief Applies the ITK bilateral filter to the input image
-    See http://www.itk.org/Doxygen320/html/classitk_1_1BilateralImageFilter.html for more details.
     */
     ItkImageType2D::Pointer ProcessItkBilateralFilter(ItkImageType2D::Pointer inputItkImage);
     /*!
     \brief Applies the OpenCV bilateral filter to the input image.
-    See http://opencv.willowgarage.com/documentation/c/image_filtering.html#smooth for more details
     */
     void ProcessCVBilateralFilter(IplImage* inputIplImage, IplImage* outputIplImage);
     /*!
     \brief Applies the OpenCV median filter to the input image.
-    See http://opencv.willowgarage.com/documentation/c/image_filtering.html#smooth for more details
     */
     void ProcessCVMedianFilter(IplImage* inputIplImage, IplImage* outputIplImage, int radius = 3);
     /*!
     \brief Performs temporal median filter on an image given the number of frames to be considered
     */
     void ProcessStreamedQuickSelectMedianImageFilter(IplImage* inputIplImage);
     /*!
     \brief Quickselect algorithm
     * This Quickselect routine is based on the algorithm described in
     * "Numerical recipes in C", Second Edition,
     * Cambridge University Press, 1992, Section 8.5, ISBN 0-521-43108-5
     * This code by Nicolas Devillard - 1998. Public domain.
     */
     float quick_select(float arr[], int n);
     /*!
     \brief Initialize and allocate a 2D ITK image of dimension m_ImageWidth*m_ImageHeight
     */
     void CreateItkImage(ItkImageType2D::Pointer &itkInputImage);
 
     mitk::Image::Pointer m_SegmentationMask; ///< mask image used for segmenting the image
 
     int m_ImageWidth; ///< x-dimension of the image
     int m_ImageHeight; ///< y-dimension of the image
     int m_ImageSize; ///< size of the image in bytes
 
     IplImage* m_IplDistanceImage; ///< OpenCV-representation of the distance image
     IplImage* m_IplOutputImage; ///< OpenCV-representation of the output image
 
     ItkImageType2D::Pointer m_ItkInputImage; ///< ITK representation of the distance image
 
     bool m_ApplyTemporalMedianFilter; ///< Flag indicating if the temporal median filter is currently active for processing the distance image
     bool m_ApplyAverageFilter; ///< Flag indicating if the average filter is currently active for processing the distance image
     bool m_ApplyMedianFilter; ///< Flag indicating if the spatial median filter is currently active for processing the distance image
     bool m_ApplyThresholdFilter; ///< Flag indicating if the threshold filter is currently active for processing the distance image
     bool m_ApplyMaskSegmentation; ///< Flag indicating if a mask segmentation is performed
     bool m_ApplyBilateralFilter; ///< Flag indicating if the bilateral filter is currently active for processing the distance image
 
     float** m_DataBuffer; ///< Buffer used for calculating the pixel-wise median over the last n (m_TemporalMedianFilterNumOfFrames) number of frames
     int m_DataBufferCurrentIndex; ///< Current index in the buffer of the temporal median filter
     int m_DataBufferMaxSize; ///< Maximal size for the buffer of the temporal median filter (m_DataBuffer)
 
     int m_TemporalMedianFilterNumOfFrames; ///< Number of frames to be used in the calculation of the temporal median
     int m_ThresholdFilterMin; ///< Lower threshold of the threshold filter. Pixels with values below will be assigned value 0 when applying the threshold filter
     int m_ThresholdFilterMax; ///< Lower threshold of the threshold filter. Pixels with values above will be assigned value 0 when applying the threshold filter
     double m_BilateralFilterDomainSigma; ///< Parameter of the bilateral filter controlling the smoothing effect of the filter. Default value: 2
     double m_BilateralFilterRangeSigma; ///< Parameter of the bilateral filter controlling the edge preserving effect of the filter. Default value: 60
     int m_BilateralFilterKernelRadius; ///< Kernel radius of the bilateral filter mask
 
   };
 } //END mitk namespace
 #endif
diff --git a/Modules/ToFUI/Qmitk/QmitkStructureSensorParameterWidget.h b/Modules/ToFUI/Qmitk/QmitkStructureSensorParameterWidget.h
index 45cf2399a9..c83301a597 100644
--- a/Modules/ToFUI/Qmitk/QmitkStructureSensorParameterWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkStructureSensorParameterWidget.h
@@ -1,84 +1,84 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkStructureSensorParameterWidget_h
 #define QmitkStructureSensorParameterWidget_h
 
 #include "MitkToFUIExports.h"
 #include "ui_QmitkStructureSensorParameterWidgetControls.h"
 
 #include <mitkToFImageGrabber.h>
 
 #include <QWidget>
 
 /**
 * @brief Widget for configuring the Structure Sensor device (Occipital, Inc.)
 *
 * @note This device is currently not available open-source, because the required WiFi
-* protocol is part of the commercial mbits source code (http://mbits.info/). If you
+* protocol is part of the commercial mbits source code (https://mbits.info/). If you
 * want to use the device please contact mitk-users@dkfz-heidelberg.de.
 *
 * @ingroup ToFUI
 */
 class MITKTOFUI_EXPORT QmitkStructureSensorParameterWidget :public QWidget
 {
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkStructureSensorParameterWidget(QWidget* p = nullptr, Qt::WindowFlags f = nullptr);
     ~QmitkStructureSensorParameterWidget() override;
 
     /* @brief This method is part of the widget an needs not to be called seperately. */
     virtual void CreateQtPartControl(QWidget *parent);
     /* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
 
     /*!
     \brief returns the ToFImageGrabber
     \return ToFImageGrabber currently used by the widget
     */
     mitk::ToFImageGrabber* GetToFImageGrabber();
 
     /*!
     \brief sets the ToFImageGrabber
     */
     void SetToFImageGrabber(mitk::ToFImageGrabber* aToFImageGrabber);
 
     /*!
     \brief activate camera settings according to the parameters from GUI
     */
     void ActivateAllParameters();
 
     /**
      * @brief GetSelectedResolution getter for 640/320 resolution.
      * @return 320: 320x240, 640: 640x480 else -1 and a warning.
      */
     int GetSelectedResolution();
 
   protected slots:
     /**
      * @brief OnResolutionChanged called when the resolution combobox is changed.
      */
     void OnResolutionChanged();
 
   protected:
 
     Ui::QmitkStructureSensorParameterWidgetControls* m_Controls; ///< member holding the UI elements of this widget
 
     mitk::ToFImageGrabber::Pointer m_ToFImageGrabber; ///< image grabber object to be configured by the widget
 };
 
 #endif // QmitkStructureSensorParameterWidget_h
diff --git a/Modules/TubeGraph/src/DataStructure/mitkTubeGraph.cpp b/Modules/TubeGraph/src/DataStructure/mitkTubeGraph.cpp
index bcec2ba4a6..cdb8a26cf6 100644
--- a/Modules/TubeGraph/src/DataStructure/mitkTubeGraph.cpp
+++ b/Modules/TubeGraph/src/DataStructure/mitkTubeGraph.cpp
@@ -1,273 +1,273 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkTubeGraph.h"
 #include "mitkGeometry3D.h"
 
 const mitk::TubeGraph::TubeDescriptorType mitk::TubeGraph::ErrorId =
   std::pair<VertexDescriptorType, VertexDescriptorType>(boost::graph_traits<GraphType>::null_vertex(),
                                                         boost::graph_traits<GraphType>::null_vertex());
 
 mitk::TubeGraph::TubeGraph()
 {
 }
 
 mitk::TubeGraph::TubeGraph(const mitk::TubeGraph &graph) : UndirectedGraph<TubeGraphVertex, TubeGraphEdge>(graph)
 {
 }
 
 mitk::TubeGraph::~TubeGraph()
 {
 }
 
 std::vector<mitk::TubeGraph::TubeDescriptorType> mitk::TubeGraph::SearchShortestPath(
   const TubeDescriptorType &, const TubeDescriptorType &)
 {
   std::vector<TubeDescriptorType> shortestPath;
   return shortestPath;
 }
 
 std::vector<mitk::TubeGraph::TubeDescriptorType> mitk::TubeGraph::SearchAllPathBetweenVertices(
   const mitk::TubeGraph::TubeDescriptorType &startTube,
   const mitk::TubeGraph::TubeDescriptorType &endTube /*, std::vector<unsigned long> barrier*/)
-{ // http://lists.boost.org/boost-users/att-9001/maze.cpp
-  // http://www.boost.org/doc/libs/1_49_0/libs/graph/example/bfs.cpp
+{ // https://lists.boost.org/boost-users/att-9001/maze.cpp
+  // https://www.boost.org/doc/libs/1_49_0/libs/graph/example/bfs.cpp
 
   typedef std::map<VertexDescriptorType, EdgeDescriptorType> EdgeMap;
   typedef boost::associative_property_map<EdgeMap> PredecessorMap;
   typedef boost::edge_predecessor_recorder<PredecessorMap, boost::on_tree_edge> PredecessorVisitor;
   typedef boost::dfs_visitor<std::pair<PredecessorVisitor, boost::null_visitor>> DFSVisitor;
 
   EdgeMap edgesMap;
   PredecessorMap predecessorMap(edgesMap);
 
   PredecessorVisitor predecessorVisitor(predecessorMap);
   boost::null_visitor nullVisitor;
   DFSVisitor visitor = boost::make_dfs_visitor(std::make_pair(predecessorVisitor, nullVisitor));
 
   std::map<VertexDescriptorType, boost::default_color_type> vertexColorMap;
   std::map<EdgeDescriptorType, boost::default_color_type> edgeColorMap;
 
   boost::undirected_dfs(
     m_Graph, visitor, make_assoc_property_map(vertexColorMap), make_assoc_property_map(edgeColorMap), startTube.second);
 
   std::vector<TubeDescriptorType> solutionPath;
   solutionPath.push_back(endTube);
   VertexDescriptorType pathEdgeSource = endTube.first;
   VertexDescriptorType pathEdgeTarget;
 
   MITK_INFO << "Source: [" << startTube.first << "," << startTube.second << "] Target: [" << endTube.first << ","
             << endTube.second << "]";
   MITK_INFO << "tube [" << endTube.first << "," << endTube.second << "]";
   do
   {
     if (pathEdgeSource == 10393696)
       break;
     EdgeDescriptorType edge = get(predecessorMap, pathEdgeSource);
     pathEdgeSource = boost::source(edge, m_Graph);
     pathEdgeTarget = boost::target(edge, m_Graph);
     TubeDescriptorType tube(pathEdgeSource, pathEdgeTarget);
     MITK_INFO << "tube [" << tube.first << "," << tube.second << "]";
     solutionPath.push_back(tube);
   } while (pathEdgeSource != startTube.second);
 
   return solutionPath;
 }
 
 std::vector<mitk::TubeGraph::TubeDescriptorType> mitk::TubeGraph::SearchPathToPeriphery(
   const mitk::TubeGraph::TubeDescriptorType &startTube /*, std::vector<unsigned long> barrier*/)
 {
   std::vector<mitk::TubeGraph::TubeDescriptorType> pathToPeriphery;
 
   if (m_RootTube == ErrorId)
   {
     m_RootTube = this->GetThickestTube();
     if (m_Root == m_RootTube.first)
       m_Root = m_RootTube.second;
     else
       m_Root = m_RootTube.first;
   }
 
   // Attention!! No check which one is the right one
   DirectedGraphType directedGraph = this->GetDirectedGraph(m_Root);
 
   // Only the target vertex: it's a directed Graph, and we want only the "after tube" tubes and the clicked ones
   // this->GetOutEdgesOfAVertex(startTube.first, directedGraph, pathToPeriphery);
   pathToPeriphery.push_back(startTube);
   this->GetOutEdgesOfAVertex(startTube.second, directedGraph, pathToPeriphery);
 
   return pathToPeriphery;
 }
 
 void mitk::TubeGraph::GetOutEdgesOfAVertex(mitk::TubeGraph::VertexDescriptorType vertex,
                                            mitk::TubeGraph::DirectedGraphType &directedGraph,
                                            std::vector<mitk::TubeGraph::TubeDescriptorType> &pathToPeriphery)
 {
   typedef boost::graph_traits<DirectedGraphType>::out_edge_iterator OutEdgeIteratorType;
   std::pair<OutEdgeIteratorType, OutEdgeIteratorType> outEdges = boost::out_edges(vertex, directedGraph);
   for (; outEdges.first != outEdges.second; ++outEdges.first)
   {
     TubeDescriptorType tube;
     tube.first = boost::source(*outEdges.first, directedGraph);
     tube.second = boost::target(*outEdges.first, directedGraph);
 
     if (std::find(pathToPeriphery.begin(), pathToPeriphery.end(), tube) == pathToPeriphery.end())
     {
       pathToPeriphery.push_back(tube);
       this->GetOutEdgesOfAVertex(tube.second, directedGraph, pathToPeriphery);
     }
   }
 }
 
 mitk::TubeGraph::TubeDescriptorType mitk::TubeGraph::GetThickestTube()
 {
   TubeDescriptorType thickestTube;
   float tubeDiameter = 0.0;
 
   EdgeIteratorType iterator, end;
 
   boost::tie(iterator, end) = boost::edges(m_Graph);
 
   for (; iterator != end; ++iterator)
   {
     TubeGraphEdge edge = this->GetEdge(*iterator);
 
     std::pair<TubeGraphVertex, TubeGraphVertex> soureTargetPair = this->GetVerticesOfAnEdge(*iterator);
 
     float tempDiameter = edge.GetEdgeAverageDiameter(soureTargetPair.first, soureTargetPair.second);
     if (tempDiameter > tubeDiameter)
     {
       tubeDiameter = tempDiameter;
       thickestTube.first = this->GetVertexDescriptor(soureTargetPair.first);
       thickestTube.second = this->GetVertexDescriptor(soureTargetPair.second);
     }
   }
   return thickestTube;
 }
 
 mitk::TubeGraph::DirectedGraphType mitk::TubeGraph::GetDirectedGraph(VertexDescriptorType startVertex)
 {
   DirectedGraphType directedGraph(boost::num_vertices(m_Graph));
   DirectedGraphBfsVisitor vis(this, directedGraph);
   boost::breadth_first_search(m_Graph, startVertex, visitor(vis));
   return directedGraph;
 }
 
 mitk::TubeGraph::Pointer mitk::TubeGraph::CreateSubGraph(std::vector<TubeDescriptorType> subGraphTubes)
 {
   TubeGraph::Pointer subGraph = new TubeGraph();
   // store the descriptor from origin graph to the correspondent new descriptors
   std::map<VertexDescriptorType, VertexDescriptorType> vertexDescriptorOldToNewMap;
 
   // add a new edge and if necessary also the vertices of each tube to the new sub graph
   for (auto it = subGraphTubes.begin(); it != subGraphTubes.end(); it++)
   {
     // search for the source vertex in the subgraph; if it is already added continue, otherwise add it
     if (vertexDescriptorOldToNewMap.find(it->first) == vertexDescriptorOldToNewMap.end())
     {
       // add the vertex to the subgraph
       VertexDescriptorType newVertexDescriptor = subGraph->AddVertex(this->GetVertex(it->first));
       // add the pair of descriptor from the origin graph to the descriptor from the subgraph
       vertexDescriptorOldToNewMap.insert(
         std::pair<VertexDescriptorType, VertexDescriptorType>(it->first, newVertexDescriptor));
     }
     // and now...search for the target vertex...
     if (vertexDescriptorOldToNewMap.find(it->second) == vertexDescriptorOldToNewMap.end())
     {
       VertexDescriptorType newVertexDescriptor = subGraph->AddVertex(this->GetVertex(it->second));
       vertexDescriptorOldToNewMap.insert(
         std::pair<VertexDescriptorType, VertexDescriptorType>(it->second, newVertexDescriptor));
     }
     // Get the EdgeDescriptor from origin graph
     EdgeDescriptorType edgeDescriptor = this->GetEdgeDescriptorByVerices(it->first, it->second);
 
     TubeGraphEdge oldEdge = this->GetEdge(edgeDescriptor);
 
     // AddEdge needs the source vertex, the target vertex and the edge data
     // source Vertex: get the subgraph VertexDescriptor  by the origin descriptor (tubeDescriptor->first)from the
     // assigning map
     // target Vertex: get the subgraph VertexDescriptor  by the origin descriptor (tubeDescriptor->second)from the
     // assigning map
     // edge data: copy the TubeGraphEdge object using the origin edge desciptor and the origin graph
     VertexDescriptorType sourceVertex = vertexDescriptorOldToNewMap[it->first];
     VertexDescriptorType targetVertex = vertexDescriptorOldToNewMap[it->second];
     subGraph->AddEdge(sourceVertex, targetVertex, this->GetEdge(edgeDescriptor));
   }
   subGraph->CopyInformation(this);
 
   mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
   geometry->Initialize();
   subGraph->SetGeometry(geometry);
 
   this->Modified();
 
   return subGraph;
 }
 
 void mitk::TubeGraph::RemoveSubGraph(std::vector<TubeDescriptorType> deletedTubes)
 {
   for (auto it = deletedTubes.begin(); it != deletedTubes.end(); it++)
   {
     VertexDescriptorType source = it->first;
     VertexDescriptorType target = it->second;
 
     EdgeDescriptorType edge = this->GetEdgeDescriptorByVerices(source, target);
     this->RemoveEdge(edge);
 
     if (this->GetAllEdgesOfAVertex(source).size() == 0)
     {
       this->RemoveVertex(source);
     }
     if (this->GetAllEdgesOfAVertex(target).size() == 0)
     {
       this->RemoveVertex(target);
     }
   }
   this->Modified();
 }
 
 void mitk::TubeGraph::SetRootTube(const TubeDescriptorType &root)
 {
   if (root != TubeGraph::ErrorId)
   {
     m_RootTube = root;
     if (m_Root == root.first)
       m_Root = root.second;
     else
       m_Root = root.first;
     this->Modified();
   }
 }
 
 void mitk::TubeGraph::SetRoot(const VertexDescriptorType &root)
 {
   if (root != TubeGraph::ErrorId.first)
   {
     m_Root = root;
   }
 }
 
 mitk::TubeGraph::TubeDescriptorType mitk::TubeGraph::GetRootTube()
 {
   return m_RootTube;
 }
 
 mitk::TubeGraph::VertexDescriptorType mitk::TubeGraph::GetRootVertex()
 {
   return m_Root;
 }
 
 mitk::TubeGraph &mitk::TubeGraph::operator=(const mitk::TubeGraph &rhs)
 {
   UndirectedGraph<TubeGraphVertex, TubeGraphEdge>::operator=(rhs);
   return *this;
 }
diff --git a/Modules/US/Testing/files.cmake b/Modules/US/Testing/files.cmake
index c3b51c1dd7..651decd4d2 100644
--- a/Modules/US/Testing/files.cmake
+++ b/Modules/US/Testing/files.cmake
@@ -1,19 +1,19 @@
 SET(MODULE_TESTS
    mitkUSDeviceTest.cpp
    mitkUSProbeTest.cpp
 
    # -----------------------------------------------------------------------
 
    # ------------------ Deavtivated Tests ----------------------------------
 
-   # see http://bugs.mitk.org/show_bug.cgi?id=18180
+   # see https://phabricator.mitk.org/T18180
    mitkUSImageLoggingFilterTest.cpp
 
    # -----------------------------------------------------------------------
 )
 
 SET(MODULE_CUSTOM_TESTS
   mitkUSImageVideoSourceTest.cpp
 )
 
 
diff --git a/Plugins/org.blueberry.core.commands/manifest_headers.cmake b/Plugins/org.blueberry.core.commands/manifest_headers.cmake
index 7883c7d99a..2249f61273 100644
--- a/Plugins/org.blueberry.core.commands/manifest_headers.cmake
+++ b/Plugins/org.blueberry.core.commands/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "BlueBerry Core Commands Plugin")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin "org.blueberry.core.runtime")
 
diff --git a/Plugins/org.blueberry.core.expressions/manifest_headers.cmake b/Plugins/org.blueberry.core.expressions/manifest_headers.cmake
index ebfc43f317..b15ffc6f1b 100644
--- a/Plugins/org.blueberry.core.expressions/manifest_headers.cmake
+++ b/Plugins/org.blueberry.core.expressions/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "BlueBerry Core Expressions Plugin")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.core.runtime)
 
diff --git a/Plugins/org.blueberry.core.jobs/manifest_headers.cmake b/Plugins/org.blueberry.core.jobs/manifest_headers.cmake
index 0f2b007e1c..358bcd3717 100644
--- a/Plugins/org.blueberry.core.jobs/manifest_headers.cmake
+++ b/Plugins/org.blueberry.core.jobs/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "BlueBerry Jobs Mechanism")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.core.runtime)
 
diff --git a/Plugins/org.blueberry.core.runtime/manifest_headers.cmake b/Plugins/org.blueberry.core.runtime/manifest_headers.cmake
index 60cbdc1491..47a94ff860 100644
--- a/Plugins/org.blueberry.core.runtime/manifest_headers.cmake
+++ b/Plugins/org.blueberry.core.runtime/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "BlueBerry Core Runtime Plugin")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Plugin-ActivationPolicy "eager")
 
diff --git a/Plugins/org.blueberry.core.runtime/src/berryIPreferences.h b/Plugins/org.blueberry.core.runtime/src/berryIPreferences.h
index a9badb3a9b..6df73b2edf 100644
--- a/Plugins/org.blueberry.core.runtime/src/berryIPreferences.h
+++ b/Plugins/org.blueberry.core.runtime/src/berryIPreferences.h
@@ -1,709 +1,709 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef BERRYIPREFERENCES_H_
 #define BERRYIPREFERENCES_H_
 
 #include <org_blueberry_core_runtime_Export.h>
 
 #include "berryObject.h"
 #include "berryBackingStoreException.h"
 
 
 namespace berry
 {
 
   /**
    * A node in a hierarchical collection of preference data.
    *
    * <p>
    * This interface allows applications to store and retrieve user and system
    * preference data. This data is stored persistently in an
    * implementation-dependent backing store. Typical implementations include flat
    * files, OS-specific registries, directory servers and SQL databases.
    *
    * <p>
    * For each bundle, there is a separate tree of nodes for each user, and one for
    * system preferences. The precise description of "user" and "system" will vary
    * from one bundle to another. Typical information stored in the user preference
    * tree might include font choice, and color choice for a bundle which interacts
    * with the user via a servlet. Typical information stored in the system
    * preference tree might include installation data, or things like high score
    * information for a game program.
    *
    * <p>
    * Nodes in a preference tree are named in a similar fashion to directories in a
    * hierarchical file system. Every node in a preference tree has a <i>node name
    * </i> (which is not necessarily unique), a unique <i>absolute path name </i>,
    * and a path name <i>relative </i> to each ancestor including itself.
    *
    * <p>
    * The root node has a node name of the empty <code>QString</code> object ("").
    * Every other node has an arbitrary node name, specified at the time it is
    * created. The only restrictions on this name are that it cannot be the empty
    * string, and it cannot contain the slash character ('/').
    *
    * <p>
    * The root node has an absolute path name of <code>"/"</code>. Children of the
    * root node have absolute path names of <code>"/" + </code> <i>&lt;node name&gt;
    * </i>. All other nodes have absolute path names of <i>&lt;parent's absolute
    * path name&gt; </i> <code> + "/" + </code> <i>&lt;node name&gt; </i>. Note that
    * all absolute path names begin with the slash character.
    *
    * <p>
    * A node <i>n </i>'s path name relative to its ancestor <i>a </i> is simply the
    * string that must be appended to <i>a </i>'s absolute path name in order to
    * form <i>n </i>'s absolute path name, with the initial slash character (if
    * present) removed. Note that:
    * <ul>
    * <li>No relative path names begin with the slash character.
    * <li>Every node's path name relative to itself is the empty string.
    * <li>Every node's path name relative to its parent is its node name (except
    * for the root node, which does not have a parent).
    * <li>Every node's path name relative to the root is its absolute path name
    * with the initial slash character removed.
    * </ul>
    *
    * <p>
    * Note finally that:
    * <ul>
    * <li>No path name contains multiple consecutive slash characters.
    * <li>No path name with the exception of the root's absolute path name end in
    * the slash character.
    * <li>Any string that conforms to these two rules is a valid path name.
    * </ul>
    *
    * <p>
    * Each <code>Preference</code> node has zero or more properties associated with
    * it, where a property consists of a name and a value. The bundle writer is
    * free to choose any appropriate names for properties. Their values can be of
    * type <code>QString</code>,<code>long</code>,<code>int</code>,<code>bool</code>,
    * <code>std::vector<char></code>,<code>float</code>, or <code>double</code> but they can
    * always be accessed as if they were <code>QString</code> objects.
    *
    * <p>
    * All node name and property name comparisons are case-sensitive.
    *
    * <p>
    * All of the methods that modify preference data are permitted to operate
    * asynchronously; they may return immediately, and changes will eventually
    * propagate to the persistent backing store, with an implementation-dependent
    * delay. The <code>flush</code> method may be used to synchronously force updates
    * to the backing store.
    *
    * <p>
    * Implementations must automatically attempt to flush to the backing store any
    * pending updates for a bundle's preferences when the bundle is stopped or
    * otherwise ungets the IPreferences Service.
    *
    * <p>
    * The methods in this class may be invoked concurrently by multiple threads in
    * a single Java Virtual Machine (JVM) without the need for external
    * synchronization, and the results will be equivalent to some serial execution.
    * If this class is used concurrently <i>by multiple JVMs </i> that store their
    * preference data in the same backing store, the data store will not be
    * corrupted, but no other guarantees are made concerning the consistency of the
    * preference data.
    *
    *
    * @version $Revision$
    */
   struct org_blueberry_core_runtime_EXPORT IPreferences : virtual public Object
   {
     berryObjectMacro(berry::IPreferences);
 
     ~IPreferences() override;
 
     /**
      * Associates the specified value with the specified key in this node.
      *
      * @param key key with which the specified value is to be associated.
      * @param value value to be associated with the specified key.
      * @throws NullPointerException if <code>key</code> or <code>value</code> is
      *         <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      */
     virtual void Put(const QString& key, const QString& value) = 0;
 
     /**
      * Returns the value associated with the specified <code>key</code> in this
      * node. Returns the specified default if there is no value associated with
      * the <code>key</code>, or the backing store is inaccessible.
      *
      * @param key key whose associated value is to be returned.
      * @param def the value to be returned in the event that this node has no
      *        value associated with <code>key</code> or the backing store is
      *        inaccessible.
      * @return the value associated with <code>key</code>, or <code>def</code> if
      *         no value is associated with <code>key</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @throws NullPointerException if <code>key</code> is <code>null</code>. (A
      *         <code>null</code> default <i>is </i> permitted.)
      */
     virtual QString Get(const QString& key, const QString& def) const = 0;
 
     /**
      * Removes the value associated with the specified <code>key</code> in this
      * node, if any.
      *
      * @param key key whose mapping is to be removed from this node.
      * @see #Get
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      */
     virtual void Remove(const QString& key) = 0;
 
     /**
      * Removes all of the properties (key-value associations) in this node. This
      * call has no effect on any descendants of this node.
      *
      * @throws BackingStoreException if this operation cannot be completed due
      *         to a failure in the backing store, or inability to communicate
      *         with it.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #Remove(const QString&)
      */
     virtual void Clear() = 0;
 
     /**
      * Associates a <code>QString</code> object representing the specified
      * <code>int</code> value with the specified <code>key</code> in this node. The
      * associated string is the one that would be returned if the <code>int</code>
      * value were passed to <code>Integer.toString(int)</code>. This method is
      * intended for use in conjunction with {@link #GetInt}method.
      *
      * <p>
      * Implementor's note: it is <i>not </i> necessary that the property value
      * be represented by a <code>QString</code> object in the backing store. If the
      * backing store supports integer values, it is not unreasonable to use
      * them. This implementation detail is not visible through the
      * <code>IPreferences</code> API, which allows the value to be read as an
      * <code>int</code> (with <code>getInt</code> or a <code>QString</code> (with
      * <code>get</code>) type.
      *
      * @param key key with which the string form of value is to be associated.
      * @param value <code>value</code> whose string form is to be associated with
      *        <code>key</code>.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #GetInt
      */
     virtual void PutInt(const QString& key, int value) = 0;
 
     /**
      * Returns the <code>int</code> value represented by the <code>QString</code>
      * object associated with the specified <code>key</code> in this node. The
      * <code>QString</code> object is converted to an <code>int</code> as by
      * <code>Integer.parseInt(QString)</code>. Returns the specified default if
      * there is no value associated with the <code>key</code>, the backing store
      * is inaccessible, or if <code>Integer.parseInt(QString)</code> would throw a
      * <code>NumberFormatException</code> if the associated <code>value</code> were
      * passed. This method is intended for use in conjunction with the
      * {@link #PutInt}method.
      *
      * @param key key whose associated value is to be returned as an
      *        <code>int</code>.
      * @param def the value to be returned in the event that this node has no
      *        value associated with <code>key</code> or the associated value
      *        cannot be interpreted as an <code>int</code> or the backing store is
      *        inaccessible.
      * @return the <code>int</code> value represented by the <code>QString</code>
      *         object associated with <code>key</code> in this node, or
      *         <code>def</code> if the associated value does not exist or cannot
      *         be interpreted as an <code>int</code> type.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #PutInt(const QString&,int)
      * @see #Get
      */
     virtual int GetInt(const QString& key, int def) const = 0;
 
     /**
      * Associates a <code>QString</code> object representing the specified
      * <code>long</code> value with the specified <code>key</code> in this node. The
      * associated <code>QString</code> object is the one that would be returned if
      * the <code>long</code> value were passed to <code>Long.toString(long)</code>.
      * This method is intended for use in conjunction with the {@link #GetLong}
      * method.
      *
      * <p>
      * Implementor's note: it is <i>not </i> necessary that the <code>value</code>
      * be represented by a <code>QString</code> type in the backing store. If the
      * backing store supports <code>long</code> values, it is not unreasonable to
      * use them. This implementation detail is not visible through the <code>
      * IPreferences</code> API, which allows the value to be read as a
      * <code>long</code> (with <code>getLong</code> or a <code>QString</code> (with
      * <code>get</code>) type.
      *
      * @param key <code>key</code> with which the string form of <code>value</code>
      *        is to be associated.
      * @param value <code>value</code> whose string form is to be associated with
      *        <code>key</code>.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #GetLong
      */
     virtual void PutLong(const QString& key, long value) = 0;
 
     /**
      * Returns the <code>long</code> value represented by the <code>QString</code>
      * object associated with the specified <code>key</code> in this node. The
      * <code>QString</code> object is converted to a <code>long</code> as by
      * <code>Long.parseLong(QString)</code>. Returns the specified default if
      * there is no value associated with the <code>key</code>, the backing store
      * is inaccessible, or if <code>Long.parseLong(QString)</code> would throw a
      * <code>NumberFormatException</code> if the associated <code>value</code> were
      * passed. This method is intended for use in conjunction with the
      * {@link #PutLong}method.
      *
      * @param key <code>key</code> whose associated value is to be returned as a
      *        <code>long</code> value.
      * @param def the value to be returned in the event that this node has no
      *        value associated with <code>key</code> or the associated value
      *        cannot be interpreted as a <code>long</code> type or the backing
      *        store is inaccessible.
      * @return the <code>long</code> value represented by the <code>QString</code>
      *         object associated with <code>key</code> in this node, or
      *         <code>def</code> if the associated value does not exist or cannot
      *         be interpreted as a <code>long</code> type.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #PutLong(const QString&,long)
      * @see #Get
      */
     virtual long GetLong(const QString& key, long def) const = 0;
 
     /**
      * Associates a <code>QString</code> object representing the specified
      * <code>bool</code> value with the specified key in this node. The
      * associated string is "true" if the value is <code>true</code>, and "false"
      * if it is <code>false</code>. This method is intended for use in
      * conjunction with the {@link #GetBool}method.
      *
      * <p>
      * Implementor's note: it is <i>not </i> necessary that the value be
      * represented by a string in the backing store. If the backing store
      * supports <code>bool</code> values, it is not unreasonable to use them.
      * This implementation detail is not visible through the <code>IPreferences
      * </code> API, which allows the value to be read as a <code>bool</code>
      * (with <code>getBool</code>) or a <code>QString</code> (with <code>get</code>)
      * type.
      *
      * @param key <code>key</code> with which the string form of value is to be
      *        associated.
      * @param value value whose string form is to be associated with
      *        <code>key</code>.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #GetBool
      * @see #Get
      */
     virtual void PutBool(const QString& key, bool value) = 0;
 
     /**
      * Returns the <code>bool</code> value represented by the <code>QString</code>
      * object associated with the specified <code>key</code> in this node. Valid
      * strings are "true", which represents <code>true</code>, and "false", which
      * represents <code>false</code>. Case is ignored, so, for example, "TRUE"
      * and "False" are also valid. This method is intended for use in
      * conjunction with the {@link #PutBool}method.
      *
      * <p>
      * Returns the specified default if there is no value associated with the
      * <code>key</code>, the backing store is inaccessible, or if the associated
      * value is something other than "true" or "false", ignoring case.
      *
      * @param key <code>key</code> whose associated value is to be returned as a
      *        <code>bool</code>.
      * @param def the value to be returned in the event that this node has no
      *        value associated with <code>key</code> or the associated value
      *        cannot be interpreted as a <code>bool</code> or the backing store
      *        is inaccessible.
      * @return the <code>bool</code> value represented by the <code>std::string</code>
      *         object associated with <code>key</code> in this node, or
      *         <code>null</code> if the associated value does not exist or cannot
      *         be interpreted as a <code>bool</code>.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #Get
      * @see #PutBool
      */
     virtual bool GetBool(const QString& key, bool def) const = 0;
 
     /**
      * Associates a <code>QString</code> object representing the specified
      * <code>float</code> value with the specified <code>key</code> in this node.
      * The associated <code>QString</code> object is the one that would be returned
      * if the <code>float</code> value were passed to
      * <code>Float.toString(float)</code>. This method is intended for use in
      * conjunction with the {@link #GetFloat}method.
      *
      * <p>
      * Implementor's note: it is <i>not </i> necessary that the value be
      * represented by a string in the backing store. If the backing store
      * supports <code>float</code> values, it is not unreasonable to use them.
      * This implementation detail is not visible through the <code>IPreferences
      * </code> API, which allows the value to be read as a <code>float</code> (with
      * <code>getFloat</code>) or a <code>QString</code> (with <code>get</code>) type.
      *
      * @param key <code>key</code> with which the string form of value is to be
      *        associated.
      * @param value value whose string form is to be associated with
      *        <code>key</code>.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #GetFloat
      */
     virtual void PutFloat(const QString& key, float value) = 0;
 
     /**
      * Returns the float <code>value</code> represented by the <code>QString</code>
      * object associated with the specified <code>key</code> in this node. The
      * <code>QString</code> object is converted to a <code>float</code> value as by
      * <code>Float.parseFloat(QString)</code>. Returns the specified default if
      * there is no value associated with the <code>key</code>, the backing store
      * is inaccessible, or if <code>Float.parseFloat(QString)</code> would throw a
      * <code>NumberFormatException</code> if the associated value were passed.
      * This method is intended for use in conjunction with the {@link #PutFloat}
      * method.
      *
      * @param key <code>key</code> whose associated value is to be returned as a
      *        <code>float</code> value.
      * @param def the value to be returned in the event that this node has no
      *        value associated with <code>key</code> or the associated value
      *        cannot be interpreted as a <code>float</code> type or the backing
      *        store is inaccessible.
      * @return the <code>float</code> value represented by the string associated
      *         with <code>key</code> in this node, or <code>def</code> if the
      *         associated value does not exist or cannot be interpreted as a
      *         <code>float</code> type.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @see #PutFloat
      * @see #Get
      */
     virtual float GetFloat(const QString& key, float def) const = 0;
 
     /**
      * Associates a <code>QString</code> object representing the specified
      * <code>double</code> value with the specified <code>key</code> in this node.
      * The associated <code>QString</code> object is the one that would be returned
      * if the <code>double</code> value were passed to
      * <code>Double.toString(double)</code>. This method is intended for use in
      * conjunction with the {@link #GetDouble}method
      *
      * <p>
      * Implementor's note: it is <i>not </i> necessary that the value be
      * represented by a string in the backing store. If the backing store
      * supports <code>double</code> values, it is not unreasonable to use them.
      * This implementation detail is not visible through the <code>IPreferences
      * </code> API, which allows the value to be read as a <code>double</code> (with
      * <code>getDouble</code>) or a <code>QString</code> (with <code>get</code>)
      * type.
      *
      * @param key <code>key</code> with which the string form of value is to be
      *        associated.
      * @param value value whose string form is to be associated with
      *        <code>key</code>.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #GetDouble
      */
     virtual void PutDouble(const QString& key, double value) = 0;
 
     /**
      * Returns the <code>double</code> value represented by the <code>QString</code>
      * object associated with the specified <code>key</code> in this node. The
      * <code>QString</code> object is converted to a <code>double</code> value as by
      * <code>Double.parseDouble(QString)</code>. Returns the specified default if
      * there is no value associated with the <code>key</code>, the backing store
      * is inaccessible, or if <code>Double.parseDouble(QString)</code> would throw
      * a <code>NumberFormatException</code> if the associated value were passed.
      * This method is intended for use in conjunction with the
      * {@link #PutDouble}method.
      *
      * @param key <code>key</code> whose associated value is to be returned as a
      *        <code>double</code> value.
      * @param def the value to be returned in the event that this node has no
      *        value associated with <code>key</code> or the associated value
      *        cannot be interpreted as a <code>double</code> type or the backing
      *        store is inaccessible.
      * @return the <code>double</code> value represented by the <code>QString</code>
      *         object associated with <code>key</code> in this node, or
      *         <code>def</code> if the associated value does not exist or cannot
      *         be interpreted as a <code>double</code> type.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the the {@link #Remove()}method.
      * @throws NullPointerException if <code>key</code> is <code>null</code>.
      * @see #PutDouble
      * @see #Get
      */
     virtual double GetDouble(const QString& key, double def) const = 0;
 
     /**
      * Associates a <code>QByteArray</code> object representing the specified
      * <code>QByteArray</code> with the specified <code>key</code> in this node. The
      * associated <code>QByteArray</code> object is stored in <i>Base64</i> encoding.
      * This method is intended for use in conjunction with the
      * {@link #GetByteArray}method.
      *
      * @param key <code>key</code> with which the string form of <code>value</code>
      *        is to be associated.
      * @param value <code>value</code> whose string form is to be associated with
      *        <code>key</code>.
      * @throws NullPointerException if <code>key</code> or <code>value</code> is
      *         <code>null</code>.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #GetByteArray
      * @see #Get
      */
     virtual void PutByteArray(const QString& key, const QByteArray& value) = 0;
 
     /**
      * Returns the <code>QByteArray</code> value represented by the <code>QString</code>
      * object associated with the specified <code>key</code> in this node. Valid
      * <code>QString</code> objects are <i>Base64 </i> encoded binary data, as
-     * defined in <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 </a>,
+     * defined in <a href="https://www.ietf.org/rfc/rfc2045.txt">RFC 2045 </a>,
      * Section 6.8, with one minor change: the string must consist solely of
      * characters from the <i>Base64 Alphabet </i>; no newline characters or
      * extraneous characters are permitted. This method is intended for use in
      * conjunction with the {@link #PutByteArray}method.
      *
      * <p>
      * Returns the specified default if there is no value associated with the
      * <code>key</code>, the backing store is inaccessible, or if the associated
      * value is not a valid Base64 encoded byte array (as defined above).
      *
      * @param key <code>key</code> whose associated value is to be returned as a
      *        <code>std::vector<char></code> object.
      * @param def the value to be returned in the event that this node has no
      *        value associated with <code>key</code> or the associated value
      *        cannot be interpreted as a <code>std::vector<char></code> type, or the backing
      *        store is inaccessible.
      * @return the <code>std::vector<char></code> value represented by the <code>QString</code>
      *         object associated with <code>key</code> in this node, or
      *         <code>def</code> if the associated value does not exist or cannot
      *         be interpreted as a <code>std::vector<char></code>.
      * @throws NullPointerException if <code>key</code> is <code>null</code>. (A
      *         <code>null</code> value for <code>def</code> <i>is </i> permitted.)
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #Get
      * @see #PutByteArray
      */
     virtual QByteArray GetByteArray(const QString& key, const QByteArray& def) const = 0;
 
     /**
      * Returns all of the keys that have an associated value in this node. (The
      * returned array will be of size zero if this node has no preferences and
      * not <code>null</code>!)
      *
      * @return an array of the keys that have an associated value in this node.
      * @throws BackingStoreException if this operation cannot be completed due
      *         to a failure in the backing store, or inability to communicate
      *         with it.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      */
     virtual QStringList Keys() const = 0;
 
     /**
      * Returns the names of the children of this node. (The returned array will
      * be of size zero if this node has no children and not <code>null</code>!)
      *
      * @return the names of the children of this node.
      * @throws BackingStoreException if this operation cannot be completed due
      *         to a failure in the backing store, or inability to communicate
      *         with it.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      */
     virtual QStringList ChildrenNames() const = 0;
 
     /**
      * Returns the parent of this node, or <code>null</code> if this is the root.
      *
      * @return the parent of this node.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      */
     virtual IPreferences::Pointer Parent() const = 0;
 
     /**
      * Returns a named <code>IPreferences</code> object (node), creating it and any
      * of its ancestors if they do not already exist. Accepts a relative or
      * absolute pathname. Absolute pathnames (which begin with <code>'/'</code>)
      * are interpreted relative to the root of this node. Relative pathnames
      * (which begin with any character other than <code>'/'</code>) are
      * interpreted relative to this node itself. The empty string (<code>""</code>)
      * is a valid relative pathname, referring to this node itself.
      *
      * <p>
      * If the returned node did not exist prior to this call, this node and any
      * ancestors that were created by this call are not guaranteed to become
      * persistent until the <code>flush</code> method is called on the returned
      * node (or one of its descendants).
      *
      * @param pathName the path name of the <code>IPreferences</code> object to
      *        return.
      * @return the specified <code>IPreferences</code> object.
      * @throws IllegalArgumentException if the path name is invalid.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @throws NullPointerException if path name is <code>null</code>.
      * @see #Flush()
      */
     virtual IPreferences::Pointer Node(const QString& pathName) = 0;
 
     /**
      * Returns true if the named node exists. Accepts a relative or absolute
      * pathname. Absolute pathnames (which begin with <code>'/'</code>) are
      * interpreted relative to the root of this node. Relative pathnames (which
      * begin with any character other than <code>'/'</code>) are interpreted
      * relative to this node itself. The pathname <code>""</code> is valid, and
      * refers to this node itself.
      *
      * <p>
      * If this node (or an ancestor) has already been removed with the
      * {@link #Remove()}method, it <i>is </i> legal to invoke this method,
      * but only with the pathname <code>""</code>; the invocation will return
      * <code>false</code>. Thus, the idiom <code>p.nodeExists("")</code> may be
      * used to test whether <code>p</code> has been removed.
      *
      * @param pathName the path name of the node whose existence is to be
      *        checked.
      * @return true if the specified node exists.
      * @throws BackingStoreException if this operation cannot be completed due
      *         to a failure in the backing store, or inability to communicate
      *         with it.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method and
      *         <code>pathname</code> is not the empty string (<code>""</code>).
      * @throws IllegalArgumentException if the path name is invalid (i.e., it
      *         contains multiple consecutive slash characters, or ends with a
      *         slash character and is more than one character long).
      */
     virtual bool NodeExists(const QString& pathName) const = 0;
 
     /**
      * Removes this node and all of its descendants, invalidating any properties
      * contained in the removed nodes. Once a node has been removed, attempting
      * any method other than <code>name()</code>,<code>absolutePath()</code> or
      * <code>nodeExists("")</code> on the corresponding <code>IPreferences</code>
      * instance will fail with an <code>IllegalStateException</code>. (The
      * methods defined on <code>Object</code> can still be invoked on a node after
      * it has been removed; they will not throw <code>IllegalStateException</code>.)
      *
      * <p>
      * The removal is not guaranteed to be persistent until the <code>flush</code>
      * method is called on the parent of this node.
      *
      * @throws IllegalStateException if this node (or an ancestor) has already
      *         been removed with the {@link #Remove()}method.
      * @throws BackingStoreException if this operation cannot be completed due
      *         to a failure in the backing store, or inability to communicate
      *         with it.
      * @see #Flush()
      */
     virtual void RemoveNode() = 0;
 
     /**
      * Returns this node's name, relative to its parent.
      *
      * @return this node's name, relative to its parent.
      */
     virtual QString Name() const = 0;
 
     /**
      * Returns this node's absolute path name. Note that:
      * <ul>
      * <li>Root node - The path name of the root node is <code>"/"</code>.
      * <li>Slash at end - Path names other than that of the root node may not
      * end in slash (<code>'/'</code>).
      * <li>Unusual names -<code>"."</code> and <code>".."</code> have <i>no </i>
      * special significance in path names.
      * <li>Illegal names - The only illegal path names are those that contain
      * multiple consecutive slashes, or that end in slash and are not the root.
      * </ul>
      *
      * @return this node's absolute path name.
      */
     virtual QString AbsolutePath() const = 0;
 
     /**
      * Forces any changes in the contents of this node and its descendants to
      * the persistent store.
      *
      * <p>
      * Once this method returns successfully, it is safe to assume that all
      * changes made in the subtree rooted at this node prior to the method
      * invocation have become permanent.
      *
      * <p>
      * Implementations are free to flush changes into the persistent store at
      * any time. They do not need to wait for this method to be called.
      *
      * <p>
      * When a flush occurs on a newly created node, it is made persistent, as
      * are any ancestors (and descendants) that have yet to be made persistent.
      * Note however that any properties value changes in ancestors are <i>not
      * </i> guaranteed to be made persistent.
      *
      * @throws BackingStoreException if this operation cannot be completed due
      *         to a failure in the backing store, or inability to communicate
      *         with it.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #Sync()
      */
     virtual void Flush() = 0;
 
     /**
      * Ensures that future reads from this node and its descendants reflect any
      * changes that were committed to the persistent store (from any VM) prior
      * to the <code>sync</code> invocation. As a side-effect, forces any changes
      * in the contents of this node and its descendants to the persistent store,
      * as if the <code>flush</code> method had been invoked on this node.
      *
      * @throws BackingStoreException if this operation cannot be completed due
      *         to a failure in the backing store, or inability to communicate
      *         with it.
      * @throws IllegalStateException if this node (or an ancestor) has been
      *         removed with the {@link #Remove()}method.
      * @see #Flush()
      */
     virtual void Sync() = 0;
 
     /**
     * Sets a flag to the parameter <code>block</code> which can be used to
     * block berry messages in order to prevent callback functions to be called.
     *
     * @param block boolean to set the flag
     */
     virtual void BlockSignals(bool block) = 0;
   };
 
 }  // namespace berry
 
 #endif /*BERRYIPREFERENCES_H_*/
diff --git a/Plugins/org.blueberry.ui.qt.help/manifest_headers.cmake b/Plugins/org.blueberry.ui.qt.help/manifest_headers.cmake
index c6e771bee6..c048aca4b9 100644
--- a/Plugins/org.blueberry.ui.qt.help/manifest_headers.cmake
+++ b/Plugins/org.blueberry.ui.qt.help/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "BlueBerry Help Plugin")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.ui.qt)
 
diff --git a/Plugins/org.blueberry.ui.qt.log/manifest_headers.cmake b/Plugins/org.blueberry.ui.qt.log/manifest_headers.cmake
index 90cd70804d..2951d1e717 100644
--- a/Plugins/org.blueberry.ui.qt.log/manifest_headers.cmake
+++ b/Plugins/org.blueberry.ui.qt.log/manifest_headers.cmake
@@ -1,7 +1,7 @@
 set(Plugin-Name "BlueBerry Log Bundle")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.ui.qt)
 set(Plugin-ActivationPolicy "eager")
 
diff --git a/Plugins/org.blueberry.ui.qt.objectinspector/manifest_headers.cmake b/Plugins/org.blueberry.ui.qt.objectinspector/manifest_headers.cmake
index c85e761ac5..edc14d0ace 100644
--- a/Plugins/org.blueberry.ui.qt.objectinspector/manifest_headers.cmake
+++ b/Plugins/org.blueberry.ui.qt.objectinspector/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "BlueBerry Object Inspector")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.ui.qt)
 
diff --git a/Plugins/org.blueberry.ui.qt/manifest_headers.cmake b/Plugins/org.blueberry.ui.qt/manifest_headers.cmake
index 38cfc39534..15cf6c2f8e 100644
--- a/Plugins/org.blueberry.ui.qt/manifest_headers.cmake
+++ b/Plugins/org.blueberry.ui.qt/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "BlueBerry Qt User Interface Plugin")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.core.commands org.blueberry.core.expressions)
 
diff --git a/Plugins/org.blueberry.ui.qt/resources/fonts/FiraSans/OFL.txt b/Plugins/org.blueberry.ui.qt/resources/fonts/FiraSans/OFL.txt
index 4f9e17ed29..0c7c7c57bc 100644
--- a/Plugins/org.blueberry.ui.qt/resources/fonts/FiraSans/OFL.txt
+++ b/Plugins/org.blueberry.ui.qt/resources/fonts/FiraSans/OFL.txt
@@ -1,92 +1,92 @@
 Copyright (c) 2012-2015, The Mozilla Foundation and Telefonica S.A.
 This Font Software is licensed under the SIL Open Font License, Version 1.1.
 This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
+https://scripts.sil.org/OFL
 
 
 -----------------------------------------------------------
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
 -----------------------------------------------------------
 
 PREAMBLE
 The goals of the Open Font License (OFL) are to stimulate worldwide
 development of collaborative font projects, to support the font creation
 efforts of academic and linguistic communities, and to provide a free and
 open framework in which fonts may be shared and improved in partnership
 with others.
 
 The OFL allows the licensed fonts to be used, studied, modified and
 redistributed freely as long as they are not sold by themselves. The
 fonts, including any derivative works, can be bundled, embedded, 
 redistributed and/or sold with any software provided that any reserved
 names are not used by derivative works. The fonts and derivatives,
 however, cannot be released under any other type of license. The
 requirement for fonts to remain under this license does not apply
 to any document created using the fonts or their derivatives.
 
 DEFINITIONS
 "Font Software" refers to the set of files released by the Copyright
 Holder(s) under this license and clearly marked as such. This may
 include source files, build scripts and documentation.
 
 "Reserved Font Name" refers to any names specified as such after the
 copyright statement(s).
 
 "Original Version" refers to the collection of Font Software components as
 distributed by the Copyright Holder(s).
 
 "Modified Version" refers to any derivative made by adding to, deleting,
 or substituting -- in part or in whole -- any of the components of the
 Original Version, by changing formats or by porting the Font Software to a
 new environment.
 
 "Author" refers to any designer, engineer, programmer, technical
 writer or other person who contributed to the Font Software.
 
 PERMISSION & CONDITIONS
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of the Font Software, to use, study, copy, merge, embed, modify,
 redistribute, and sell modified and unmodified copies of the Font
 Software, subject to the following conditions:
 
 1) Neither the Font Software nor any of its individual components,
 in Original or Modified Versions, may be sold by itself.
 
 2) Original or Modified Versions of the Font Software may be bundled,
 redistributed and/or sold with any software, provided that each copy
 contains the above copyright notice and this license. These can be
 included either as stand-alone text files, human-readable headers or
 in the appropriate machine-readable metadata fields within text or
 binary files as long as those fields can be easily viewed by the user.
 
 3) No Modified Version of the Font Software may use the Reserved Font
 Name(s) unless explicit written permission is granted by the corresponding
 Copyright Holder. This restriction only applies to the primary font name as
 presented to the users.
 
 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
 Software shall not be used to promote, endorse or advertise any
 Modified Version, except to acknowledge the contribution(s) of the
 Copyright Holder(s) and the Author(s) or with their explicit written
 permission.
 
 5) The Font Software, modified or unmodified, in part or in whole,
 must be distributed entirely under this license, and must not be
 distributed under any other license. The requirement for fonts to
 remain under this license does not apply to any document created
 using the Font Software.
 
 TERMINATION
 This license becomes null and void if any of the above conditions are
 not met.
 
 DISCLAIMER
 THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
 OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
 COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
 OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/Plugins/org.blueberry.ui.qt/resources/fonts/LightFiraSans/OFL.txt b/Plugins/org.blueberry.ui.qt/resources/fonts/LightFiraSans/OFL.txt
index 4f9e17ed29..0c7c7c57bc 100644
--- a/Plugins/org.blueberry.ui.qt/resources/fonts/LightFiraSans/OFL.txt
+++ b/Plugins/org.blueberry.ui.qt/resources/fonts/LightFiraSans/OFL.txt
@@ -1,92 +1,92 @@
 Copyright (c) 2012-2015, The Mozilla Foundation and Telefonica S.A.
 This Font Software is licensed under the SIL Open Font License, Version 1.1.
 This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
+https://scripts.sil.org/OFL
 
 
 -----------------------------------------------------------
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
 -----------------------------------------------------------
 
 PREAMBLE
 The goals of the Open Font License (OFL) are to stimulate worldwide
 development of collaborative font projects, to support the font creation
 efforts of academic and linguistic communities, and to provide a free and
 open framework in which fonts may be shared and improved in partnership
 with others.
 
 The OFL allows the licensed fonts to be used, studied, modified and
 redistributed freely as long as they are not sold by themselves. The
 fonts, including any derivative works, can be bundled, embedded, 
 redistributed and/or sold with any software provided that any reserved
 names are not used by derivative works. The fonts and derivatives,
 however, cannot be released under any other type of license. The
 requirement for fonts to remain under this license does not apply
 to any document created using the fonts or their derivatives.
 
 DEFINITIONS
 "Font Software" refers to the set of files released by the Copyright
 Holder(s) under this license and clearly marked as such. This may
 include source files, build scripts and documentation.
 
 "Reserved Font Name" refers to any names specified as such after the
 copyright statement(s).
 
 "Original Version" refers to the collection of Font Software components as
 distributed by the Copyright Holder(s).
 
 "Modified Version" refers to any derivative made by adding to, deleting,
 or substituting -- in part or in whole -- any of the components of the
 Original Version, by changing formats or by porting the Font Software to a
 new environment.
 
 "Author" refers to any designer, engineer, programmer, technical
 writer or other person who contributed to the Font Software.
 
 PERMISSION & CONDITIONS
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of the Font Software, to use, study, copy, merge, embed, modify,
 redistribute, and sell modified and unmodified copies of the Font
 Software, subject to the following conditions:
 
 1) Neither the Font Software nor any of its individual components,
 in Original or Modified Versions, may be sold by itself.
 
 2) Original or Modified Versions of the Font Software may be bundled,
 redistributed and/or sold with any software, provided that each copy
 contains the above copyright notice and this license. These can be
 included either as stand-alone text files, human-readable headers or
 in the appropriate machine-readable metadata fields within text or
 binary files as long as those fields can be easily viewed by the user.
 
 3) No Modified Version of the Font Software may use the Reserved Font
 Name(s) unless explicit written permission is granted by the corresponding
 Copyright Holder. This restriction only applies to the primary font name as
 presented to the users.
 
 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
 Software shall not be used to promote, endorse or advertise any
 Modified Version, except to acknowledge the contribution(s) of the
 Copyright Holder(s) and the Author(s) or with their explicit written
 permission.
 
 5) The Font Software, modified or unmodified, in part or in whole,
 must be distributed entirely under this license, and must not be
 distributed under any other license. The requirement for fonts to
 remain under this license does not apply to any document created
 using the Font Software.
 
 TERMINATION
 This license becomes null and void if any of the above conditions are
 not met.
 
 DISCLAIMER
 THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
 OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
 COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
 OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/Plugins/org.blueberry.ui.qt/resources/fonts/Roboto/LICENSE.txt b/Plugins/org.blueberry.ui.qt/resources/fonts/Roboto/LICENSE.txt
index 75b52484ea..a082ed2191 100644
--- a/Plugins/org.blueberry.ui.qt/resources/fonts/Roboto/LICENSE.txt
+++ b/Plugins/org.blueberry.ui.qt/resources/fonts/Roboto/LICENSE.txt
@@ -1,202 +1,202 @@
 
                                  Apache License
                            Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+                        https://www.apache.org/licenses/
 
    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
    1. Definitions.
 
       "License" shall mean the terms and conditions for use, reproduction,
       and distribution as defined by Sections 1 through 9 of this document.
 
       "Licensor" shall mean the copyright owner or entity authorized by
       the copyright owner that is granting the License.
 
       "Legal Entity" shall mean the union of the acting entity and all
       other entities that control, are controlled by, or are under common
       control with that entity. For the purposes of this definition,
       "control" means (i) the power, direct or indirect, to cause the
       direction or management of such entity, whether by contract or
       otherwise, or (ii) ownership of fifty percent (50%) or more of the
       outstanding shares, or (iii) beneficial ownership of such entity.
 
       "You" (or "Your") shall mean an individual or Legal Entity
       exercising permissions granted by this License.
 
       "Source" form shall mean the preferred form for making modifications,
       including but not limited to software source code, documentation
       source, and configuration files.
 
       "Object" form shall mean any form resulting from mechanical
       transformation or translation of a Source form, including but
       not limited to compiled object code, generated documentation,
       and conversions to other media types.
 
       "Work" shall mean the work of authorship, whether in Source or
       Object form, made available under the License, as indicated by a
       copyright notice that is included in or attached to the work
       (an example is provided in the Appendix below).
 
       "Derivative Works" shall mean any work, whether in Source or Object
       form, that is based on (or derived from) the Work and for which the
       editorial revisions, annotations, elaborations, or other modifications
       represent, as a whole, an original work of authorship. For the purposes
       of this License, Derivative Works shall not include works that remain
       separable from, or merely link (or bind by name) to the interfaces of,
       the Work and Derivative Works thereof.
 
       "Contribution" shall mean any work of authorship, including
       the original version of the Work and any modifications or additions
       to that Work or Derivative Works thereof, that is intentionally
       submitted to Licensor for inclusion in the Work by the copyright owner
       or by an individual or Legal Entity authorized to submit on behalf of
       the copyright owner. For the purposes of this definition, "submitted"
       means any form of electronic, verbal, or written communication sent
       to the Licensor or its representatives, including but not limited to
       communication on electronic mailing lists, source code control systems,
       and issue tracking systems that are managed by, or on behalf of, the
       Licensor for the purpose of discussing and improving the Work, but
       excluding communication that is conspicuously marked or otherwise
       designated in writing by the copyright owner as "Not a Contribution."
 
       "Contributor" shall mean Licensor and any individual or Legal Entity
       on behalf of whom a Contribution has been received by Licensor and
       subsequently incorporated within the Work.
 
    2. Grant of Copyright License. Subject to the terms and conditions of
       this License, each Contributor hereby grants to You a perpetual,
       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
       copyright license to reproduce, prepare Derivative Works of,
       publicly display, publicly perform, sublicense, and distribute the
       Work and such Derivative Works in Source or Object form.
 
    3. Grant of Patent License. Subject to the terms and conditions of
       this License, each Contributor hereby grants to You a perpetual,
       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
       (except as stated in this section) patent license to make, have made,
       use, offer to sell, sell, import, and otherwise transfer the Work,
       where such license applies only to those patent claims licensable
       by such Contributor that are necessarily infringed by their
       Contribution(s) alone or by combination of their Contribution(s)
       with the Work to which such Contribution(s) was submitted. If You
       institute patent litigation against any entity (including a
       cross-claim or counterclaim in a lawsuit) alleging that the Work
       or a Contribution incorporated within the Work constitutes direct
       or contributory patent infringement, then any patent licenses
       granted to You under this License for that Work shall terminate
       as of the date such litigation is filed.
 
    4. Redistribution. You may reproduce and distribute copies of the
       Work or Derivative Works thereof in any medium, with or without
       modifications, and in Source or Object form, provided that You
       meet the following conditions:
 
       (a) You must give any other recipients of the Work or
           Derivative Works a copy of this License; and
 
       (b) You must cause any modified files to carry prominent notices
           stating that You changed the files; and
 
       (c) You must retain, in the Source form of any Derivative Works
           that You distribute, all copyright, patent, trademark, and
           attribution notices from the Source form of the Work,
           excluding those notices that do not pertain to any part of
           the Derivative Works; and
 
       (d) If the Work includes a "NOTICE" text file as part of its
           distribution, then any Derivative Works that You distribute must
           include a readable copy of the attribution notices contained
           within such NOTICE file, excluding those notices that do not
           pertain to any part of the Derivative Works, in at least one
           of the following places: within a NOTICE text file distributed
           as part of the Derivative Works; within the Source form or
           documentation, if provided along with the Derivative Works; or,
           within a display generated by the Derivative Works, if and
           wherever such third-party notices normally appear. The contents
           of the NOTICE file are for informational purposes only and
           do not modify the License. You may add Your own attribution
           notices within Derivative Works that You distribute, alongside
           or as an addendum to the NOTICE text from the Work, provided
           that such additional attribution notices cannot be construed
           as modifying the License.
 
       You may add Your own copyright statement to Your modifications and
       may provide additional or different license terms and conditions
       for use, reproduction, or distribution of Your modifications, or
       for any such Derivative Works as a whole, provided Your use,
       reproduction, and distribution of the Work otherwise complies with
       the conditions stated in this License.
 
    5. Submission of Contributions. Unless You explicitly state otherwise,
       any Contribution intentionally submitted for inclusion in the Work
       by You to the Licensor shall be under the terms and conditions of
       this License, without any additional terms or conditions.
       Notwithstanding the above, nothing herein shall supersede or modify
       the terms of any separate license agreement you may have executed
       with Licensor regarding such Contributions.
 
    6. Trademarks. This License does not grant permission to use the trade
       names, trademarks, service marks, or product names of the Licensor,
       except as required for reasonable and customary use in describing the
       origin of the Work and reproducing the content of the NOTICE file.
 
    7. Disclaimer of Warranty. Unless required by applicable law or
       agreed to in writing, Licensor provides the Work (and each
       Contributor provides its Contributions) on an "AS IS" BASIS,
       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
       implied, including, without limitation, any warranties or conditions
       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
       PARTICULAR PURPOSE. You are solely responsible for determining the
       appropriateness of using or redistributing the Work and assume any
       risks associated with Your exercise of permissions under this License.
 
    8. Limitation of Liability. In no event and under no legal theory,
       whether in tort (including negligence), contract, or otherwise,
       unless required by applicable law (such as deliberate and grossly
       negligent acts) or agreed to in writing, shall any Contributor be
       liable to You for damages, including any direct, indirect, special,
       incidental, or consequential damages of any character arising as a
       result of this License or out of the use or inability to use the
       Work (including but not limited to damages for loss of goodwill,
       work stoppage, computer failure or malfunction, or any and all
       other commercial damages or losses), even if such Contributor
       has been advised of the possibility of such damages.
 
    9. Accepting Warranty or Additional Liability. While redistributing
       the Work or Derivative Works thereof, You may choose to offer,
       and charge a fee for, acceptance of support, warranty, indemnity,
       or other liability obligations and/or rights consistent with this
       License. However, in accepting such obligations, You may act only
       on Your own behalf and on Your sole responsibility, not on behalf
       of any other Contributor, and only if You agree to indemnify,
       defend, and hold each Contributor harmless for any liability
       incurred by, or claims asserted against, such Contributor by reason
       of your accepting any such warranty or additional liability.
 
    END OF TERMS AND CONDITIONS
 
    APPENDIX: How to apply the Apache License to your work.
 
       To apply the Apache License to your work, attach the following
       boilerplate notice, with the fields enclosed by brackets "[]"
       replaced with your own identifying information. (Don't include
       the brackets!)  The text should be enclosed in the appropriate
       comment syntax for the file format. We also recommend that a
       file or class name and description of purpose be included on the
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
    Copyright [yyyy] [name of copyright owner]
 
    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
+       https://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.
diff --git a/Plugins/org.blueberry.ui.qt/resources/fonts/xkcd/license.txt b/Plugins/org.blueberry.ui.qt/resources/fonts/xkcd/license.txt
index 7f182a3bf3..d5b08b15c3 100644
--- a/Plugins/org.blueberry.ui.qt/resources/fonts/xkcd/license.txt
+++ b/Plugins/org.blueberry.ui.qt/resources/fonts/xkcd/license.txt
@@ -1,335 +1,335 @@
 Creative Commons Legal Code
 
 Attribution-NonCommercial 3.0 Unported
 
     CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
     LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN
     ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
     INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
     REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR
     DAMAGES RESULTING FROM ITS USE.
 
 License
 
 THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE
 COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS PROTECTED BY
 COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS
 AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.
 
 BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE
 TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY
 BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS
 CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND
 CONDITIONS.
 
 1. Definitions
 
  a. "Adaptation" means a work based upon the Work, or upon the Work and
     other pre-existing works, such as a translation, adaptation,
     derivative work, arrangement of music or other alterations of a
     literary or artistic work, or phonogram or performance and includes
     cinematographic adaptations or any other form in which the Work may be
     recast, transformed, or adapted including in any form recognizably
     derived from the original, except that a work that constitutes a
     Collection will not be considered an Adaptation for the purpose of
     this License. For the avoidance of doubt, where the Work is a musical
     work, performance or phonogram, the synchronization of the Work in
     timed-relation with a moving image ("synching") will be considered an
     Adaptation for the purpose of this License.
  b. "Collection" means a collection of literary or artistic works, such as
     encyclopedias and anthologies, or performances, phonograms or
     broadcasts, or other works or subject matter other than works listed
     in Section 1(f) below, which, by reason of the selection and
     arrangement of their contents, constitute intellectual creations, in
     which the Work is included in its entirety in unmodified form along
     with one or more other contributions, each constituting separate and
     independent works in themselves, which together are assembled into a
     collective whole. A work that constitutes a Collection will not be
     considered an Adaptation (as defined above) for the purposes of this
     License.
  c. "Distribute" means to make available to the public the original and
     copies of the Work or Adaptation, as appropriate, through sale or
     other transfer of ownership.
  d. "Licensor" means the individual, individuals, entity or entities that
     offer(s) the Work under the terms of this License.
  e. "Original Author" means, in the case of a literary or artistic work,
     the individual, individuals, entity or entities who created the Work
     or if no individual or entity can be identified, the publisher; and in
     addition (i) in the case of a performance the actors, singers,
     musicians, dancers, and other persons who act, sing, deliver, declaim,
     play in, interpret or otherwise perform literary or artistic works or
     expressions of folklore; (ii) in the case of a phonogram the producer
     being the person or legal entity who first fixes the sounds of a
     performance or other sounds; and, (iii) in the case of broadcasts, the
     organization that transmits the broadcast.
  f. "Work" means the literary and/or artistic work offered under the terms
     of this License including without limitation any production in the
     literary, scientific and artistic domain, whatever may be the mode or
     form of its expression including digital form, such as a book,
     pamphlet and other writing; a lecture, address, sermon or other work
     of the same nature; a dramatic or dramatico-musical work; a
     choreographic work or entertainment in dumb show; a musical
     composition with or without words; a cinematographic work to which are
     assimilated works expressed by a process analogous to cinematography;
     a work of drawing, painting, architecture, sculpture, engraving or
     lithography; a photographic work to which are assimilated works
     expressed by a process analogous to photography; a work of applied
     art; an illustration, map, plan, sketch or three-dimensional work
     relative to geography, topography, architecture or science; a
     performance; a broadcast; a phonogram; a compilation of data to the
     extent it is protected as a copyrightable work; or a work performed by
     a variety or circus performer to the extent it is not otherwise
     considered a literary or artistic work.
  g. "You" means an individual or entity exercising rights under this
     License who has not previously violated the terms of this License with
     respect to the Work, or who has received express permission from the
     Licensor to exercise rights under this License despite a previous
     violation.
  h. "Publicly Perform" means to perform public recitations of the Work and
     to communicate to the public those public recitations, by any means or
     process, including by wire or wireless means or public digital
     performances; to make available to the public Works in such a way that
     members of the public may access these Works from a place and at a
     place individually chosen by them; to perform the Work to the public
     by any means or process and the communication to the public of the
     performances of the Work, including by public digital performance; to
     broadcast and rebroadcast the Work by any means including signs,
     sounds or images.
  i. "Reproduce" means to make copies of the Work by any means including
     without limitation by sound or visual recordings and the right of
     fixation and reproducing fixations of the Work, including storage of a
     protected performance or phonogram in digital form or other electronic
     medium.
 
 2. Fair Dealing Rights. Nothing in this License is intended to reduce,
 limit, or restrict any uses free from copyright or rights arising from
 limitations or exceptions that are provided for in connection with the
 copyright protection under copyright law or other applicable laws.
 
 3. License Grant. Subject to the terms and conditions of this License,
 Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
 perpetual (for the duration of the applicable copyright) license to
 exercise the rights in the Work as stated below:
 
  a. to Reproduce the Work, to incorporate the Work into one or more
     Collections, and to Reproduce the Work as incorporated in the
     Collections;
  b. to create and Reproduce Adaptations provided that any such Adaptation,
     including any translation in any medium, takes reasonable steps to
     clearly label, demarcate or otherwise identify that changes were made
     to the original Work. For example, a translation could be marked "The
     original work was translated from English to Spanish," or a
     modification could indicate "The original work has been modified.";
  c. to Distribute and Publicly Perform the Work including as incorporated
     in Collections; and,
  d. to Distribute and Publicly Perform Adaptations.
 
 The above rights may be exercised in all media and formats whether now
 known or hereafter devised. The above rights include the right to make
 such modifications as are technically necessary to exercise the rights in
 other media and formats. Subject to Section 8(f), all rights not expressly
 granted by Licensor are hereby reserved, including but not limited to the
 rights set forth in Section 4(d).
 
 4. Restrictions. The license granted in Section 3 above is expressly made
 subject to and limited by the following restrictions:
 
  a. You may Distribute or Publicly Perform the Work only under the terms
     of this License. You must include a copy of, or the Uniform Resource
     Identifier (URI) for, this License with every copy of the Work You
     Distribute or Publicly Perform. You may not offer or impose any terms
     on the Work that restrict the terms of this License or the ability of
     the recipient of the Work to exercise the rights granted to that
     recipient under the terms of the License. You may not sublicense the
     Work. You must keep intact all notices that refer to this License and
     to the disclaimer of warranties with every copy of the Work You
     Distribute or Publicly Perform. When You Distribute or Publicly
     Perform the Work, You may not impose any effective technological
     measures on the Work that restrict the ability of a recipient of the
     Work from You to exercise the rights granted to that recipient under
     the terms of the License. This Section 4(a) applies to the Work as
     incorporated in a Collection, but this does not require the Collection
     apart from the Work itself to be made subject to the terms of this
     License. If You create a Collection, upon notice from any Licensor You
     must, to the extent practicable, remove from the Collection any credit
     as required by Section 4(c), as requested. If You create an
     Adaptation, upon notice from any Licensor You must, to the extent
     practicable, remove from the Adaptation any credit as required by
     Section 4(c), as requested.
  b. You may not exercise any of the rights granted to You in Section 3
     above in any manner that is primarily intended for or directed toward
     commercial advantage or private monetary compensation. The exchange of
     the Work for other copyrighted works by means of digital file-sharing
     or otherwise shall not be considered to be intended for or directed
     toward commercial advantage or private monetary compensation, provided
     there is no payment of any monetary compensation in connection with
     the exchange of copyrighted works.
  c. If You Distribute, or Publicly Perform the Work or any Adaptations or
     Collections, You must, unless a request has been made pursuant to
     Section 4(a), keep intact all copyright notices for the Work and
     provide, reasonable to the medium or means You are utilizing: (i) the
     name of the Original Author (or pseudonym, if applicable) if supplied,
     and/or if the Original Author and/or Licensor designate another party
     or parties (e.g., a sponsor institute, publishing entity, journal) for
     attribution ("Attribution Parties") in Licensor's copyright notice,
     terms of service or by other reasonable means, the name of such party
     or parties; (ii) the title of the Work if supplied; (iii) to the
     extent reasonably practicable, the URI, if any, that Licensor
     specifies to be associated with the Work, unless such URI does not
     refer to the copyright notice or licensing information for the Work;
     and, (iv) consistent with Section 3(b), in the case of an Adaptation,
     a credit identifying the use of the Work in the Adaptation (e.g.,
     "French translation of the Work by Original Author," or "Screenplay
     based on original Work by Original Author"). The credit required by
     this Section 4(c) may be implemented in any reasonable manner;
     provided, however, that in the case of a Adaptation or Collection, at
     a minimum such credit will appear, if a credit for all contributing
     authors of the Adaptation or Collection appears, then as part of these
     credits and in a manner at least as prominent as the credits for the
     other contributing authors. For the avoidance of doubt, You may only
     use the credit required by this Section for the purpose of attribution
     in the manner set out above and, by exercising Your rights under this
     License, You may not implicitly or explicitly assert or imply any
     connection with, sponsorship or endorsement by the Original Author,
     Licensor and/or Attribution Parties, as appropriate, of You or Your
     use of the Work, without the separate, express prior written
     permission of the Original Author, Licensor and/or Attribution
     Parties.
  d. For the avoidance of doubt:
 
      i. Non-waivable Compulsory License Schemes. In those jurisdictions in
         which the right to collect royalties through any statutory or
         compulsory licensing scheme cannot be waived, the Licensor
         reserves the exclusive right to collect such royalties for any
         exercise by You of the rights granted under this License;
     ii. Waivable Compulsory License Schemes. In those jurisdictions in
         which the right to collect royalties through any statutory or
         compulsory licensing scheme can be waived, the Licensor reserves
         the exclusive right to collect such royalties for any exercise by
         You of the rights granted under this License if Your exercise of
         such rights is for a purpose or use which is otherwise than
         noncommercial as permitted under Section 4(b) and otherwise waives
         the right to collect royalties through any statutory or compulsory
         licensing scheme; and,
    iii. Voluntary License Schemes. The Licensor reserves the right to
         collect royalties, whether individually or, in the event that the
         Licensor is a member of a collecting society that administers
         voluntary licensing schemes, via that society, from any exercise
         by You of the rights granted under this License that is for a
         purpose or use which is otherwise than noncommercial as permitted
         under Section 4(c).
  e. Except as otherwise agreed in writing by the Licensor or as may be
     otherwise permitted by applicable law, if You Reproduce, Distribute or
     Publicly Perform the Work either by itself or as part of any
     Adaptations or Collections, You must not distort, mutilate, modify or
     take other derogatory action in relation to the Work which would be
     prejudicial to the Original Author's honor or reputation. Licensor
     agrees that in those jurisdictions (e.g. Japan), in which any exercise
     of the right granted in Section 3(b) of this License (the right to
     make Adaptations) would be deemed to be a distortion, mutilation,
     modification or other derogatory action prejudicial to the Original
     Author's honor and reputation, the Licensor will waive or not assert,
     as appropriate, this Section, to the fullest extent permitted by the
     applicable national law, to enable You to reasonably exercise Your
     right under Section 3(b) of this License (right to make Adaptations)
     but not otherwise.
 
 5. Representations, Warranties and Disclaimer
 
 UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR
 OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY
 KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE,
 INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY,
 FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF
 LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS,
 WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION
 OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.
 
 6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE
 LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR
 ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES
 ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS
 BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 
 7. Termination
 
  a. This License and the rights granted hereunder will terminate
     automatically upon any breach by You of the terms of this License.
     Individuals or entities who have received Adaptations or Collections
     from You under this License, however, will not have their licenses
     terminated provided such individuals or entities remain in full
     compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will
     survive any termination of this License.
  b. Subject to the above terms and conditions, the license granted here is
     perpetual (for the duration of the applicable copyright in the Work).
     Notwithstanding the above, Licensor reserves the right to release the
     Work under different license terms or to stop distributing the Work at
     any time; provided, however that any such election will not serve to
     withdraw this License (or any other license that has been, or is
     required to be, granted under the terms of this License), and this
     License will continue in full force and effect unless terminated as
     stated above.
 
 8. Miscellaneous
 
  a. Each time You Distribute or Publicly Perform the Work or a Collection,
     the Licensor offers to the recipient a license to the Work on the same
     terms and conditions as the license granted to You under this License.
  b. Each time You Distribute or Publicly Perform an Adaptation, Licensor
     offers to the recipient a license to the original Work on the same
     terms and conditions as the license granted to You under this License.
  c. If any provision of this License is invalid or unenforceable under
     applicable law, it shall not affect the validity or enforceability of
     the remainder of the terms of this License, and without further action
     by the parties to this agreement, such provision shall be reformed to
     the minimum extent necessary to make such provision valid and
     enforceable.
  d. No term or provision of this License shall be deemed waived and no
     breach consented to unless such waiver or consent shall be in writing
     and signed by the party to be charged with such waiver or consent.
  e. This License constitutes the entire agreement between the parties with
     respect to the Work licensed here. There are no understandings,
     agreements or representations with respect to the Work not specified
     here. Licensor shall not be bound by any additional provisions that
     may appear in any communication from You. This License may not be
     modified without the mutual written agreement of the Licensor and You.
  f. The rights granted under, and the subject matter referenced, in this
     License were drafted utilizing the terminology of the Berne Convention
     for the Protection of Literary and Artistic Works (as amended on
     September 28, 1979), the Rome Convention of 1961, the WIPO Copyright
     Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996
     and the Universal Copyright Convention (as revised on July 24, 1971).
     These rights and subject matter take effect in the relevant
     jurisdiction in which the License terms are sought to be enforced
     according to the corresponding provisions of the implementation of
     those treaty provisions in the applicable national law. If the
     standard suite of rights granted under applicable copyright law
     includes additional rights not granted under this License, such
     additional rights are deemed to be included in the License; this
     License is not intended to restrict the license of any rights under
     applicable law.
 
 
 Creative Commons Notice
 
     Creative Commons is not a party to this License, and makes no warranty
     whatsoever in connection with the Work. Creative Commons will not be
     liable to You or any party on any legal theory for any damages
     whatsoever, including without limitation any general, special,
     incidental or consequential damages arising in connection to this
     license. Notwithstanding the foregoing two (2) sentences, if Creative
     Commons has expressly identified itself as the Licensor hereunder, it
     shall have all rights and obligations of Licensor.
 
     Except for the limited purpose of indicating to the public that the
     Work is licensed under the CCPL, Creative Commons does not authorize
     the use by either party of the trademark "Creative Commons" or any
     related trademark or logo of Creative Commons without the prior
     written consent of Creative Commons. Any permitted use will be in
     compliance with Creative Commons' then-current trademark usage
     guidelines, as may be published on its website or otherwise made
     available upon request from time to time. For the avoidance of doubt,
     this trademark restriction does not form part of the License.
 
-    Creative Commons may be contacted at http://creativecommons.org/.
+    Creative Commons may be contacted at https://creativecommons.org/.
 
diff --git a/Plugins/org.blueberry.ui.qt/src/berryShellEvent.h b/Plugins/org.blueberry.ui.qt/src/berryShellEvent.h
index 8be2079d34..b887e1ecf4 100644
--- a/Plugins/org.blueberry.ui.qt/src/berryShellEvent.h
+++ b/Plugins/org.blueberry.ui.qt/src/berryShellEvent.h
@@ -1,64 +1,63 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef BERRYSHELLEVENT_H_
 #define BERRYSHELLEVENT_H_
 
 #include <org_blueberry_ui_qt_Export.h>
 
 #include <berryMacros.h>
 #include <berryObject.h>
 
 namespace berry {
 
 class Shell;
 
 /**
  * Instances of this class are sent as a result of
  * operations being performed on shells.
  *
  * @see ShellListener
- * @see <a href="http://www.blueberry.org/swt/">Sample code and further information</a>
  */
 
 class BERRY_UI_QT ShellEvent : public Object {
 
 public:
 
   berryObjectMacro(ShellEvent);
 
   /**
    * A flag indicating whether the operation should be allowed.
    * Setting this field to <code>false</code> will cancel the operation.
    */
   bool doit;
 
   /**
    * Constructs a new instance of this class based on the
    * information in the given untyped event.
    *
    * @param source the untyped event containing the information
    */
   ShellEvent(SmartPointer<Shell> source) ;
 
   SmartPointer<Shell> GetSource();
 
 private:
 
   SmartPointer<Shell> source;
 
 };
 
 }
 
 #endif /* BERRYSHELLEVENT_H_ */
diff --git a/Plugins/org.blueberry.ui.qt/src/guitk/berryGuiTkControlEvent.h b/Plugins/org.blueberry.ui.qt/src/guitk/berryGuiTkControlEvent.h
index 5d03be43c3..8e1a19f9a8 100755
--- a/Plugins/org.blueberry.ui.qt/src/guitk/berryGuiTkControlEvent.h
+++ b/Plugins/org.blueberry.ui.qt/src/guitk/berryGuiTkControlEvent.h
@@ -1,51 +1,50 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef BERRYGUITKCONTROLEVENT_H_
 #define BERRYGUITKCONTROLEVENT_H_
 
 #include "berryGuiTkEvent.h"
 
 namespace berry
 {
 
 namespace GuiTk
 {
 
 /**
  * Instances of this class are sent as a result of
  * controls being moved or resized.
  *
  * @see ControlListener
- * @see <a href="http://www.blueberry.org/swt/">Sample code and further information</a>
  */
 
 class BERRY_UI_QT ControlEvent: public Event
 {
 
 public:
 
   berryObjectMacro(ControlEvent);
 
 
 
   ControlEvent();
 
   ControlEvent(QWidget* item, int x = 0, int y = 0, int width = 0, int height = 0);
 
 };
 
 }
 
 }
 
 #endif /* BERRYGUITKCONTROLEVENT_H_ */
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryViewReference.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryViewReference.cpp
index fe216887c6..e06d7b0611 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryViewReference.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryViewReference.cpp
@@ -1,440 +1,440 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "berryViewReference.h"
 
 #include <berryIConfigurationElement.h>
 
 #include "berryUIException.h"
 #include "tweaklets/berryWorkbenchPageTweaklet.h"
 #include "berryPlatformUI.h"
 
 #include "berryWorkbenchPage.h"
 #include "berryWorkbenchConstants.h"
 #include "berryViewDescriptor.h"
 #include "berryViewFactory.h"
 #include "berryViewRegistry.h"
 #include "berryViewSite.h"
 #include "berryPartTester.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryErrorViewPart.h"
 
 namespace berry
 {
 
 ViewReference::ViewReference(ViewFactory* fac, const QString& id,
     const QString& secId, IMemento::Pointer m) :
   factory(fac), secondaryId(secId), memento(m)
 {
   ViewDescriptor::Pointer desc =
       this->factory->GetViewRegistry()->Find(id).Cast<ViewDescriptor> ();
   QIcon iDesc;
   QString title;
   if (!desc.IsNull())
   {
     iDesc = desc->GetImageDescriptor();
     title = desc->GetLabel();
   }
 
   QString name;
 
   if (!memento.IsNull())
   {
     //      name = memento.getString(IWorkbenchConstants.TAG_PART_NAME);
     //      IMemento propBag = memento.getChild(IWorkbenchConstants.TAG_PROPERTIES);
     //      if (propBag != null) {
     //        IMemento[] props = propBag
     //            .getChildren(IWorkbenchConstants.TAG_PROPERTY);
     //        for (int i = 0; i < props.length; i++) {
     //          propertyCache.put(props[i].getID(), props[i].getTextData());
     //        }
     //      }
   }
   if (name.isEmpty())
   {
     name = title;
   }
 
   this->Init(id, "", iDesc, name, ""); //$NON-NLS-1$//$NON-NLS-2$
 
 }
 
 void ViewReference::DoDisposePart()
 {
   IViewPart::Pointer view = part.Cast<IViewPart> ();
   //WorkbenchPartReference::DoDisposePart();
   if (!view.IsNull())
   {
     // Free action bars, pane, etc.
     //PartSite site = (PartSite) view.getSite();
     //ViewActionBars actionBars = (ViewActionBars) site.getActionBars();
     //
     // 3.3 start
     //
     //IMenuService menuService = (IMenuService) site
     //    .getService(IMenuService.class);
     //menuService.releaseContributions((ContributionManager) site.getActionBars()
     //    .getMenuManager());
     //menuService.releaseContributions((ContributionManager) site.getActionBars()
     //    .getToolBarManager());
     // 3.3 end
     //actionBars.dispose();
 
     // and now dispose the delegates since the
     // PluginActionContributionItem
     // can no longer do that
     //      if (actionBuilder != null) {
     //        actionBuilder.dispose();
     //        actionBuilder = null;
     //      }
 
     // Free the site.
     //site.dispose();
   }
 
 }
 
 IWorkbenchPage::Pointer ViewReference::GetPage() const
 {
   return IWorkbenchPage::Pointer(this->factory->GetWorkbenchPage());
 }
 
 QString ViewReference::GetRegisteredName()
 {
   if (!part.IsNull() && !part->GetSite().IsNull())
   {
     return part->GetSite()->GetRegisteredName();
   }
 
   const IViewRegistry* reg = this->factory->GetViewRegistry();
   IViewDescriptor::Pointer desc = reg->Find(this->GetId());
   if (!desc.IsNull())
   {
     return desc->GetLabel();
   }
   return this->GetPartName();
 }
 
 QString ViewReference::GetSecondaryId()
 {
   return secondaryId;
 }
 
 IViewPart::Pointer ViewReference::GetView(bool restore)
 {
   return this->GetPart(restore).Cast<IViewPart> ();
 }
 
 IWorkbenchPart::Pointer ViewReference::CreatePart()
 {
 
   // Check the status of this part
 
   IWorkbenchPart::Pointer result;
   PartInitException* exception = nullptr;
 
   // Try to restore the view -- this does the real work of restoring the
   // view
   //
   try
   {
     result = this->CreatePartHelper();
   }
   catch (const PartInitException& e)
   {
     exception = e.clone();
   }
 
   // If unable to create the part, create an error part instead
   // and pass the error to the status handling facility
   if (exception != nullptr)
   {
     //      IStatus partStatus = exception.getStatus();
     //      IStatus displayStatus = StatusUtil.newStatus(partStatus,
     //          NLS.bind(WorkbenchMessages.ViewFactory_initException, partStatus.getMessage()));
     //      IStatus logStatus = StatusUtil
     //          .newStatus(
     //              partStatus,
     //              NLS
     //                  .bind(
     //                      "Unable to create view ID {0}: {1}", getId(), partStatus.getMessage())); //$NON-NLS-1$
 
     // Pass the error to the status handling facility
     //      StatusManager.getManager().handle(logStatus);
 
     QString errorTitle = "Unable to create view ID " + this->GetId();
     WorkbenchPlugin::Log(errorTitle + ": " + exception->what());
 
     IViewDescriptor::Pointer desc = factory->GetViewRegistry()->Find(
         this->GetId());
     QString label = this->GetId();
     if (!desc.IsNull())
     {
       label = desc->GetLabel();
     }
 
     QString errorMsg(exception->what());
     delete exception;
 
     errorMsg
         += "<ul><li>Check your shared library for unresolved symbols</li>"
             "<li>Check your class attribute in your plugin.xml file</li>"
             "<li>Check your manifest.cpp file</li></ul>"
-            "</br>For a comprehensive check-list, see <a href=\"http://www.mitk.org/wiki/How_to_fix_your_plug-in_DLL\">http://www.mitk.org/wiki/How_to_fix_your_plug-in_DLL</a>";
+            "</br>For a comprehensive check-list, see <a href=\"https://www.mitk.org/wiki/How_to_fix_your_plug-in_DLL\">https://www.mitk.org/wiki/How_to_fix_your_plug-in_DLL</a>";
     ErrorViewPart::Pointer part(new ErrorViewPart(errorTitle, errorMsg));
 
     //PartPane pane = getPane();
     IViewReference::Pointer viewRef(this);
     ViewSite::Pointer site(new ViewSite(viewRef, part,
                                         factory->GetWorkbenchPage(), GetId(), PlatformUI::PLUGIN_ID(), label));
     //site.setActionBars(new ViewActionBars(factory.page.getActionBars(),
     //    site, (ViewPane) pane));
     try
     {
       part->Init(site);
     }
     catch (const PartInitException& e)
     {
       BERRY_ERROR << e.what();
       //StatusUtil.handleStatus(e, StatusManager.SHOW
       //    | StatusManager.LOG);
       return IWorkbenchPart::Pointer(nullptr);
     }
     part->SetPartName(label);
 
     QWidget* parent = pane->GetControl();
 
     try
     {
       part->CreatePartControl(parent);
     }
     catch (const std::exception& e)
     {
       BERRY_ERROR << "Error creating view: " << e.what() << std::endl;
       //          StatusUtil.handleStatus(e, StatusManager.SHOW
       //              | StatusManager.LOG);
       return IWorkbenchPart::Pointer(nullptr);
     }
 
     result = part.Cast<IWorkbenchPart> ();
   }
 
   return result;
 }
 
 PartPane::Pointer ViewReference::CreatePane()
 {
   IWorkbenchPartReference::Pointer partRef(this);
   PartPane::Pointer pane(new PartPane(partRef,
       this->factory->GetWorkbenchPage()));
   return pane;
   //return Tweaklets::Get(WorkbenchTweaklet::KEY)->CreateViewPane(this, this->factory->GetWorkbenchPage());
 }
 
 IWorkbenchPart::Pointer ViewReference::CreatePartHelper()
 {
 
   IWorkbenchPart::Pointer result;
 
   IMemento::Pointer stateMem;
   if (!memento.IsNull())
   {
     stateMem = memento->GetChild(WorkbenchConstants::TAG_VIEW_STATE);
   }
 
   IViewDescriptor::Pointer desc = factory->GetViewRegistry()->Find(GetId());
   if (desc.IsNull())
   {
     throw PartInitException(QString("Could not create view: ") + this->GetId());
   }
 
   // Create the part pane
   PartPane::Pointer pane = this->GetPane();
 
   // Create the pane's top-level control
   pane->CreateControl(factory->GetWorkbenchPage()->GetClientComposite());
 
   QString label = desc->GetLabel(); // debugging only
 
   // Things that will need to be disposed if an exception occurs (they are
   // listed here
   // in the order they should be disposed)
   //Composite content = null;
   IViewPart::Pointer initializedView;
   ViewSite::Pointer site;
   //ViewActionBars actionBars = null;
   // End of things that need to be explicitly disposed from the try block
 
   try
   {
     IViewPart::Pointer view;
 
     view = desc->CreateView();
 
     if (view.IsNull())
         return result;
 
     this->CreatePartProperties(view);
 
     // Create site
     IViewReference::Pointer viewRef(this);
     site = new ViewSite(viewRef, view, factory->GetWorkbenchPage(), desc);
     //actionBars = new ViewActionBars(factory.page.getActionBars(), site,
     //    (ViewPane) pane);
     //site.setActionBars(actionBars);
 
 
     view->Init(site, stateMem);
     // Once we've called init, we MUST dispose the view. Remember
     // the fact that
     // we've initialized the view in case an exception is thrown.
     initializedView = view;
 
     if (view->GetSite() != site)
     {
       throw PartInitException("View initialization failed. Site is incorrect.");
     }
 
     // Create the top-level composite
 
     {
       QWidget* parent = pane->GetControl();
 
       view->CreatePartControl(parent);
     }
 
     // Install the part's tools and menu
 
     {
       //
       // 3.3 start
       //
       //        IMenuService menuService = (IMenuService) site
       //            .getService(IMenuService.class);
       //        menuService.populateContributionManager(
       //            (ContributionManager) site.getActionBars()
       //                .getMenuManager(), "menu:" //$NON-NLS-1$
       //                + site.getId());
       //        menuService
       //            .populateContributionManager((ContributionManager) site
       //                .getActionBars().getToolBarManager(),
       //                "toolbar:" + site.getId()); //$NON-NLS-1$
       // 3.3 end
 
       //        actionBuilder = new ViewActionBuilder();
       //        actionBuilder.readActionExtensions(view);
       //        ActionDescriptor[] actionDescriptors = actionBuilder
       //            .getExtendedActions();
       //        IKeyBindingService keyBindingService = view.getSite()
       //            .getKeyBindingService();
       //
       //        if (actionDescriptors != null) {
       //          for (int i = 0; i < actionDescriptors.length; i++) {
       //            ActionDescriptor actionDescriptor = actionDescriptors[i];
       //
       //            if (actionDescriptor != null) {
       //              IAction action = actionDescriptors[i].getAction();
       //
       //              if (action != null
       //                  && action.getActionDefinitionId() != null) {
       //                keyBindingService.registerAction(action);
       //              }
       //            }
       //          }
       //        }
       //
       //        site.getActionBars().updateActionBars();
     }
 
     // The part should now be fully created. Exercise its public
     // interface, and sanity-check
     // it wherever possible. If it's going to throw exceptions or behave
     // badly, it's much better
     // that it does so now while we can still cancel creation of the
     // part.
     PartTester::TestView(view);
 
     result = view.Cast<IWorkbenchPart> ();
 
     //      IConfigurationElement::Pointer element = desc->GetConfigurationElement();
     //      if (!element.IsNull()) {
     //        factory.page.getExtensionTracker().registerObject(
     //            element.getDeclaringExtension(), view,
     //            IExtensionTracker.REF_WEAK);
     //      }
   }
   catch (const ctkException& e)
   {
     //      if ((e instanceof Error) && !(e instanceof LinkageError)) {
     //        throw (Error) e;
     //      }
 
     // An exception occurred. First deallocate anything we've allocated
     // in the try block (see the top
     // of the try block for a list of objects that need to be explicitly
     // disposed)
     //      if (content != null) {
     //        try {
     //          content.dispose();
     //        } catch (RuntimeException re) {
     //          StatusManager.getManager().handle(
     //              StatusUtil.newStatus(WorkbenchPlugin.PI_WORKBENCH,
     //                  re));
     //        }
     //      }
     //
     //      if (initializedView != null) {
     //        try {
     //          initializedView.dispose();
     //        } catch (RuntimeException re) {
     //          StatusManager.getManager().handle(
     //              StatusUtil.newStatus(WorkbenchPlugin.PI_WORKBENCH,
     //                  re));
     //        }
     //      }
     //
     //      if (site != null) {
     //        try {
     //          site.dispose();
     //        } catch (RuntimeException re) {
     //          StatusManager.getManager().handle(
     //              StatusUtil.newStatus(WorkbenchPlugin.PI_WORKBENCH,
     //                  re));
     //        }
     //      }
     //
     //      if (actionBars != null) {
     //        try {
     //          actionBars.dispose();
     //        } catch (RuntimeException re) {
     //          StatusManager.getManager().handle(
     //              StatusUtil.newStatus(WorkbenchPlugin.PI_WORKBENCH,
     //                  re));
     //        }
     //      }
 
     throw PartInitException(e.what(), e);
   }
   catch (const std::exception& e)
   {
     throw PartInitException(e.what());
   }
 
   return result;
 }
 
 IMemento::Pointer ViewReference::GetMemento()
 {
   return memento;
 }
 
 } // namespace berry
diff --git a/Plugins/org.mitk.core.ext/manifest_headers.cmake b/Plugins/org.mitk.core.ext/manifest_headers.cmake
index 584066de75..32a48a5359 100644
--- a/Plugins/org.mitk.core.ext/manifest_headers.cmake
+++ b/Plugins/org.mitk.core.ext/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Extensions")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.core.runtime)
diff --git a/Plugins/org.mitk.core.jobs/manifest_headers.cmake b/Plugins/org.mitk.core.jobs/manifest_headers.cmake
index 7405b9a76a..ea188966c6 100644
--- a/Plugins/org.mitk.core.jobs/manifest_headers.cmake
+++ b/Plugins/org.mitk.core.jobs/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Job Plug-in")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.core.jobs)
diff --git a/Plugins/org.mitk.core.services/manifest_headers.cmake b/Plugins/org.mitk.core.services/manifest_headers.cmake
index 6646f1ee0a..279c05b04a 100644
--- a/Plugins/org.mitk.core.services/manifest_headers.cmake
+++ b/Plugins/org.mitk.core.services/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "MITK Core Plugin")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.core.runtime)
 
diff --git a/Plugins/org.mitk.gui.common/manifest_headers.cmake b/Plugins/org.mitk.gui.common/manifest_headers.cmake
index 44f38af198..abe3305c65 100644
--- a/Plugins/org.mitk.gui.common/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.common/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "MITK Qt User Interface Plugin")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.blueberry.ui.qt org.mitk.core.services)
 
diff --git a/Plugins/org.mitk.gui.qt.application/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.application/manifest_headers.cmake
index 19ca7c69d6..948867097e 100644
--- a/Plugins/org.mitk.gui.qt.application/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.application/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "MITK Qt CoreApp application")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.common)
 
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.basicimageprocessing/manifest_headers.cmake
index 64dd130fc3..138dbf3166 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Basic Image Processing")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.cmdlinemodules/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.cmdlinemodules/manifest_headers.cmake
index 8ed170d027..d792fa6273 100644
--- a/Plugins/org.mitk.gui.qt.cmdlinemodules/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.cmdlinemodules/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "Command Line Modules")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "CMIC, Centre For Medical Image Computing, UCL.")
-set(Plugin-ContactAddress "http://cmic.cs.ucl.ac.uk/")
+set(Plugin-ContactAddress "https://www.ucl.ac.uk/medical-image-computing")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleRunner.cpp b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleRunner.cpp
index e78f9b212b..5d179b37f1 100644
--- a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleRunner.cpp
+++ b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleRunner.cpp
@@ -1,665 +1,665 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkCmdLineModuleRunner.h"
 #include "ui_QmitkCmdLineModuleProgressWidget.h"
 
 // Qt
 #include <QFile>
 #include <QFileInfo>
 #include <QDir>
 #include <QMessageBox>
 #include <QVBoxLayout>
 #include <QLayoutItem>
 #include <QTextBrowser>
 #include <QByteArray>
 #include <QApplication>
 #include <QRegExp>
 #include <QStyle>
 
 // CTK
 #include <ctkCmdLineModuleFuture.h>
 #include <ctkCmdLineModuleFutureWatcher.h>
 #include <ctkCmdLineModuleManager.h>
 #include <ctkCmdLineModuleFrontend.h>
 #include <ctkCmdLineModuleDescription.h>
 #include <ctkCollapsibleGroupBox.h>
 
 // MITK
 #include <mitkIOUtil.h>
 #include <mitkDataStorage.h>
 #include <mitkExceptionMacro.h>
 #include <mitkFileReaderSelector.h>
 #include <QmitkCustomVariants.h>
 #include "QmitkCmdLineModuleGui.h"
 
 
 //-----------------------------------------------------------------------------
 QmitkCmdLineModuleRunner::QmitkCmdLineModuleRunner(QWidget *parent)
   : QWidget(parent)
 , m_ModuleManager(nullptr)
 , m_DataStorage(nullptr)
 , m_UI(new Ui::QmitkCmdLineModuleProgressWidget)
 , m_Layout(nullptr)
 , m_ModuleFrontEnd(nullptr)
 , m_FutureWatcher(nullptr)
 {
   m_UI->setupUi(this);
   m_UI->m_RemoveButton->setIcon(QApplication::style()->standardIcon(QStyle::SP_TitleBarCloseButton));
 
   m_Layout = new QVBoxLayout();
   m_Layout->setContentsMargins(0,0,0,0);
   m_Layout->setSpacing(0);
   m_UI->m_ParametersGroupBox->setLayout(m_Layout);
 
   qRegisterMetaType<ctkCmdLineModuleReference>();
 
   connect(m_UI->m_RemoveButton, SIGNAL(clicked()), this, SLOT(OnRemoveButtonClicked()));
 
   // Due to Qt bug 12152, we cannot listen to the "paused" signal because it is
   // not emitted directly when the QFuture is paused. Instead, it is emitted after
   // resuming the future, after the "resume" signal has been emitted... we use
   // a polling approach instead.
   connect(&m_PollPauseTimer, SIGNAL(timeout()), SLOT(OnCheckModulePaused()));
   m_PollPauseTimer.setInterval(300);
   m_PollPauseTimer.start();
 }
 
 
 //-----------------------------------------------------------------------------
 QmitkCmdLineModuleRunner::~QmitkCmdLineModuleRunner()
 {
   if (m_ModuleFrontEnd != nullptr)
   {
     delete m_ModuleFrontEnd;
   }
 
   this->ClearUpTemporaryFiles();
 
   delete m_UI;
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::SetManager(ctkCmdLineModuleManager* manager)
 {
   this->m_ModuleManager = manager;
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   this->m_DataStorage = dataStorage;
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::SetOutputDirectory(const QString& directoryName)
 {
   this->m_OutputDirectoryName = directoryName;
 }
 
 
 //-----------------------------------------------------------------------------
 QString QmitkCmdLineModuleRunner::GetTitle()
 {
   assert(m_ModuleFrontEnd);
 
   ctkCmdLineModuleReference reference = m_ModuleFrontEnd->moduleReference();
   ctkCmdLineModuleDescription description = reference.description();
 
   return description.title();
 }
 
 
 //-----------------------------------------------------------------------------
 QString QmitkCmdLineModuleRunner::GetFullName() const
 {
   assert(m_ModuleFrontEnd);
 
   ctkCmdLineModuleReference reference = m_ModuleFrontEnd->moduleReference();
   ctkCmdLineModuleDescription description = reference.description();
 
   return description.categoryDotTitle();
 }
 
 
 //-----------------------------------------------------------------------------
 QString QmitkCmdLineModuleRunner::GetValidNodeName(const QString& nodeName) const
 {
   QString outputName = nodeName;
 
   // We will allow A-Z, a-z, 0-9, period, hyphen and underscore in the output file name.
   // This method is parsing a node name, and other bits of code add on a file extension .nii.
   // So, in the output string from this function, we should not allow period, so that
   // the second recommendation on this page:
-  // http://www.boost.org/doc/libs/1_43_0/libs/filesystem/doc/portability_guide.htm
+  // https://www.boost.org/doc/libs/1_43_0/libs/filesystem/doc/portability_guide.htm
   // is still true.
 
   QRegExp rx("[A-Z|a-z|0-9|-|_]{1,1}");
 
   QString singleLetter;
 
   for (int i = 0; i < outputName.size(); i++)
   {
     if (i == 0 && outputName[i] == '-')
     {
       outputName[i] = '_';
     }
 
     singleLetter = outputName[i];
 
     if (!rx.exactMatch(singleLetter))
     {
       outputName[i] = '-';
     }
   }
   return outputName;
 }
 
 
 //-----------------------------------------------------------------------------
 bool QmitkCmdLineModuleRunner::IsStarted() const
 {
   bool isStarted = false;
   if (m_FutureWatcher != nullptr && m_FutureWatcher->isStarted())
   {
     isStarted = true;
   }
   return isStarted;
 }
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnCheckModulePaused()
 {
   if (!this->IsStarted())
   {
     return;
   }
 
   if (this->m_FutureWatcher->future().isPaused())
   {
     if (!m_UI->m_PauseButton->isChecked())
     {
       m_UI->m_PauseButton->setChecked(true);
     }
   }
   else
   {
     if (m_UI->m_PauseButton->isChecked())
     {
       m_UI->m_PauseButton->setChecked(false);
     }
   }
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnPauseButtonToggled(bool toggled)
 {
   this->m_FutureWatcher->setPaused(toggled);
 
   if (toggled)
   {
     this->m_UI->m_ProgressTitle->setText(this->GetTitle() + ": paused");
   }
   else
   {
     this->m_UI->m_ProgressTitle->setText(this->GetTitle() + ": resumed");
   }
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnRemoveButtonClicked()
 {
   this->deleteLater();
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnModuleStarted()
 {
   this->m_UI->m_ProgressBar->setMaximum(0);
 
   QString message = "started.";
   this->PublishMessage(message);
 
   emit started();
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnModuleCanceled()
 {
   QString message = "cancelling.";
   this->PublishMessage(message);
 
   this->m_UI->m_PauseButton->setEnabled(false);
   this->m_UI->m_PauseButton->setChecked(false);
   this->m_UI->m_CancelButton->setEnabled(false);
   this->m_UI->m_RemoveButton->setEnabled(true);
 
   this->m_UI->m_ParametersGroupBox->setCollapsed(true);
   this->m_UI->m_ConsoleGroupBox->setCollapsed(true);
   this->m_UI->m_ProgressTitle->setText(this->GetTitle() + ": cancelled");
 
   message = "cancelled.";
   this->PublishMessage(message);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnModuleFinished()
 {
   this->m_UI->m_PauseButton->setEnabled(false);
   this->m_UI->m_PauseButton->setChecked(false);
   this->m_UI->m_CancelButton->setEnabled(false);
   this->m_UI->m_RemoveButton->setEnabled(true);
 
   if (!this->m_FutureWatcher->isCanceled())
   {
     QString message = "finishing.";
     this->PublishMessage(message);
 
     // If no incremental results from stdout, try getting hold of the whole buffer and printing it.
     if (m_OutputCount == 0)
     {
       message = "Output channel is:";
       this->PublishMessage(message);
       this->PublishByteArray(this->m_FutureWatcher->readAllOutputData());
     }
 
     // If no incremental results from stderr, try getting hold of the whole buffer and printing it.
     if (m_ErrorCount == 0)
     {
       message = "Error channel is:";
       this->PublishMessage(message);
       this->PublishByteArray(this->m_FutureWatcher->readAllErrorData());
     }
 
     this->m_UI->m_ProgressTitle->setText(this->GetTitle() + ": finished");
 
     this->LoadOutputData();
     this->ClearUpTemporaryFiles();
 
     message = "finished.";
     this->PublishMessage(message);
 
   }
 
   emit finished();
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnModuleResumed()
 {
   this->m_UI->m_PauseButton->setChecked(false);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnModuleProgressRangeChanged(int progressMin, int progressMax)
 {
   this->m_UI->m_ProgressBar->setMinimum(progressMin);
   this->m_UI->m_ProgressBar->setMaximum(progressMax);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnModuleProgressTextChanged(const QString& progressText)
 {
   this->m_UI->m_Console->appendPlainText(progressText);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnModuleProgressValueChanged(int progressValue)
 {
   this->m_UI->m_ProgressBar->setValue(progressValue);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnOutputDataReady()
 {
   m_OutputCount++;
   this->PublishByteArray(this->m_FutureWatcher->readPendingOutputData());
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::OnErrorDataReady()
 {
   m_ErrorCount++;
   this->PublishByteArray(this->m_FutureWatcher->readPendingErrorData());
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::PublishMessage(const QString& message)
 {
   QString prefix = ""; // Can put additional prefix here if needed.
   QString outputMessage = prefix + message;
 
   qDebug() << outputMessage;
   this->m_UI->m_Console->appendPlainText(outputMessage);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::PublishByteArray(const QByteArray& array)
 {
   QString message = array.data();
   this->PublishMessage(message);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::ClearUpTemporaryFiles()
 {
   QString message;
   QString fileName;
 
   foreach (QTemporaryFile* file, m_TemporaryFiles)
   {
     assert(file != nullptr);
 
     fileName = file->fileName();
     message = QObject::tr("removing %1").arg(fileName);
     this->PublishMessage(message);
 
     delete file;
   }
 
   m_TemporaryFiles.clear();
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::LoadOutputData()
 {
   assert(m_DataStorage);
 
   QString fileName;
   foreach (fileName, m_OutputDataToLoad)
   {
     QString message;
 
     try
     {
 
       mitk::IOUtil::LoadInfo info(fileName.toStdString());
       std::vector<mitk::FileReaderSelector::Item> readers = info.m_ReaderSelector.Get();
       if (readers.size() > 0)
       {
         mitk::IOUtil::Load(fileName.toStdString(), *(m_DataStorage));
         message = QObject::tr("Loaded %1").arg(fileName);
       }
       else
       {
         message = QObject::tr("Not loading %1, as no IFileReader is available.").arg(fileName);
       }
     }
     catch (const mitk::Exception& e)
     {
       message = QObject::tr("Failed to load %1, due to %2\n").arg(fileName).arg(e.what());
       MITK_ERROR << message.toStdString();
     }
 
     this->PublishMessage(message);
   }
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::SetFrontend(QmitkCmdLineModuleGui* frontEnd)
 {
   assert(frontEnd);
   assert(m_ModuleManager);
   assert(m_DataStorage);
 
   // We are assuming that this method is ONLY EVER CALLED ONCE.
   assert(!m_ModuleFrontEnd);
 
   // Assign the frontEnd to the member variable.
   m_ModuleFrontEnd = frontEnd;
 
   // We put the new GUI into the layout.
   m_Layout->insertWidget(0, m_ModuleFrontEnd->getGui());
 
   // And configure a few other niceties.
   m_UI->m_ProgressTitle->setText(this->GetTitle());
   m_UI->m_ConsoleGroupBox->setCollapsed(true);     // We basically call SetFrontend then Run
   m_UI->m_ParametersGroupBox->setCollapsed(true);  // so in practice the user will only want the progress bar.
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleRunner::Run()
 {
   assert(m_ModuleManager);
   assert(m_DataStorage);
   assert(m_ModuleFrontEnd);
 
   m_OutputDataToLoad.clear();
 
   QString parameterName;
   QString message;
   QList<ctkCmdLineModuleParameter> parameters;
 
   ctkCmdLineModuleReference reference = m_ModuleFrontEnd->moduleReference();
   ctkCmdLineModuleDescription description = reference.description();
 
   // Check we have valid output. If at all possible, they should be somewhere writable.
 
   parameters = m_ModuleFrontEnd->parameters("image", ctkCmdLineModuleFrontend::Output);
   parameters << m_ModuleFrontEnd->parameters("file", ctkCmdLineModuleFrontend::Output);
   parameters << m_ModuleFrontEnd->parameters("geometry", ctkCmdLineModuleFrontend::Output);
 
   foreach (ctkCmdLineModuleParameter parameter, parameters)
   {
     parameterName = parameter.name();
     QString outputFileName = m_ModuleFrontEnd->value(parameterName, ctkCmdLineModuleFrontend::DisplayRole).toString();
 
     // Try to make sure we are not running in the application installation folder,
     // as more likely than not, it should not have write access, and you certainly
     // don't want users output files dumped there.
     //
     // eg. C:/Program Files (Windows), /Applications (Mac), /usr/local (Linux) etc.
 
     QFileInfo outputFileInfo(outputFileName);
 
     QString applicationDir = QApplication::applicationDirPath();
     QString outputDir = outputFileInfo.dir().absolutePath();
 
     if (applicationDir == outputDir)
     {
       qDebug() << "QmitkCmdLineModuleRunner::Run(), output folder = application folder, so will swap to defaultOutputDir, specified in CLI module preferences";
 
       QFileInfo newOutputFileInfo(m_OutputDirectoryName, outputFileInfo.fileName());
       QString newOutputFileAbsolutePath = newOutputFileInfo.absoluteFilePath();
 
       qDebug() << "QmitkCmdLineModuleRunner::Run(), swapping " << outputFileName << " to " << newOutputFileAbsolutePath;
 
       QMessageBox msgBox;
         msgBox.setText("The output directory is the same as the application installation directory");
         msgBox.setInformativeText(tr("Output file:\n%1\n\nwill be swapped to\n%2").arg(outputFileName).arg(newOutputFileAbsolutePath));
         msgBox.setStandardButtons(QMessageBox::Ok);
         msgBox.setIcon(QMessageBox::Warning);
         msgBox.exec();
 
       m_ModuleFrontEnd->setValue(parameterName, newOutputFileAbsolutePath, ctkCmdLineModuleFrontend::DisplayRole);
     }
   }
 
   // For each output image or file, store the filename, so we can auto-load it once the process finishes.
   foreach (ctkCmdLineModuleParameter parameter, parameters)
   {
     parameterName = parameter.name();
     QString outputFileName = m_ModuleFrontEnd->value(parameterName, ctkCmdLineModuleFrontend::DisplayRole).toString();
 
     if (!outputFileName.isEmpty())
     {
       m_OutputDataToLoad.push_back(outputFileName);
 
       message = "Registered " + outputFileName + " to auto load upon completion.";
       this->PublishMessage(message);
     }
   }
 
   // For each input image, write a temporary file as a Nifti image (TODO - iterate through list of file formats).
   // and then save the full path name back on the parameter.
 
   message = "Saving image data to temporary storage...";
   this->PublishMessage(message);
 
   parameters = m_ModuleFrontEnd->parameters("image", ctkCmdLineModuleFrontend::Input);
   foreach (ctkCmdLineModuleParameter parameter, parameters)
   {
     parameterName = parameter.name();
 
     QVariant tmp = m_ModuleFrontEnd->value(parameterName, ctkCmdLineModuleFrontend::UserRole);
     mitk::DataNode::Pointer node = tmp.value<mitkDataNodePtr>();
 
     if (node.IsNotNull())
     {
       mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
       if (image != nullptr)
       {
         QString errorMessage;
         QTemporaryFile* tempFile = this->SaveTemporaryImage(parameter, node.GetPointer(), errorMessage);
 
         if(tempFile == nullptr)
         {
           QMessageBox::warning(this, "Saving temporary file failed", errorMessage);
           return;
         }
 
         m_TemporaryFiles.push_back(tempFile);
         m_ModuleFrontEnd->setValue(parameterName, tempFile->fileName());
 
         message = "Saved " + tempFile->fileName();
         this->PublishMessage(message);
 
       } // end if image
     } // end if node
   } // end foreach input image
 
   m_OutputCount = 0;
   m_ErrorCount = 0;
 
   // Now we run stuff.
   message = "starting.";
   this->PublishMessage(message);
 
   if (m_FutureWatcher == nullptr)
   {
     m_FutureWatcher = new ctkCmdLineModuleFutureWatcher();
 
     connect(m_FutureWatcher, SIGNAL(started()), SLOT(OnModuleStarted()));
     connect(m_FutureWatcher, SIGNAL(canceled()), SLOT(OnModuleCanceled()));
     connect(m_FutureWatcher, SIGNAL(finished()), SLOT(OnModuleFinished()));
     connect(m_FutureWatcher, SIGNAL(resumed()), SLOT(OnModuleResumed()));
     connect(m_FutureWatcher, SIGNAL(progressRangeChanged(int,int)), SLOT(OnModuleProgressRangeChanged(int,int)));
     connect(m_FutureWatcher, SIGNAL(progressTextChanged(QString)), SLOT(OnModuleProgressTextChanged(QString)));
     connect(m_FutureWatcher, SIGNAL(progressValueChanged(int)), SLOT(OnModuleProgressValueChanged(int)));
     connect(m_FutureWatcher, SIGNAL(outputDataReady()), SLOT(OnOutputDataReady()));
     connect(m_FutureWatcher, SIGNAL(errorDataReady()), SLOT(OnErrorDataReady()));
 
     connect(m_UI->m_CancelButton, SIGNAL(clicked()), m_FutureWatcher, SLOT(cancel()));
     connect(m_UI->m_PauseButton, SIGNAL(toggled(bool)), this, SLOT(OnPauseButtonToggled(bool)));
 
   }
   ctkCmdLineModuleFuture future = m_ModuleManager->run(m_ModuleFrontEnd);
   m_FutureWatcher->setFuture(future);
 
   m_UI->m_PauseButton->setEnabled(future.canPause());
   m_UI->m_CancelButton->setEnabled(future.canCancel());
   m_UI->m_RemoveButton->setEnabled(!future.isRunning());
 
   // Give some immediate indication that we are running.
   m_UI->m_ProgressTitle->setText(description.title() + ": running");
 }
 
 
 //-----------------------------------------------------------------------------
 QTemporaryFile* QmitkCmdLineModuleRunner::SaveTemporaryImage(const ctkCmdLineModuleParameter &parameter, mitk::DataNode::ConstPointer node, QString& errorMessage) const
 {
   // Don't call this if node is null or node is not an image.
   assert(node.GetPointer());
   mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
   assert(image);
 
   QString intermediateError;
   QString intermediateErrors;
 
   QTemporaryFile *returnedFile = nullptr;
   QString name = this->GetValidNodeName(QString::fromStdString(node->GetName()));
   QString fileNameTemplate = name + "_XXXXXX";
 
   // If no file extensions are specified, we default to .nii
   QStringList fileExts = parameter.fileExtensions();
   if (fileExts.isEmpty())
   {
     fileExts.push_back(".nii");
   }
 
   // Try each extension until we get a good one.
   foreach (QString extension, fileExts)
   {
     // File extensions may or may not include the leading dot, so add one if necessary.
     if (!extension.startsWith("."))
     {
       extension.prepend(".");
     }
     fileNameTemplate = fileNameTemplate + extension;
 
     try
     {
       QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + QDir::separator() + fileNameTemplate);
       if (tempFile->open())
       {
         tempFile->close();
         try
         {
           mitk::IOUtil::Save( image, tempFile->fileName().toStdString() );
           returnedFile = tempFile;
           break;
         }
         catch(const mitk::Exception &)
         {
           intermediateError = QObject::tr("Tried %1, failed to save image:\n%2\n").arg(extension).arg(tempFile->fileName());
         }
       }
       else
       {
         intermediateError = QObject::tr("Tried %1, failed to open file:\n%2\n").arg(extension).arg(tempFile->fileName());
       }
     }
     catch(const mitk::Exception &e)
     {
       intermediateError = QObject::tr("Tried %1, caught MITK Exception:\nDescription: %2\nFilename: %3\nLine: %4\n")
                           .arg(extension).arg(e.GetDescription()).arg(e.GetFile()).arg(e.GetLine());
     }
     catch(const std::exception& e)
     {
       intermediateError = QObject::tr("Tried %1, caught exception:\nDescription: %2\n")
                           .arg(extension).arg(e.what());
     }
     intermediateErrors += intermediateError;
   }
   errorMessage = intermediateErrors;
   return returnedFile;
 }
diff --git a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleRunner.h b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleRunner.h
index c638c1f18c..c61d1c6610 100644
--- a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleRunner.h
+++ b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleRunner.h
@@ -1,232 +1,232 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKCMDLINEMODULERUNNER_H
 #define QMITKCMDLINEMODULERUNNER_H
 
 #include <QWidget>
 #include <QTimer>
 #include <QList>
 
 #include <ctkCmdLineModuleParameter.h>
 #include <mitkDataNode.h>
 
 class QVBoxLayout;
 class QTemporaryFile;
 class QmitkCmdLineModuleGui;
 class ctkCmdLineModuleManager;
 class ctkCmdLineModuleFutureWatcher;
 
 namespace Ui {
 class QmitkCmdLineModuleProgressWidget;
 }
 
 namespace mitk {
 class DataStorage;
 }
 
 /**
  * \class QmitkCmdLineModuleRunner
  * \brief Based on ctkCmdLineModuleExplorerProgressWidget, implements a progress widget
  * with console output, and space for storing the GUI widgets.
  * \author Matt Clarkson (m.clarkson@ucl.ac.uk)
  * \ingroup org_mitk_gui_qt_cmdlinemodules_internal
  * \sa ctkCmdLineModuleExplorerProgressWidget
  */
 class QmitkCmdLineModuleRunner : public QWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkCmdLineModuleRunner(QWidget *parent = nullptr);
   ~QmitkCmdLineModuleRunner() override;
 
   /**
    * \brief Sets the manager on this object, and must be called immediately
    * after construction, before using the widget.
    */
   void SetManager(ctkCmdLineModuleManager* manager);
 
   /**
    * \brief Sets the DataStorage on this object, and must be called immediately
    * after construction, before using the widget.
    */
   void SetDataStorage(mitk::DataStorage* dataStorage);
 
   /**
    * \brief Sets the Output Directory on this widget, and must be called
    * immediately after construction, before using the widget.
    */
   void SetOutputDirectory(const QString& directoryName);
 
   /**
    * \brief Tells this widget, which module frontend it is running
    * \param frontEnd our QmitkCmdLineModuleGui class derived from ctkCmdLineModuleFrontend
    */
   void SetFrontend(QmitkCmdLineModuleGui* frontEnd);
 
   /**
    * \brief Runs the module that this widget is currently referring to.
    */
   void Run();
 
 Q_SIGNALS:
 
   // These signals so that container classes such as CommandLineModuleView
   // can keep track of how many modules are running simultaneously.
 
   void started();   // emmitted when the module is started.
   void finished();  // emmitted when the module is completely finished.
 
 private Q_SLOTS:
 
   void OnCheckModulePaused();
 
   void OnPauseButtonToggled(bool toggled);
   void OnRemoveButtonClicked();
 
   void OnModuleStarted();
   void OnModuleCanceled();
   void OnModuleFinished();
   void OnModuleResumed();
   void OnModuleProgressRangeChanged(int progressMin, int progressMax);
   void OnModuleProgressTextChanged(const QString& progressText);
   void OnModuleProgressValueChanged(int progressValue);
   void OnOutputDataReady();
   void OnErrorDataReady();
 
 private:
 
   /**
    * \brief Simply returns true if this widget is considered as having been started.
    */
   bool IsStarted() const;
 
   /**
    * \brief Used to write output to the console widget, and also to qDebug().
    */
   void PublishMessage(const QString& message);
 
   /**
    * \brief Used to write output to the console widget, and also to qDebug().
    */
   void PublishByteArray(const QByteArray& array);
 
   /**
    * \brief Destroys any images listed in m_TemporaryFileNames.
    */
   void ClearUpTemporaryFiles();
 
   /**
    * \brief Loads any data listed in m_OutputDataToLoad into the m_DataStorage.
    */
   void LoadOutputData();
 
   /**
    * \brief Saves temporary image to file.
    * \param[in] node non-nullptr pointer to node containing a non-nullptr mitk::Image.
    * \param[out] errorMessage which if not empty means an error occurred.
    * \return QTemporaryFile temporary file that the caller is responsible for deleting.
    *
    * If the returned QTemporaryFile is nullptr, check errorMessage.
    * If the returned QTemporaryFile is not-nullptr, there could still be data in the errorMessage.
    * It could be that this method tried n file extensions, before finding a successful one.
    * In this case, the returned QTemporaryFile is the successful one, and the errorMessage contains error messages of all the failed attempts.
    */
   QTemporaryFile* SaveTemporaryImage(const ctkCmdLineModuleParameter& parameter, mitk::DataNode::ConstPointer node, QString& errorMessage) const;
 
   /**
    * \brief Utility method to look up the title from the description.
    */
   QString GetTitle();
 
   /**
    * \brief Returns <category>.<title>, derived from the ctkCmdLineModuleReference and
    * hence from the ctkCmdLineModuleDescription.
    */
   QString GetFullName() const;
 
   /**
    * \brief Takes nodeName, and makes sure that it only contains A-Z, a-z, 0-9, hyphen and underscore,
    * and does not use hyphen as the first character.
    *
-   * Inspired by <a href="http://www.boost.org/doc/libs/1_43_0/libs/filesystem/doc/portability_guide.htm">boost recommendations</a>.
+   * Inspired by <a href="https://www.boost.org/doc/libs/1_43_0/libs/filesystem/doc/portability_guide.htm">boost recommendations</a>.
    */
   QString GetValidNodeName(const QString& nodeName) const;
 
   /**
    * \brief This must be injected before the Widget is used.
    */
   ctkCmdLineModuleManager *m_ModuleManager;
 
   /**
    * \brief This must be injected before the Widget is used.
    */
   mitk::DataStorage *m_DataStorage;
 
   /**
    * \brief This must be injected before the Widget is used.
    */
   QString m_OutputDirectoryName;
 
   /**
    * \brief We instantiate the main widgets from this .ui file.
    */
   Ui::QmitkCmdLineModuleProgressWidget *m_UI;
 
   /**
    * \brief The m_ParametersGroupBox needs a layout.
    */
   QVBoxLayout *m_Layout;
 
   /**
    * \brief The QmitkCmdLineModuleGui is created by the QmitkCmdLineModuleFactoryGui outside
    * of this class and injected into this class before being run.
    */
   QmitkCmdLineModuleGui *m_ModuleFrontEnd;
 
   /**
    * \brief Main object to keep track of a running command line module.
    */
   ctkCmdLineModuleFutureWatcher *m_FutureWatcher;
 
   /**
    * \brief Due to Qt bug 12152, we use a timer to correctly check for a paused module.
    */
   QTimer m_PollPauseTimer;
 
   /**
    * \brief We store a list of temporary file names that are saved to disk before
    * launching a command line app, and then must be cleared up when the command line
    * app successfully finishes.
    */
   QList<QTemporaryFile*> m_TemporaryFiles;
 
   /**
    * \brief We store a list of output images, so that on successful completion of
    * the command line module, we automatically load the output data into the mitk::DataStorage.
    */
   QStringList m_OutputDataToLoad;
 
   /**
    * \brief We track how many times the OnOutputDataReady is called.
    */
   int m_OutputCount;
 
   /**
    * \brief We track how many times the OnErrorDataReady is called.
    */
   int m_ErrorCount;
 };
 
 #endif // QMITKCMDLINEMODULERUNNER_H
diff --git a/Plugins/org.mitk.gui.qt.common/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.common/manifest_headers.cmake
index b7e17e79ce..bc8f4118f0 100644
--- a/Plugins/org.mitk.gui.qt.common/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.common/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "Common MITK Qt classes")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.common)
 
diff --git a/Plugins/org.mitk.gui.qt.datamanager/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.datamanager/manifest_headers.cmake
index e431f30840..b5251acf93 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.datamanager/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Data Manager")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.application org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.datamanagerlight/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.datamanagerlight/manifest_headers.cmake
index 34dbec6092..a11153dbf5 100644
--- a/Plugins/org.mitk.gui.qt.datamanagerlight/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.datamanagerlight/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Data Manager Light")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.datastorageviewertest/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.datastorageviewertest/manifest_headers.cmake
index 3189816295..5be160a4f6 100644
--- a/Plugins/org.mitk.gui.qt.datastorageviewertest/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.datastorageviewertest/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Data storage viewer test")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "DKFZ")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.deformableclippingplane/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.deformableclippingplane/manifest_headers.cmake
index 92f1980c68..b64619ac32 100644
--- a/Plugins/org.mitk.gui.qt.deformableclippingplane/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.deformableclippingplane/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "Clipping Plane")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager)
diff --git a/Plugins/org.mitk.gui.qt.ext/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.ext/manifest_headers.cmake
index 43b0579214..9a31004ed0 100644
--- a/Plugins/org.mitk.gui.qt.ext/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.ext/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "Common Qt Ext Plugin")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.core.ext org.mitk.gui.qt.application)
diff --git a/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/README.txt b/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/README.txt
index 7a2762e162..4b55cbf1a5 100644
--- a/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/README.txt
+++ b/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/README.txt
@@ -1 +1 @@
-This icon theme is based on Font Awesome by Dave Gandy - http://fontawesome.io
\ No newline at end of file
+This icon theme is based on Font Awesome v4 - https://fontawesome.com/v4/
diff --git a/Plugins/org.mitk.gui.qt.extapplication/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.extapplication/manifest_headers.cmake
index d77df2ad49..28523be39d 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.extapplication/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Workbench")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.ext)
diff --git a/Plugins/org.mitk.gui.qt.flow.segmentation/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.flow.segmentation/manifest_headers.cmake
index 996ab595c6..edc51c047e 100644
--- a/Plugins/org.mitk.gui.qt.flow.segmentation/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.flow.segmentation/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "Flow Segmentation Control")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "DKFZ, Medical Image Computing")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.segmentation org.mitk.gui.qt.flowapplication)
diff --git a/Plugins/org.mitk.gui.qt.flowapplication/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.flowapplication/manifest_headers.cmake
index d1227975c7..cbbc713870 100644
--- a/Plugins/org.mitk.gui.qt.flowapplication/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.flowapplication/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Flow Application")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "DKFZ, Medical Image Computing")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.ext)
diff --git a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisorHack.h b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisorHack.h
index 3cd0d48862..63058bd27d 100644
--- a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisorHack.h
+++ b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisorHack.h
@@ -1,58 +1,54 @@
-/*===================================================================
+/*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
+Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
 
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
+============================================================================*/
 
 #include <QObject>
 
 class ctkPluginContext;
 class QmitkPreferencesDialog;
 
 /** This class is a "hack" due to the currently missing command framework. It is a direct clone of QmitkExtWorkbenchWindowAdvisorHack.*/
 class QmitkFlowApplicationWorkbenchWindowAdvisorHack : public QObject
 {
   Q_OBJECT
 
   public slots:
 
     void onUndo();
     void onRedo();
     void onImageNavigator();
     void onEditPreferences();
     void onQuit();
 
     void onResetPerspective();
     void onClosePerspective();
     void onIntro();
 
     /**
      * @brief This slot is called if the user klicks the menu item "help->context help" or presses F1.
      * The help page is shown in a workbench editor.
      */
     void onHelp();
 
     void onHelpOpenHelpPerspective();
 
     /**
      * @brief This slot is called if the user clicks in help menu the about button
      */
     void onAbout();
 
   public:
 
     QmitkFlowApplicationWorkbenchWindowAdvisorHack();
     ~QmitkFlowApplicationWorkbenchWindowAdvisorHack() override;
 
     static QmitkFlowApplicationWorkbenchWindowAdvisorHack* undohack;
 };
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/manifest_headers.cmake
index 473ac96eb1..fda3a4df97 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "IGT APP: Hummel Protocol Measurements")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/manifest_headers.cmake
index bf3e8c3a20..a913fb3559 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "IGT APP: UltrasoundTracking Navigation")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.stdmultiwidgeteditor)
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.igtexamples/manifest_headers.cmake
index 93de0663d9..8b6c63de7d 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.igtexamples/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "IGT Examples")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.imagecropper/manifest_headers.cmake
index b9888860cc..8211a4fb19 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.imagecropper/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Image Cropper")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.imagenavigator/manifest_headers.cmake
index 4eeddaf9b5..b6110e75e6 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Image Navigator")
 set(Plugin-Version "0.9")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/manifest_headers.cmake
index 9d1b9f037f..66bd9eb121 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MatchPoint Algorithm Browser")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager org.mitk.matchpoint.core.helper)
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/manifest_headers.cmake
index 7dabe1ee55..a119aa7b04 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MatchPoint Algorithm Control")
 set(Plugin-Version "0.2")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager org.mitk.matchpoint.core.helper)
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/manifest_headers.cmake
index 6a307ded95..f04fd4c29e 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MatchPoint Registration Evaluator")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager)
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.framereg/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.matchpoint.framereg/manifest_headers.cmake
index 991e0f6b7d..40921fa01d 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.framereg/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.matchpoint.framereg/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MatchPoint Frame Correction")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager org.mitk.matchpoint.core.helper)
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/manifest_headers.cmake
index e8e01074da..07fd6d195c 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MatchPoint Registration Manipulator")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager)
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.mapper/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.matchpoint.mapper/manifest_headers.cmake
index d3ad93def4..ebdedc4bc3 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.mapper/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.matchpoint.mapper/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MatchPoint Data Mapper")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager)
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/manifest_headers.cmake
index 71ef009f9e..99a2c9228f 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MatchPoint Registration Visualizer")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager)
diff --git a/Plugins/org.mitk.gui.qt.materialeditor/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.materialeditor/manifest_headers.cmake
index 91c055ee03..a76fffae0a 100644
--- a/Plugins/org.mitk.gui.qt.materialeditor/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.materialeditor/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Material Editor")
 set(Plugin-Version "0.9")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.measurementtoolbox/manifest_headers.cmake
index 9d77595dc0..c2e1719337 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/manifest_headers.cmake
@@ -1,8 +1,8 @@
 set(Plugin-Name "MITK Measurement")
 set(Plugin-Version "1.0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin
  org.mitk.gui.qt.common
  org.blueberry.ui.qt
  )
diff --git a/Plugins/org.mitk.gui.qt.mitkworkbench.intro/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.mitkworkbench.intro/manifest_headers.cmake
index 558878f25c..6688a63e49 100644
--- a/Plugins/org.mitk.gui.qt.mitkworkbench.intro/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.mitkworkbench.intro/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Workbench Intro")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.extapplication)
diff --git a/Plugins/org.mitk.gui.qt.mitkworkbench.intro/resources/WelcomePresentation.html b/Plugins/org.mitk.gui.qt.mitkworkbench.intro/resources/WelcomePresentation.html
index 386057ff4d..a9e59ac637 100644
--- a/Plugins/org.mitk.gui.qt.mitkworkbench.intro/resources/WelcomePresentation.html
+++ b/Plugins/org.mitk.gui.qt.mitkworkbench.intro/resources/WelcomePresentation.html
@@ -1,286 +1,286 @@
 <!doctype html>
 
 <meta http-equiv="X-UA-Compatible" content="IE=11,IE=10,IE=9,IE=8" />
 
 <html lang="en">
     <head>
       <meta charset="utf-8">
       <title>May I introduce you to MITK?</title>
       <meta name="description" content="A short introduction into working with the MITK Workbench">
       <meta name="author" content="German Cancer Research Center (DKFZ)">
 
       <link rel="stylesheet" href="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/css/reveal.css">
       <link rel="stylesheet" href="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/css/theme/MITK.css" id="theme">
 
       <!-- Code syntax highlighting -->
       <link rel="stylesheet" href="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/lib/css/zenburn.css">
     </head>
 
     <body>
         <div class="reveal">
             <!-- Any section element inside of this container is displayed as a slide -->
             <div class="slides">
 
 <!-- Main page + navigation help -->
                 <section>
                     <section>
                         <br>
                         <br>
                         <br>
                         <br>
                         <h2>May I introduce you to MITK?</h2>
                         <br>
                         <br>
                         <br>
                         <br>
                         <p style="text-align: bottom; color: rgb(144, 144, 144)"><small>For a short explanation of the navigation through the tutorial, press <strong>DOWN</strong>.</small></p>
                         <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/ArrowDown.png" style="position: absolute; bottom: 5%; right: 5%; width: 5%; box-shadow: none" />
                     </section>
                     <section>
                         <h4>Navigation through the tutorial slides</h4>
                         <p style="text-align: left"><small>In the lower right corner you see <strong>four arrows</strong> for navigation through the slides.</small></p>
                         <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/ControlArrows.png" style="position: absolute; top: 23%; left: 45%; width: 10%" />
                         <br>
                         <br>
                         <br>
                         <p style="text-align: left"><small>If an arrow turns <strong>bold</strong>, you can follow it in this direction either using your <strong>mouse or keyboard</strong>. </small></p>
                         <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MouseTangoStyle.svg" style="position: absolute; bottom: 27%; left: 40%; height: 12%; box-shadow: none" />
                         <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/ArrowKeys.png" style="position: absolute; bottom: 27%; right: 37%; height: 12%; box-shadow: none" />
                         <br>
                         <p style="text-align: left"><small>Besides the arrow keys you can also use the <strong>space bar</strong>, </br>to navigate you through all slides.</small></p>
                         <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/Spacebar.png" style="position: absolute; bottom: 16%; right: 25%; width: 12%; box-shadow: none" />
                         <p style="text-align: left"><small>When you press "<strong>Esc</strong>", you will see an overview about all the available slides.</small></p>
                         <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/Esc.png" style="position: absolute; bottom: 6%; right: 15%; width: 5%; box-shadow: none" />
                         <!-- This seems to not work in the QtWebkit
                         <p style="text-align: left"><small>With <strong>Alt + clicking</strong> on a certain spot in the slide, you can zoom in.</small></p>
                         <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/Alt.png" style="position: absolute; bottom: 5%; right: 26%; width: 5%; box-shadow: none" />
                         <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MousePointerClick.png" style="position: absolute; bottom: 5%; right: 20%; width: 5%; box-shadow: none" />
                         -->
                     </section>
                 </section>
 
 
 <!-- Welcome Page in MITK - 1 -->
 
                 <section>
                     <h3>Welcome Page</h3>
                     <br>
                     <p style="text-align: right;"><small>The first window you will see, is the <br><strong>Welcome Page</strong>!</small></p>
                     <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/WelcomePage.png" style="position: absolute; left: 5%; top: 20% ; width: 50%; border: none" />
                     <br>
                     <p class="fragment" data-fragment-index="0" style="text-align: right"><small>You can always reopen it by clicking on <br>"<em>Help</em>" and then "<em>Welcome</em>".<br> To return there from this presentation<br> click the MITK logo in the lower left corner.</small></p>
                     <img class="fragment current-visible" data-fragment-index="0" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/HelpWelcome.png" style="position: absolute; left: 0%; top: 15%; width: 25%; border: none" />
                     <br>
                     <br>
                     <br>
                     <p class="fragment" data-fragment-index="1" class="fragment" style="text-align: center"><small>Here you can find links to further on-line tutorials and related documentation.</small></p>
                     <img class="fragment current-visible" data-fragment-index="1" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MITKArrow.png" style="position: absolute; right: 38%; bottom: 33%; width: 15%; border: none; box-shadow: none; background: none; -webkit-transform: rotate(-145deg); transform: rotate(-145deg)" />
                     <br>
                 </section>
 
 
 <!-- Overview MITK Window - 2 -->
 
                 <section>
                     <h3>Window overview</h3>
                     <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/ScreenScanPlugins.png" style="position: absolute; left: 5%; top: 15%; width: 50%; border: none" />
                     <br>
                     <p class="fragment" data-fragment-index="0" style="text-align: right"><small>On the upper border you find the <strong>Toolbar</strong><br> with shortcuts to all important functions.</small></p>
                     <img class="fragment current-visible" data-fragment-index="0" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/Toolbar.png" style="position: absolute; top: 15%; left: 0%; width: 90%; border: none" />
                     <br>
                     <p class="fragment" data-fragment-index="1" style="text-align: right"><small>Your images and results appear <br>in the <strong>Display area</strong> in 2D and 3D views.</small></p>
                     <img class="fragment current-visible" data-fragment-index="1" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/DisplayAreaSmall.png" style="position: absolute; left: 13%; top: 17%; width: 35%" />
                     <br>
                     <br>
                     <br>
                     <br>
                     <p class="fragment" data-fragment-index="2" style="text-align: left"><small>Tools are called <em>Plugins</em> in MITK. After opening they appear to the sides of the display area by default. </small></p>
                     <img class="fragment current-visible" data-fragment-index="2" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MITKArrow.png" style="position: absolute; left: 5%; bottom: 20%; width: 10%; -webkit-transform: rotate(-90deg); transform: rotate(-90deg); box-shadow: none" />
                     <img class="fragment current-visible" data-fragment-index="2" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MITKArrow.png" style="position: absolute; left: 45%; bottom: 20%; width: 10%; -webkit-transform: rotate(-90deg); transform: rotate(-90deg); box-shadow: none" />
                 </section>
 
 
 <!-- Toolbar  - 3 -->
 
                 <section>
                     <h3>Toolbar</h3>
                     <p class="fragment" data-fragment-index="0" style="text-align: left"><small>You can access the main functions with the buttons on the left side of the toolbar.</small></p>
                     <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/ScreenWithScan.png" style="position: absolute; bottom: 0%; left: 28%; width: 44%;" data-fragment-index="0" />
                     <div class="fragment current-visible" data-fragment-index="0" style="position: absolute; bottom: 45%; left: 27%; width: 21%; height: 2%; border-radius: 10px 10px 10px 10px; border: 5px solid #2d5a88"></div>
                     <img class="fragment current-visible" data-fragment-index="0" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/ToolbarLeft.png" style="position: absolute; left: 3%; bottom: 49%; width: 55%" />
                     <ul class="fragment current-visible" data-fragment-index="0" style="position: absolute; left: 0%; bottom: 15%"><small>
                         <li>Open File</li>
                         <li>Save/Close Project</li>
                         <li>Undo/Redo</li>
                         <li>Image Navigator</li>
                         <li>...</li>
                     </small></ul>
                     <p class="fragment" data-fragment-index="1" style="text-align: right"><small>On the right side you find the available Plugins for working on your data.</small></p>
                     <div class="fragment current-visible" data-fragment-index="1" style="position: absolute; bottom: 45%; right: 34%; width: 17%; height: 2%; border-radius: 10px 10px 10px 10px; border: 5px solid #2d5a88"></div>
                     <img class="fragment current-visible" data-fragment-index="1" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/ToolbarRight.png" style="position: absolute; right: 1%; bottom: 49%; width: 60%" />
                     <ul class="fragment current-visible" data-fragment-index="1" style="position: absolute; right: 0%; bottom: 15%"><small>
                         <p><strong>Plugins:</strong></p>
                         <li>Clipping Plane</li>
                         <li>Segmentation Utilities</li>
                         <li>Movie Maker</li>
                         <li>Image Cropper</li>
                         <li>...</li>
                     </small></ul>
                     <p class="fragment" data-fragment-index="2" style="text-align: right"><small>The <strong>help</strong> button can also be found here.</small></p>
                     <img class="fragment current-visible" data-fragment-index="2" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/IconHelp.svg" style="position: absolute; top: 34%; right: 46%; width: 5%; box-shadow: 5px 5px 10px rgba(0, 0, 0, 0.2); border-radius: 5px 5px 5px 5px; border: 2px solid rgb(45, 92, 136);" />
                     <br>
                     <br>
                     <br>
                     <br>
                     <br>
                     <br>
                     <br>
                 </section>
 
 
 <!-- Data Manager - 4 -->
 
                 <section>
                     <h3>Data Manager</h3>
                     <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/ScreenScanData.png" style="position: absolute; top: 25%; right: 0%; width: 50%; border:none" />
                     <p class="fragment" data-fragment-index="0" style="text-align: left"><small>In the <strong>Data Manager</strong> you get an overview of all your data.</small></p>
                     <img class="fragment current-visible" data-fragment-index="0"src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/IconDataManager.png" style="position: absolute; top: 15%; right: 22%; width: 5%; box-shadow: 5px 5px 10px rgba(0, 0, 0, 0.2); border-radius: 5px 5px 5px 5px; border: 2px solid rgb(45, 92, 136)" />
                     <div class="fragment current-visible" data-fragment-index="0" style="position: absolute; top: 28%; right: 23.7%; width: 1.5%; height: 2.5%; border-radius: 10px 10px 10px 10px; border: 5px solid #2d5a88"></div>
                     <div class="fragment current-visible" data-fragment-index="0" style="position: absolute; top: 30.5%; right: 38.2%; width: 11%; height: 35%; border-radius: 5px 5px 5px 5px; border: 5px solid #2d5a88"></div>
                     <br>
                     <br>
                     <br>
                     <p class="fragment" data-fragment-index="1" style="text-align: left"><small>Besides the image itself, additional objects<br> such as <strong>segmentations, 3D models, ...</strong><br> are shown</small></p>
                     <img class="fragment current-visible" data-fragment-index="1" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/DataManagerData.png" style="position: absolute; right: 34%; top: 23%; width: 30%" />
                     <br>
                     <br>
                     <br>
                     <p class="fragment" data-fragment-index="2" style="text-align: left"><small>The <strong>Image Navigator</strong> helps to scroll faster through your scans or to navigate to a certain slice.</small></p>
                     <img class="fragment" data-fragment-index="2" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/IconImageNavigator.png" style="position: absolute; bottom: 15%; left: 0%; width: 5%; box-shadow: 5px 5px 10px rgba(0, 0, 0, 0.2); border-radius: 5px 5px 5px 5px; border: 2px solid rgb(45, 92, 136)" />
                     <img class="fragment current-visible" data-fragment-index="2" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/ImageNavigator.png" style="position: absolute; bottom: 13%; right: 30%; width: 27%; border: none" />
                 </section>
 
 
 <!-- Display area - 5 -->
 
                 <section>
                     <h3>Display Area</h3>
                     <p class="fragment" data-fragment-index="0" style="text-align: left"><small>Three windows of the display area show you slices from the three different anatomical planes.</small></p>
                     <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/DisplayAreaScan.png" style="position: absolute; top: 20%; left: 5%;; width: 48%; border: none" />
                     <p class="fragment" data-fragment-index="0" style="position: absolute; left: 10%; top: 30%;color: rgb(255, 0, 0); transition: all 0.25s ease-in 0.75s; background: black"><strong>axial</strong></p>
                     <p class="fragment" data-fragment-index="0" style="position: absolute; left: 10%; top: 60%; color: rgb(0, 0, 255); transition: all 0.25s ease-in 1.25s; background: black"><strong>coronal</strong></p>
                     <p class="fragment" data-fragment-index="0" style="position: absolute; left: 35%; top: 30%; color: rgb(0, 255, 0); transition: all 0.25s ease-in 1.75s; background: black"><strong>sagittal</strong></p>
                     <br>
                     <br>
                     <br>
                     <br>
                     <p class="fragment" data-fragment-index="2" style="text-align: right; bottom: 30%"><small>On the right side is the <strong>level-window</strong><br> for adjusting the displayed </br>grey level range of the image.</small></p>
                     <br>
                     <br>
                     <br>
                     <p class="fragment" data-fragment-index="1" style="text-align: center"><small>The fourth window shows you the <strong>3D view</strong>.</small></p>
                     <p class="fragment" data-fragment-index="1" style="position: absolute; left: 35%; top: 60%; color: rgb(255, 255, 0); transition: all 0.25s ease-in 0.25s; background: black"><strong>3D</strong></p>
                     <img class="fragment current-visible" data-fragment-index="2" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/Levelwindow.png" style="position: absolute; left: 50%; top: 17%; width: 3%" />
                 </section>
 
 
 <!-- Display Windows - 6 -->
 
                 <section>
                     <h3>Display Windows</h3>
                     <p class="fragment" data-fragment-index="0" style="text-align: left"><small>A <strong>crosshair</strong> is shown in each display window to facilitate the navigation and slice selection.</small></p>
                     <p class="fragment" data-fragment-index="1" style="text-align: right"><small>On the upper right corner you have more options to customize the view,<br> for example if you want to <strong>rotate</strong> the sectional planes.</small></p>
                     <p class="fragment" data-fragment-index="2" style="text-align: right"><small>Here you can also select other <strong>layouts</strong> of the display windows.</small></p>
                     <br>
                     <br>
                     <br>
                     <br>
                     <br>
                     <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/DisplayWindowAxial.png" style="position: absolute; bottom: 0%; right: 32.5%; width: 35%; border: none" />
                     <img class="fragment current-visible" data-fragment-index="0" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MITKArrow.png" style="position: absolute; top: 40%; left: 42.3%; width: 15%;-webkit-transform: rotate(90deg); transform: rotate(90deg); background: none; box-shadow: none" />
                     <img class="fragment current-visible" data-fragment-index="1" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/DisplayWindowButtons.png" style="position: absolute; bottom: 40%; right: 31%; width: 7.5%; height: 5%; border-radius: 10px 10px 10px 10px; border: 4px solid #2d5a88" />
                     <img class="fragment" data-fragment-index="2" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MousePointerClick.png" style="position: absolute; right: 31%; top: 51%; width: 4%; box-shadow: none; background: none" />
                     <img class="fragment current-visible" data-fragment-index="2" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/LayoutList.png" style="position: absolute; right: 17%; bottom: 3%; width: 23%" />
                     <br>
                     <br>
                 </section>
 
 
 <!-- Operations with the mouse - 7 -->
 
                 <section>
                     <h3>Mouse Navigation</h3>
                     <p><small>Inside the <strong>Display area</strong> you can easily navigate through the images with your mouse.</small></p>
                     <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MouseTangoStyle.svg" style="position: absolute; bottom: 0%; left: 35%; width: 30%; box-shadow: none" />
                     <p class="fragment" data-fragment-index="0" style="position: absolute; top: 47%; left: 0%"><small><strong>Press left and move the cursor:</strong><br>Moves the crosshair in all 3 planes.</small></p>
                     <img class="fragment current-visible" data-fragment-index="0" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MITKPoint.png" style="position: absolute; width: 4%; bottom: 28%; left: 43.5%; box-shadow: none; background: none" />
                     <p class="fragment" data-fragment-index="1"><small><strong>Scrolling:</strong><br> Scrolls through the slides.</small></p>
                     <img class="fragment current-visible" data-fragment-index="1" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MITKArrow2.png" style="position: absolute; bottom: 18.5%; left: 46.6%; width: 7%; box-shadow: none; background: none" />
                     <p class="fragment" data-fragment-index="3"><small><strong>Press the scroll wheel and move:</strong><br> Shifts the section you are looking at.</small></p>
                     <br>
                     <img class="fragment current-visible" data-fragment-index="3" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MITKPoint.png" style="position: absolute; width: 4%; bottom: 30%; left: 48%; box-shadow: none; background: none" />
                     <br>
                     <p class="fragment" data-fragment-index="4" style="position: absolute; right: 0%; top: 47%"><small><strong>Right-Click and moving:</strong><br> Zooms in and out.</small></p>
                     <br>
                     <img class="fragment current-visible" data-fragment-index="4" src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MITKPoint.png" style="position: absolute; width: 4%; bottom: 28%; right: 43.5%; box-shadow: none; background: none" />
                     <br>
                     <br>
                     <br>
                 </section>
 
 
 <!-- Last page - 8 -->
 
                 <section>
                     <p>Thank you for downloading MITK!</p>
                     <br>
                     <blockquote><p><small>Press <strong style="color: rgb(249, 145, 87)">F1</strong>, to get fast access <br>to the documentation of the Plugin you're currently using!<br> Try it now inside of the <strong style="color: rgb(45, 92, 136)">Data Manager</strong> Plugin.</small></p></blockquote>
                     <br>
                     <p class="fragment" data-fragment-index="2"><small>Maybe one of the following links could also interest you:</small>
                     <ul class="fragment" data-fragment-index="2"><small>
-                        <li><a href="http://docs.mitk.org/Tutorials/OpenSaveClose.html">Load, Save and Close Projects</a></li>
-                        <li><a href="http://docs.mitk.org/Tutorials/Navigation.html">Navigation inside MITK</a></li>
+                        <li><a href="https://docs.mitk.org/Tutorials/OpenSaveClose.html">Load, Save and Close Projects</a></li>
+                        <li><a href="https://docs.mitk.org/Tutorials/Navigation.html">Navigation inside MITK</a></li>
                     </small></ul></p>
                     <p class="fragment" data-fragment-index="2" style="text-align: right; color: #2d5a88; transition: all 0.25s ease-in 0.5s">The end!</p>
                 </section>
             </div>
 
 <!-- Footer -->
             <a class="mitk-logo" href="qrc:/org.mitk.gui.qt.welcomescreen/mitkworkbenchwelcomeview.html" target="_blank">
                 <img src="qrc:/org.mitk.gui.qt.welcomescreen.welcome.tutorial/images/welcome/MITK.png">
             </a>
             <div class="footer">
               German Cancer Research Center (DKFZ) - August 2015 - created using reveal.js
             </div>
 
         </div>
 
         <script src="lib/js/head.min.js"></script>
         <script src="js/reveal.js"></script>
 
         <script>
 
             // Full list of configuration options available at:
             // https://github.com/hakimel/reveal.js#configuration
             Reveal.initialize({
                 controls: true,
                 progress: true,
                 history: true,
                 center: true,
                 fragments: true,
                 transition: 'concave', // none/fade/slide/convex/concave/zoom
 
                 // Optional reveal.js plugins
                 dependencies: [
                     { src: 'lib/js/classList.js', condition: function() { return !document.body.classList; } },
                     { src: 'plugin/markdown/marked.js', condition: function() { return !!document.querySelector( '[data-markdown]' ); } },
                     { src: 'plugin/markdown/markdown.js', condition: function() { return !!document.querySelector( '[data-markdown]' ); } },
                     { src: 'plugin/highlight/highlight.js', async: true, condition: function() { return !!document.querySelector( 'pre code' ); }, callback: function() { hljs.initHighlightingOnLoad(); } },
                     { src: 'plugin/zoom-js/zoom.js', async: true },
                     { src: 'plugin/notes/notes.js', async: true }
                 ]
             });
 
         </script>
     </body>
 </html>
diff --git a/Plugins/org.mitk.gui.qt.mitkworkbench.intro/resources/function.js b/Plugins/org.mitk.gui.qt.mitkworkbench.intro/resources/function.js
index 3d2052c51a..7238d27761 100644
--- a/Plugins/org.mitk.gui.qt.mitkworkbench.intro/resources/function.js
+++ b/Plugins/org.mitk.gui.qt.mitkworkbench.intro/resources/function.js
@@ -1,232 +1,232 @@
 // If you want to create a new button you have to add some data (strings) to the following five arrays.
 // Make sure that you add your data at the same position in each array.
 // The buttons will be generated in order to the array's index. e.g. data at array's index '0' will generate the first button.
 
 // enter the name of your module here
 var moduleNames = new Array("MITK Website",
                             "Tutorials Website");
 
 // add the MITK-link to your module
-var moduleLinks = new Array("http://www.mitk.org/",
-                            "http://mitk.org/wiki/Tutorials");
+var moduleLinks = new Array("https://www.mitk.org",
+                            "https://www.mitk.org/Tutorials");
 
 // add the filename of your icon for the module. Place the picture in subdirectory "pics".
 // The picture's width should be 136 pixel; the height 123 pixel.
 var picFilenames = new Array("button_mitk.png",
                              "button_mitk.png");
 
 // if your module is not stable, you can mark it as experimental.
 // just set true for experimental or false for stable.
 var experimental = new Array(false,
                              false);
 
 // add the description for your module. The description is displayed in a PopUp-window.
 var moduleDescriptions = new Array("Open the MITK website in an external browser.",
                                    "Open the MITK tutorials overview in an external browser.");
 
 var bttns = new Array();
 
 var d = document, da = d.all;
 
 // holds id of current mouseover-HTML-element
 var currentTarget;
 
 // get the id of current mouseover-HTML-element
 d.onmouseover = function(o){
   var e = da ? event.srcElement : o.target;
   currentTarget = e.id;
 }
 
 
 // build-function called by onload-event in HTML-document
 function createButtons(){
 
   for (i=0; i < moduleNames.length; i++){
     bttns[i] = new Button(moduleNames[i],moduleLinks[i], picFilenames[i], moduleDescriptions[i]);
     bttns[i].createButton();
   }
 
   for (i=0; i < moduleNames.length; i++){
 
     if(experimental[i]){
       setExperimental(i);
     }
   }
 
   createClearFloat();
 }
 
 // Class Button
 function Button(moduleName, moduleLink, picFilename, moduleDescr){
 
   // Properties
   this.bttnID = "bttn" + moduleName.replace(/\s/g,'');
   this.modName = moduleName;
   this.modLink = moduleLink;
   this.picPath = "qrc:/org.mitk.gui.qt.welcomescreen/pics/" + picFilename;
   this.modDescr = moduleDescr;
 
   // Methods
   this.createButton = function(){
 
     // get DIV-wrapper for Button and append it to HTML-document
     bttnWrapper = this.createWrapper();
     document.getElementById("generatedButtonField").appendChild(bttnWrapper);
 
     // Create a button and append it to document
     this.createCSSClass();
     bttnPicLink = this.createPicLink();
     bttnPicLink.href = this.modLink;
     bttnWrapper.appendChild(bttnPicLink);
 
     // create text-link and add it to DIV-wrapper
     bttnTxtLink = document.createElement("a");
     bttnTxtLink.onclick = function(){openPage();};
     bttnTxtLink.href = this.modLink;
     bttnTxtLink.className = "textLink";
     bttnTxtLink.appendChild(document.createTextNode(this.modName));
     bttnWrapper.appendChild(bttnTxtLink);
 
     // create pop-up link for module description
     if (this.modDescr.length != 0) {
       bttnPopUpLink = document.createElement("a");
       modName = this.modName;
       modDescr = this.modDescr;
       bttnPopUpLink.onclick = function(){showPopUpWindow();};
       bttnPopUpLink.className = "popUpLink";
       bttnPopUpLink.id = "popup" + this.modName;
       bttnPopUpLink.appendChild(document.createTextNode("more info >>"));
       bttnWrapper.appendChild(document.createElement("br"));
       bttnWrapper.appendChild(bttnPopUpLink);
     }
 
     return bttnPicLink;
   }
 
   this.createWrapper = function(){
     bttnWrapper = document.createElement("div");
     bttnWrapper.id = "wrapper" + this.modName;
     bttnWrapper.className = "bttnWrap";
 
     return bttnWrapper;
   }
 
   this.createPicLink = function(){
     picLink = document.createElement("a");
     picLink.id = "link" + this.modName;
     picLink.href = this.modLink;
     picLink.className = "genericButton " + this.bttnID;
 
     return picLink;
   }
 
   this.createCSSClass = function(){
     var style = document.createElement('style');
     style.type = 'text/css';
     style.innerHTML = '.' + this.bttnID +' { background-image: url(' + this.picPath +'); }';
     document.getElementsByTagName('head')[0].appendChild(style);
   }
 
 }
 
 
 function showPopUpWindow(){
 
   // modules position in array?
   modulePos = getPos(currentTarget,"popup");
 
   // get reference to anchor-element in HTML-document
   popUpAnchor = document.getElementById("popupAnchor");
 
   // check if a popUp is open
   if(popUpAnchor.hasChildNodes()){
     // if a popUp is open, remove it!
     popUpAnchor.removeChild(document.getElementById("popup"));
   }
 
   // create new container for popUp
   container = document.createElement("div");
   container.id = "popup";
   container.align = "right";
 
   // append popUp-container to HTML-document
   popUpAnchor.appendChild(container);
 
   // create close-button and append it to popUp-container
   bttnClose = document.createElement("img");
   bttnClose.src = "pics/popup_bttn_close.png";
   bttnClose.id = "bttnClose";
   bttnClose.onclick = function(){closeInfoWindow();};
   container.appendChild(bttnClose);
 
   // create container for content-elements
   contHeadline = document.createElement("div");
   contHeadline.id = "contHeadline";
   contDescription = document.createElement("div");
   contDescription.id = "contDescription";
   contModLink = document.createElement("div");
   contModLink.id = "contModLink";
 
   // append content-container to popUp-container
   container.appendChild(contHeadline);
   container.appendChild(contDescription);
   container.appendChild(contModLink);
 
   // create text-elements with content
   headline = document.createTextNode(moduleNames[modulePos] + " ");
   description = document.createTextNode(moduleDescriptions[modulePos]);
   moduleLink = document.createElement("a");
   moduleLink.href = moduleLinks[modulePos] ;
   moduleLink.className = 'moduleLink';
   moduleLinkTxt = document.createTextNode("Click here to open '" + moduleNames[modulePos].toLowerCase() + "'");
   moduleLink.appendChild(moduleLinkTxt);
 
   // append text-elements to their container
   contHeadline.appendChild(headline);
   contDescription.appendChild(description);
   contModLink.appendChild(moduleLink);
 }
 
 function getPos(id,prefix){
 
   if(prefix == "popup"){
     targetID = id.slice(5);
   }else{
     if(prefix == "bttn"){
       targetID = id.slice(4);
     }
   }
 
   for(i=0; i < moduleNames.length; i++ ){
     if(moduleNames[i] == targetID){
       return i;
     }
   }
 }
 
 function setExperimental(modPos){
   linkID = "link" + moduleNames[modPos];
 
   expPic = document.createElement("img");
   expPic.src = "pics/experimental.png";
   expPic.className = "expPic";
 
   document.getElementById(linkID).appendChild(expPic);
 }
 
 
 function openPage(){
-  window.open("http://www.mitk.org","_blank");
+  window.open("https://www.mitk.org","_blank");
 }
 
 // function to close PopUp-window
 function closeInfoWindow(){
   popUpAnchor = document.getElementById("popupAnchor");
   popUpAnchor.removeChild(document.getElementById("popup"));
 }
 
 function createClearFloat(){
   cf = document.createElement("div");
   cf.className = "clearfloat";
   document.getElementById("generatedButtonField").appendChild(cf);
 }
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.moviemaker/manifest_headers.cmake
index d852eaea93..a6d65804d0 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.moviemaker/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Movie Maker")
 set(Plugin-Version "0.9")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.ext)
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.multilabelsegmentation/manifest_headers.cmake
index 97ba4ee1c4..0821c13120 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK MultiLabelSegmentation")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager org.mitk.gui.qt.segmentation)
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/manifest_headers.cmake
index 3f743d0a72..a1651e67d1 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK MxN Multi Widget Editor")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "DKFZ, Division of Medical Image Computing")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteraction/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.pointsetinteraction/manifest_headers.cmake
index 95f01457c3..0fd9f707e1 100644
--- a/Plugins/org.mitk.gui.qt.pointsetinteraction/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.pointsetinteraction/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Pointset Interaction")
 set(Plugin-Version "0.9")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.preprocessing.resampling/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.preprocessing.resampling/manifest_headers.cmake
index c189578b09..1072a6d5b3 100644
--- a/Plugins/org.mitk.gui.qt.preprocessing.resampling/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.preprocessing.resampling/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Preprocessing Resampling")
 set(Plugin-Version "1.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.properties/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.properties/manifest_headers.cmake
index 14c703f95b..ee430e7221 100644
--- a/Plugins/org.mitk.gui.qt.properties/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.properties/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Properties")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.python/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.python/manifest_headers.cmake
index 3c21bc8d85..3aaa799b06 100644
--- a/Plugins/org.mitk.gui.qt.python/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.python/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Python")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.radiomics/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.radiomics/manifest_headers.cmake
index 866460e81c..5a481d9578 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.radiomics/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Radiomics")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.remeshing/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.remeshing/manifest_headers.cmake
index e207d0cd63..1368f6e31c 100644
--- a/Plugins/org.mitk.gui.qt.remeshing/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.remeshing/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Remeshing")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.datamanager)
diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.renderwindowmanager/manifest_headers.cmake
index 72676e48b5..f1d9729a06 100644
--- a/Plugins/org.mitk.gui.qt.renderwindowmanager/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Render window layer manager")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "DKFZ")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.application org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.segmentation/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.segmentation/manifest_headers.cmake
index ebbe089424..7e0bdb14d2 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.segmentation/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Segmentation")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager)
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.semanticrelations/manifest_headers.cmake
index a413decc69..ed90be50bd 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Semantic relations")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "DKFZ")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.application org.mitk.gui.qt.segmentation)
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/manifest_headers.cmake
index 78fcab2418..e3da88e427 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "MITK StdMultiWidget Editor")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
 
diff --git a/Plugins/org.mitk.gui.qt.tubegraph/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.tubegraph/manifest_headers.cmake
index 2132381979..2b6a1b533c 100644
--- a/Plugins/org.mitk.gui.qt.tubegraph/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.tubegraph/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Tube Graph")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.ugvisualization/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.ugvisualization/manifest_headers.cmake
index aff0e3e5ff..04b75418be 100644
--- a/Plugins/org.mitk.gui.qt.ugvisualization/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.ugvisualization/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK UG Visualization")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.volumevisualization/manifest_headers.cmake
index 1138a3beab..e87848ea23 100644
--- a/Plugins/org.mitk.gui.qt.volumevisualization/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Volume Visualization")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.matchpoint.core.helper/manifest_headers.cmake b/Plugins/org.mitk.matchpoint.core.helper/manifest_headers.cmake
index 75ccee3db6..d4c6c20278 100644
--- a/Plugins/org.mitk.matchpoint.core.helper/manifest_headers.cmake
+++ b/Plugins/org.mitk.matchpoint.core.helper/manifest_headers.cmake
@@ -1,6 +1,6 @@
 SET(Plugin-Name "MAP MITK Core Helper")
 SET(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.common)
 set(Plugin-ActivationPolicy eager)
diff --git a/Plugins/org.mitk.planarfigure/manifest_headers.cmake b/Plugins/org.mitk.planarfigure/manifest_headers.cmake
index bf4a43d8bd..1d6c61fc2f 100644
--- a/Plugins/org.mitk.planarfigure/manifest_headers.cmake
+++ b/Plugins/org.mitk.planarfigure/manifest_headers.cmake
@@ -1,6 +1,6 @@
 set(Plugin-Name "MITK PlanarFigure")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
+set(Plugin-ContactAddress "https://www.mitk.org")
 set(Require-Plugin org.mitk.gui.common)
 set(Plugin-ActivationPolicy eager)
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index d3fee6b98c..1ab1ad5f59 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,502 +1,502 @@
 #-----------------------------------------------------------------------------
 # Convenient macro allowing to download a file
 #-----------------------------------------------------------------------------
 
 if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL)
-  set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty)
+  set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL https://www.mitk.org/download/thirdparty)
 endif()
 
 macro(downloadFile url dest)
   file(DOWNLOAD ${url} ${dest} STATUS status)
   list(GET status 0 error_code)
   list(GET status 1 error_msg)
   if(error_code)
     message(FATAL_ERROR "error: Failed to download ${url} - ${error_msg}")
   endif()
 endmacro()
 
 #-----------------------------------------------------------------------------
 # MITK Prerequisites
 #-----------------------------------------------------------------------------
 
 if(UNIX AND NOT APPLE)
 
   include(mitkFunctionCheckPackageHeader)
 
   # Check for libxt-dev
   mitkFunctionCheckPackageHeader(StringDefs.h libxt-dev /usr/include/X11/)
 
   # Check for libtiff4-dev
   mitkFunctionCheckPackageHeader(tiff.h libtiff4-dev)
 
 endif()
 
 # We need a proper patch program. On Linux and MacOS, we assume
 # that "patch" is available. On Windows, we download patch.exe
 # if not patch program is found.
 find_program(PATCH_COMMAND patch)
 if((NOT PATCH_COMMAND OR NOT EXISTS ${PATCH_COMMAND}) AND WIN32)
   downloadFile(${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/patch.exe
                ${CMAKE_CURRENT_BINARY_DIR}/patch.exe)
   find_program(PATCH_COMMAND patch ${CMAKE_CURRENT_BINARY_DIR})
 endif()
 if(NOT PATCH_COMMAND)
   message(FATAL_ERROR "No patch program found.")
 endif()
 
 #-----------------------------------------------------------------------------
 # ExternalProjects
 #-----------------------------------------------------------------------------
 
 get_property(external_projects GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
 
 if(MITK_CTEST_SCRIPT_MODE)
   # Write a file containing the list of enabled external project targets.
   # This file can be read by a ctest script to separately build projects.
   set(SUPERBUILD_TARGETS )
   foreach(proj ${external_projects})
     if(MITK_USE_${proj})
       list(APPEND SUPERBUILD_TARGETS ${proj})
     endif()
   endforeach()
   file(WRITE "${CMAKE_BINARY_DIR}/SuperBuildTargets.cmake" "set(SUPERBUILD_TARGETS ${SUPERBUILD_TARGETS})")
 endif()
 
 # A list of "nice" external projects, playing well together with CMake
 set(nice_external_projects ${external_projects})
 list(REMOVE_ITEM nice_external_projects Boost)
 foreach(proj ${nice_external_projects})
   if(MITK_USE_${proj})
     set(EXTERNAL_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory")
     mark_as_advanced(EXTERNAL_${proj}_DIR)
     if(EXTERNAL_${proj}_DIR)
       set(${proj}_DIR ${EXTERNAL_${proj}_DIR})
     endif()
   endif()
 endforeach()
 
 set(EXTERNAL_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory")
 mark_as_advanced(EXTERNAL_BOOST_ROOT)
 if(EXTERNAL_BOOST_ROOT)
   set(BOOST_ROOT ${EXTERNAL_BOOST_ROOT})
 endif()
 
 if(BUILD_TESTING)
   set(EXTERNAL_MITK_DATA_DIR "${MITK_DATA_DIR}" CACHE PATH "Path to the MITK data directory")
   mark_as_advanced(EXTERNAL_MITK_DATA_DIR)
   if(EXTERNAL_MITK_DATA_DIR)
     set(MITK_DATA_DIR ${EXTERNAL_MITK_DATA_DIR})
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # External project settings
 #-----------------------------------------------------------------------------
 
 include(ExternalProject)
 include(mitkMacroQueryCustomEPVars)
 include(mitkFunctionInstallExternalCMakeProject)
 include(mitkFunctionCleanExternalProject)
 
 option(MITK_AUTOCLEAN_EXTERNAL_PROJECTS "Experimental: Clean external project builds if updated" ON)
 
 set(ep_prefix "${CMAKE_BINARY_DIR}/ep")
 set_property(DIRECTORY PROPERTY EP_PREFIX ${ep_prefix})
 
 # Compute -G arg for configuring external projects with the same CMake generator:
 if(CMAKE_EXTRA_GENERATOR)
   set(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
 else()
   set(gen "${CMAKE_GENERATOR}")
 endif()
 
 set(gen_platform ${CMAKE_GENERATOR_PLATFORM})
 
 # Use this value where semi-colons are needed in ep_add args:
 set(sep "^^")
 
 ##
 
 if(MSVC_VERSION)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
 endif()
 
 # This is a workaround for passing linker flags
 # actually down to the linker invocation
 set(_cmake_required_flags_orig ${CMAKE_REQUIRED_FLAGS})
 set(CMAKE_REQUIRED_FLAGS "-Wl,-rpath")
 mitkFunctionCheckCompilerFlags(${CMAKE_REQUIRED_FLAGS} _has_rpath_flag)
 set(CMAKE_REQUIRED_FLAGS ${_cmake_required_flags_orig})
 
 set(_install_rpath_linkflag )
 if(_has_rpath_flag)
   if(APPLE)
     set(_install_rpath_linkflag "-Wl,-rpath,@loader_path/../lib")
   else()
     set(_install_rpath_linkflag "-Wl,-rpath='$ORIGIN/../lib'")
   endif()
 endif()
 
 set(_install_rpath)
 if(APPLE)
   set(_install_rpath "@loader_path/../lib")
 elseif(UNIX)
   # this work for libraries as well as executables
   set(_install_rpath "\$ORIGIN/../lib")
 endif()
 
 set(ep_common_args
   -DCMAKE_POLICY_DEFAULT_CMP0091:STRING=OLD
   -DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
   -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
   -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
   -DCMAKE_MACOSX_RPATH:BOOL=TRUE
   "-DCMAKE_INSTALL_RPATH:STRING=${_install_rpath}"
   -DBUILD_TESTING:BOOL=OFF
   -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
   -DBUILD_SHARED_LIBS:BOOL=ON
   -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
   -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
   -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
   -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
   "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_CXX${MITK_CXX_STANDARD}_FLAG}"
   #debug flags
   -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
   -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
   #release flags
   -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
   -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
   #relwithdebinfo
   -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
   -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
   #link flags
   -DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
   -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS}
   -DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS}
 )
 
 if(MSVC_VERSION)
   list(APPEND ep_common_args
     -DCMAKE_DEBUG_POSTFIX:STRING=d
   )
 
   set(DCMTK_CMAKE_DEBUG_POSTFIX d)
 endif()
 
 set(ep_common_cache_args
 )
 
 set(ep_common_cache_default_args
   "-DCMAKE_PREFIX_PATH:PATH=<INSTALL_DIR>;${CMAKE_PREFIX_PATH}"
   "-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
   "-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
 )
 
 # Pass the CMAKE_OSX variables to external projects
 if(APPLE)
   set(MAC_OSX_ARCHITECTURE_ARGS
         -DCMAKE_OSX_ARCHITECTURES:PATH=${CMAKE_OSX_ARCHITECTURES}
         -DCMAKE_OSX_DEPLOYMENT_TARGET:PATH=${CMAKE_OSX_DEPLOYMENT_TARGET}
         -DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT}
   )
   set(ep_common_args
         ${MAC_OSX_ARCHITECTURE_ARGS}
         ${ep_common_args}
   )
 endif()
 
 set(mitk_superbuild_ep_args)
 set(mitk_depends )
 
 # Include external projects
 include(CMakeExternals/MITKData.cmake)
 foreach(p ${external_projects})
   set(p_hash "")
 
   set(p_file "${CMAKE_SOURCE_DIR}/CMakeExternals/${p}.cmake")
   if(EXISTS ${p_file})
     file(MD5 ${p_file} p_hash)
   else()
     foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
       set(MITK_CMAKE_EXTERNALS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMakeExternals")
       set(p_file "${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/${p}.cmake")
       if(EXISTS "${p_file}")
         file(MD5 "${p_file}" p_hash)
         break()
       endif()
     endforeach()
   endif()
 
   if(p_hash)
     set(p_hash_file "${ep_prefix}/tmp/${p}-hash.txt")
     if(MITK_AUTOCLEAN_EXTERNAL_PROJECTS)
       if(EXISTS "${p_hash_file}")
         file(READ "${p_hash_file}" p_prev_hash)
         if(NOT p_hash STREQUAL p_prev_hash)
           mitkCleanExternalProject(${p})
         endif()
       endif()
     endif()
     file(WRITE "${p_hash_file}" ${p_hash})
   endif()
 
   include("${p_file}" OPTIONAL)
 
   list(APPEND mitk_superbuild_ep_args
        -DMITK_USE_${p}:BOOL=${MITK_USE_${p}}
       )
   get_property(_package GLOBAL PROPERTY MITK_${p}_PACKAGE)
   if(_package)
     list(APPEND mitk_superbuild_ep_args -D${p}_DIR:PATH=${${p}_DIR})
   endif()
 
   list(APPEND mitk_depends ${${p}_DEPENDS})
 endforeach()
 if (SWIG_EXECUTABLE)
   list(APPEND mitk_superbuild_ep_args -DSWIG_EXECUTABLE=${SWIG_EXECUTABLE})
 endif()
 
 #-----------------------------------------------------------------------------
 # Set superbuild boolean args
 #-----------------------------------------------------------------------------
 
 set(mitk_cmake_boolean_args
   BUILD_SHARED_LIBS
   WITH_COVERAGE
   BUILD_TESTING
   MITK_BUILD_ALL_PLUGINS
   MITK_BUILD_ALL_APPS
   MITK_BUILD_EXAMPLES
   MITK_USE_Qt5
   MITK_USE_SYSTEM_Boost
   MITK_USE_BLUEBERRY
   MITK_USE_OpenCL
   MITK_USE_OpenMP
   )
 
 #-----------------------------------------------------------------------------
 # Create the final variable containing superbuild boolean args
 #-----------------------------------------------------------------------------
 
 set(mitk_superbuild_boolean_args)
 foreach(mitk_cmake_arg ${mitk_cmake_boolean_args})
   list(APPEND mitk_superbuild_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}})
 endforeach()
 
 if(MITK_BUILD_ALL_PLUGINS)
   list(APPEND mitk_superbuild_boolean_args -DBLUEBERRY_BUILD_ALL_PLUGINS:BOOL=ON)
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK Utilities
 #-----------------------------------------------------------------------------
 
 set(proj MITK-Utilities)
 ExternalProject_Add(${proj}
   DOWNLOAD_COMMAND ""
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     ${mitk_depends}
 )
 #-----------------------------------------------------------------------------
 # Additional MITK CXX/C Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags for MITK")
 set(MITK_ADDITIONAL_C_FLAGS_RELEASE "" CACHE STRING "Additional Release C Flags for MITK")
 set(MITK_ADDITIONAL_C_FLAGS_DEBUG "" CACHE STRING "Additional Debug C Flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_C_FLAGS MITK_ADDITIONAL_C_FLAGS_DEBUG MITK_ADDITIONAL_C_FLAGS_RELEASE)
 
 set(MITK_ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags for MITK")
 set(MITK_ADDITIONAL_CXX_FLAGS_RELEASE "" CACHE STRING "Additional Release CXX Flags for MITK")
 set(MITK_ADDITIONAL_CXX_FLAGS_DEBUG "" CACHE STRING "Additional Debug CXX Flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_CXX_FLAGS MITK_ADDITIONAL_CXX_FLAGS_DEBUG MITK_ADDITIONAL_CXX_FLAGS_RELEASE)
 
 set(MITK_ADDITIONAL_EXE_LINKER_FLAGS "" CACHE STRING "Additional exe linker flags for MITK")
 set(MITK_ADDITIONAL_SHARED_LINKER_FLAGS "" CACHE STRING "Additional shared linker flags for MITK")
 set(MITK_ADDITIONAL_MODULE_LINKER_FLAGS "" CACHE STRING "Additional module linker flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_EXE_LINKER_FLAGS MITK_ADDITIONAL_SHARED_LINKER_FLAGS MITK_ADDITIONAL_MODULE_LINKER_FLAGS)
 
 #-----------------------------------------------------------------------------
 # MITK Configure
 #-----------------------------------------------------------------------------
 
 if(MITK_INITIAL_CACHE_FILE)
   set(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}")
 endif()
 
 set(mitk_optional_cache_args )
 foreach(type RUNTIME ARCHIVE LIBRARY)
   if(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
     list(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
   endif()
 endforeach()
 
 if(MITK_USE_OpenCV)
   list(APPEND mitk_optional_cache_args "-DCMAKE_CONFIGURATION_TYPES:STRING=Debug$<SEMICOLON>Release")
 endif()
 
 # Optional python variables
 if(MITK_USE_Python3)
   list(APPEND mitk_optional_cache_args
        -DMITK_USE_Python3:BOOL=${MITK_USE_Python3}
        "-DPython3_EXECUTABLE:FILEPATH=${Python3_EXECUTABLE}"
        "-DPython3_INCLUDE_DIR:PATH=${Python3_INCLUDE_DIRS}"
        "-DPython3_LIBRARY:FILEPATH=${Python3_LIBRARY}"
        "-DPython3_STDLIB:FILEPATH=${Python3_STDLIB}"
        "-DPython3_SITELIB:FILEPATH=${Python3_SITELIB}"
       )
 endif()
 
 if(OPENSSL_ROOT_DIR)
   list(APPEND mitk_optional_cache_args
     "-DOPENSSL_ROOT_DIR:PATH=${OPENSSL_ROOT_DIR}"
   )
 endif()
 
 if(CMAKE_FRAMEWORK_PATH)
   list(APPEND mitk_optional_cache_args
     "-DCMAKE_FRAMEWORK_PATH:PATH=${CMAKE_FRAMEWORK_PATH}"
   )
 endif()
 
 if(Eigen_INCLUDE_DIR)
     list(APPEND mitk_optional_cache_args
       -DEigen_INCLUDE_DIR:PATH=${Eigen_INCLUDE_DIR}
     )
 endif()
 
 # Optional pass through of Doxygen
 if(DOXYGEN_EXECUTABLE)
   list(APPEND mitk_optional_cache_args
        -DDOXYGEN_EXECUTABLE:FILEPATH=${DOXYGEN_EXECUTABLE}
   )
 endif()
 
 if(MITK_DOXYGEN_BUILD_ALWAYS)
   list(APPEND mitk_optional_cache_args
     -DMITK_DOXYGEN_BUILD_ALWAYS:BOOL=${MITK_DOXYGEN_BUILD_ALWAYS}
   )
 endif()
 
 set(proj MITK-Configure)
 
 ExternalProject_Add(${proj}
   LIST_SEPARATOR ${sep}
   DOWNLOAD_COMMAND ""
   CMAKE_GENERATOR ${gen}
   CMAKE_GENERATOR_PLATFORM ${gen_platform}
   CMAKE_CACHE_ARGS
     # --------------- Build options ----------------
     -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
     "-DCMAKE_PREFIX_PATH:PATH=${ep_prefix};${CMAKE_PREFIX_PATH}"
     "-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
     "-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
     # --------------- Compile options ----------------
     -DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
     -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
     -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
     -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
     -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
     "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${MITK_ADDITIONAL_C_FLAGS}"
     "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_ADDITIONAL_CXX_FLAGS}"
     # debug flags
     "-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} ${MITK_ADDITIONAL_CXX_FLAGS_DEBUG}"
     "-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} ${MITK_ADDITIONAL_C_FLAGS_DEBUG}"
     # release flags
     "-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} ${MITK_ADDITIONAL_CXX_FLAGS_RELEASE}"
     "-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} ${MITK_ADDITIONAL_C_FLAGS_RELEASE}"
     # relwithdebinfo
     -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
     -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
     # link flags
     "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} ${MITK_ADDITIONAL_EXE_LINKER_FLAGS}"
     "-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} ${MITK_ADDITIONAL_SHARED_LINKER_FLAGS}"
     "-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ${MITK_ADDITIONAL_MODULE_LINKER_FLAGS}"
     # Output directories
     -DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
     # ------------- Boolean build options --------------
     ${mitk_superbuild_boolean_args}
     ${mitk_optional_cache_args}
     -DMITK_USE_SUPERBUILD:BOOL=OFF
     -DMITK_BUILD_CONFIGURATION:STRING=${MITK_BUILD_CONFIGURATION}
     -DMITK_FAST_TESTING:BOOL=${MITK_FAST_TESTING}
     -DMITK_XVFB_TESTING:BOOL=${MITK_XVFB_TESTING}
     -DMITK_XVFB_TESTING_COMMAND:STRING=${MITK_XVFB_TESTING_COMMAND}
     -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
     # ----------------- Miscellaneous ---------------
     -DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}
     -DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}
     -DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE}
     -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
     -DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD}
     -DMITK_WHITELIST:STRING=${MITK_WHITELIST}
     -DMITK_WHITELISTS_EXTERNAL_PATH:STRING=${MITK_WHITELISTS_EXTERNAL_PATH}
     -DMITK_WHITELISTS_INTERNAL_PATH:STRING=${MITK_WHITELISTS_INTERNAL_PATH}
     -DMITK_EXTENSION_DIRS:STRING=${MITK_EXTENSION_DIRS}
     -DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_VECTOR_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS}
     -DMITK_CUSTOM_REVISION_DESC:STRING=${MITK_CUSTOM_REVISION_DESC}
     # --------------- External project options ---------------
     -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
     -DMITK_EXTERNAL_PROJECT_PREFIX:PATH=${ep_prefix}
     -DCppMicroServices_DIR:PATH=${CppMicroServices_DIR}
     -DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=${DCMTK_CMAKE_DEBUG_POSTFIX}
     -DBOOST_ROOT:PATH=${BOOST_ROOT}
     -DBOOST_LIBRARYDIR:PATH=${BOOST_LIBRARYDIR}
     -DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
     -DQt5_DIR:PATH=${Qt5_DIR}
   CMAKE_ARGS
     ${mitk_initial_cache_arg}
     ${MAC_OSX_ARCHITECTURE_ARGS}
     ${mitk_superbuild_ep_args}
   SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
   BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     MITK-Utilities
   )
 
 mitkFunctionInstallExternalCMakeProject(${proj})
 
 #-----------------------------------------------------------------------------
 # MITK
 #-----------------------------------------------------------------------------
 
 if(CMAKE_GENERATOR MATCHES ".*Makefiles.*")
   set(mitk_build_cmd "$(MAKE)")
 else()
   set(mitk_build_cmd ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build --config ${CMAKE_CFG_INTDIR})
 endif()
 
 if(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET)
   set(MITKBUILD_TARGET_ALL_OPTION "ALL")
 else()
   set(MITKBUILD_TARGET_ALL_OPTION "")
 endif()
 
 add_custom_target(MITK-build ${MITKBUILD_TARGET_ALL_OPTION}
   COMMAND ${mitk_build_cmd}
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
   DEPENDS MITK-Configure
   )
 
 #-----------------------------------------------------------------------------
 # Custom target allowing to drive the build of the MITK project itself
 #-----------------------------------------------------------------------------
 
 add_custom_target(MITK
   COMMAND ${mitk_build_cmd}
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
 )
 
diff --git a/Wrapping/Python/Packaging/setup.py.in b/Wrapping/Python/Packaging/setup.py.in
index 54812dd410..f30f98f31e 100644
--- a/Wrapping/Python/Packaging/setup.py.in
+++ b/Wrapping/Python/Packaging/setup.py.in
@@ -1,133 +1,133 @@
 import sys
 import os
 import glob
 import itertools as it
 
 def multiple_file_types(path, *patterns):
     return it.chain.from_iterable(glob.iglob(os.path.join(path,pattern)) for pattern in patterns)
 
 try:
     from setuptools import setup, Extension
     from setuptools.command.build_ext import build_ext as _build_ext
 except ImportError:
     from distutils.core import setup, Extension
     from distutils.command.build_ext import build_ext as _build_ext
 
 import re
 
 doc_files = ""
 dependency_paths = "@MITK_RUNTIME_PATH@"
 dependency_files = "@PYTHON_LIB_DEPENDENCIES@"
 binary_module_file = "@TMP_MITK_BINARY_MODULE@"
 
 def get_pep386version():
     """This method examines the MITK's CMake version variables to make a pep 386 compliant version string when building a version indented for distribution."""
     sitkMAJOR = "@MITK_VERSION_MAJOR@"
     sitkMINOR = "@MITK_VERSION_MINOR@"
     sitkPATCH = "@MITK_VERSION_PATCH@"
     sitkTWEAK = "@MITK_VERSION_TWEAK@"
     sitkRC    = "@MITK_VERSION_RC@"
     sitkPOST  = "@MITK_VERSION_POST@"
     sitkDEV   = "@MITK_VERSION_DEV@"
     sitkHASH  = "@MITK_VERSION_HASH@"
 
 
     version = sitkMAJOR+"."+sitkMINOR
 
     if sitkPATCH:
         version += "."+sitkPATCH
         if sitkTWEAK:
             version += "."+sitkTWEAK
 
     if  sitkRC:
         version += sitkRC
 
     if sitkPOST:
         version += ".post"+sitkPOST
     elif sitkDEV:
         version += ".dev"+sitkDEV
 
     # Local Version Identifier
     if sitkHASH and not "@MITK_BUILD_DISTRIBUTE@" in ['1', 'ON']:
         version += "+g"+sitkHASH
 
     return version
 
 class build_ext(_build_ext):
     """ Override standard command class to build an extension, to
     simply copy an existing compiled library into the packaging
     directory structure.
     """
 
     def build_extension(self, ext):
         """
         """
         from distutils.errors import DistutilsSetupError
 
         sources = ext.sources
         if sources is None or not len(sources) == 1:
             raise DistutilsSetupError( "Expected only one compiled library." )
 
         expected_ext_filename = os.path.split(self.get_ext_filename(ext.name))[1]
 
         ext_file = self.get_ext_fullpath(ext.name)
 
         abs_sources = list( map(os.path.abspath, sources) )
 
         module_name=ext.name.split(".")[0]
         placeholder = self.get_ext_filename("placeholder")
 
         for current_path in dependency_paths.split(";"):
            for library_file in multiple_file_types(current_path, "*.pyd","*.so"):
               if binary_module_file in library_file:
                  self.copy_file(library_file, ext_file)
                  continue
            # Do not copy .so - files manually. They will be later added by auditwheel
            for library_file in multiple_file_types(current_path, "*.dll"):
               if "Qt" in library_file:
                 continue
               library_basename=os.path.basename(library_file)
               if library_basename not in dependency_files:
                 continue
               library_target= self.get_ext_fullpath(module_name+".placeholder")
               self.copy_file(library_file,library_target.replace(placeholder,library_basename))
 
         #self.copy_file(abs_sources[0], ext_file)
 
 
 setup(
     name = 'pyMITK',
     version = get_pep386version(),
     author = 'German Cancer Research Center (DKFZ)',
     author_email = 'm.goetz@dkfz-heidelberg.de',
     ext_modules=[Extension('pyMITK._pyMITK', [r'@MITK_BINARY_MODULE@'])],
     packages= ['pyMITK'],
     package_dir = {'pyMITK':r'@MITK_PYTHON_PACKAGE_DIR@'},
     download_url = r'https://www.itk.org/MITKDoxygen/html/PyDownloadPage.html',
     platforms = [],
     description = r'MITK is a simplified interface to the Insight Toolkit (ITK) for image registration and segmentation',
     long_description  = 'MITK provides an abstraction layer to ITK that enables developers \
                          and users to access the powerful features of the InsightToolkit in an easy \
                          to use manner for biomedical image analysis.',
     classifiers=[
         "License :: OSI Approved :: Apache Software License",
         "Programming Language :: Python",
         "Programming Language :: C++",
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Education",
         "Intended Audience :: Healthcare Industry",
         "Intended Audience :: Science/Research",
         "Topic :: Scientific/Engineering",
         "Topic :: Scientific/Engineering :: Medical Science Apps.",
         "Topic :: Scientific/Engineering :: Information Analysis",
         "Topic :: Software Development :: Libraries",
         "Operating System :: Microsoft :: Windows",
         "Operating System :: POSIX",
         "Operating System :: Unix",
         "Operating System :: MacOS"
         ],
     license='Apache',
     keywords = 'MITK ITK InsightToolkit segmentation registration',
-    url = r'http://mitk.org/',
+    url = r'https://www.mitk.org/',
     cmdclass={'build_ext':build_ext}
     )
diff --git a/Wrapping/Python/mitkNumpyArrayConversion.cxx b/Wrapping/Python/mitkNumpyArrayConversion.cxx
index 5e4b41cad3..b8256fb8c5 100644
--- a/Wrapping/Python/mitkNumpyArrayConversion.cxx
+++ b/Wrapping/Python/mitkNumpyArrayConversion.cxx
@@ -1,237 +1,237 @@
 /*=========================================================================
 *
 *  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
+*         https://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.
 *
 *=========================================================================*/
 
 #include <stdint.h>
 #include <string.h>
 
 #include <numeric>
 #include <functional>
 
 #include "mitkImage.h"
 
 
 // Python is written in C
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
 
 /** An internal function that returns a memoryview object to the
  * MITK Image's buffer (shallow). The correct copy and writing
  * policies need to be done by the end-user method.
  */
 static PyObject *
 mitk_GetMemoryViewFromImage( PyObject *SWIGUNUSEDPARM(self), PyObject *args )
 {
   const void *                mitkBufferPtr;
   Py_ssize_t                  len;
   std::vector< unsigned int > size;
   size_t                      pixelSize     = 1;
 
   unsigned int                dimension;
 
   /* Cast over to a sitk Image. */
   PyObject *                  pyImage;
   void *                      voidImage;
   mitk::Image *               mitkImage;
   int                         res           = 0;
 
   PyObject *                  memoryView    = NULL;
   Py_buffer                   pyBuffer;
   memset(&pyBuffer, 0, sizeof(Py_buffer));
 
   unsigned int accumulatorValue = 1;
 
   if( !PyArg_ParseTuple( args, "O", &pyImage ) )
     {
     SWIG_fail; // SWIG_fail is a macro that says goto: fail (return NULL)
     }
   res = SWIG_ConvertPtr( pyImage, &voidImage, SWIGTYPE_p_mitk__Image, 0 );
   if (!SWIG_IsOK(res))
   {
 	  mitk::Image::Pointer tmpImage;
 	  res = SWIG_ConvertPtr(pyImage, &voidImage, SWIGTYPE_p_itk__SmartPointerT_mitk__Image_t, 0);
 	  if (!SWIG_IsOK(res))
 	  {
 		  SWIG_exception_fail(SWIG_ArgError(res), "in method 'GetByteArrayFromImage', argument needs to be of type 'sitk::Image *'");
 	  }
 	  tmpImage = *(reinterpret_cast<mitk::Image::Pointer *>(voidImage));
 	  voidImage = reinterpret_cast<void*>(tmpImage.GetPointer());
   }
   mitkImage = reinterpret_cast< mitk::Image * >( voidImage );
 
   mitkBufferPtr = mitkImage->GetData();  
   pixelSize = mitkImage->GetPixelType().GetBitsPerComponent() / 8;
 
   dimension = mitkImage->GetDimension();
   for (int i = 0; i < dimension; ++i)
   {
 	  size.push_back(mitkImage->GetDimension(i));
   }
   
   // if the image is a vector just treat is as another dimension
   if ( mitkImage->GetPixelType().GetNumberOfComponents() > 1 )
   {
     size.push_back( mitkImage->GetPixelType().GetNumberOfComponents() );
   }
 
   len = std::accumulate( size.begin(), size.end(), accumulatorValue, std::multiplies<unsigned int>() );
   len *= pixelSize;
 
   if (PyBuffer_FillInfo(&pyBuffer, NULL, (void*)mitkBufferPtr, len, true, PyBUF_CONTIG_RO)!=0)
   {
     SWIG_fail;
   }
   memoryView = PyMemoryView_FromBuffer(&pyBuffer);
 
   PyBuffer_Release(&pyBuffer);
   return memoryView;
 
 fail:
   Py_XDECREF( memoryView );
   return NULL;
 }
 
 /** An internal function that performs a deep copy of the image buffer
  * into a python byte array. The byte array can later be converted
  * into a numpy array with the frombuffer method.
  */
 static PyObject*
 mitk_SetImageFromArray( PyObject *SWIGUNUSEDPARM(self), PyObject *args )
 {
   PyObject * pyImage = NULL;
 
   const void *buffer;
   Py_ssize_t buffer_len;
   Py_buffer  pyBuffer;
   memset(&pyBuffer, 0, sizeof(Py_buffer));
 
   mitk::Image * mitkImage = NULL;
   void * mitkBufferPtr = NULL;
   size_t pixelSize = 1;
 
   unsigned int dimension = 0;
   std::vector< unsigned int > size;
   size_t len = 1;
 
   unsigned int accuValue = 1;
 
   // We wish to support both the new PEP3118 buffer interface and the
   // older. So we first try to parse the arguments with the new buffer
   // protocol, then the old.
   if (!PyArg_ParseTuple( args, "s*O", &pyBuffer, &pyImage ) )
     {
     PyErr_Clear();
 
 #ifdef PY_SSIZE_T_CLEAN
     typedef Py_ssize_t bufSizeType;
 #else
     typedef int bufSizeType;
 #endif
 
     bufSizeType _len;
     // This function takes 2 arguments from python, the first is an
     // python object which support the old "ReadBuffer" interface
     if( !PyArg_ParseTuple( args, "s#O", &buffer, &_len, &pyImage ) )
       {
       return NULL;
       }
     buffer_len = _len;
     }
   else
     {
     if ( PyBuffer_IsContiguous( &pyBuffer, 'C' ) != 1 )
       {
       PyBuffer_Release( &pyBuffer );
       PyErr_SetString( PyExc_TypeError, "A C Contiguous buffer object is required." );
       return NULL;
       }
     buffer_len = pyBuffer.len;
     buffer = pyBuffer.buf;
     }
 
   /* Cast over to a sitk Image. */
   {
     void * voidImage;
     int res = 0;
     res = SWIG_ConvertPtr( pyImage, &voidImage, SWIGTYPE_p_mitk__Image, 0 );
 	if (!SWIG_IsOK(res))
 	{
 		mitk::Image::Pointer tmpImage;
 		res = SWIG_ConvertPtr(pyImage, &voidImage, SWIGTYPE_p_itk__SmartPointerT_mitk__Image_t, 0);
 		if (!SWIG_IsOK(res))
 		{
 			SWIG_exception_fail(SWIG_ArgError(res), "in method 'GetByteArrayFromImage', argument needs to be of type 'sitk::Image *'");
 		}
 		tmpImage = *(reinterpret_cast<mitk::Image::Pointer *>(voidImage));
 		voidImage = reinterpret_cast<void*>(tmpImage.GetPointer());
 	}
 	mitkImage = reinterpret_cast< mitk::Image * >(voidImage);
   }
 
   try
     {
 	  mitkBufferPtr = mitkImage->GetData();
 	  pixelSize= mitkImage->GetPixelType().GetBitsPerComponent() / 8;
     }
   catch( const std::exception &e )
     {
     std::string msg = "Exception thrown in MITK new Image: ";
     msg += e.what();
     PyErr_SetString( PyExc_RuntimeError, msg.c_str() );
     goto fail;
     }
 
   dimension = mitkImage->GetDimension();
   for (int i = 0; i < dimension; ++i)
   {
 	  size.push_back(mitkImage->GetDimension(i));
   }
 
   // if the image is a vector just treat is as another dimension
   if (mitkImage->GetPixelType().GetNumberOfComponents() > 1)
   {
 	  size.push_back(mitkImage->GetPixelType().GetNumberOfComponents());
   }
 
   len = std::accumulate(size.begin(), size.end(), accuValue, std::multiplies<unsigned int>());
   len *= pixelSize;
 
   if ( buffer_len != len )
     {
     PyErr_SetString( PyExc_RuntimeError, "Size mismatch of image and Buffer." );
     goto fail;
     }
 
   memcpy( (void *)mitkBufferPtr, buffer, len );
 
 
   PyBuffer_Release( &pyBuffer );
   Py_RETURN_NONE;
 
 fail:
   PyBuffer_Release( &pyBuffer );
   return NULL;
 }
 
 
 
 #ifdef __cplusplus
 } // end extern "C"
 #endif