diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index d8746f3021..3637647f25 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,327 +1,328 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   mitkCoreActivator.cpp
   mitkCoreObjectFactoryBase.cpp
   mitkCoreObjectFactory.cpp
   mitkCoreServices.cpp
   mitkException.cpp
 
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkCompositePixelValueToString.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkExtractSliceFilter2.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkTemporalJoinImagesFilter.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkLayerController.cpp
 
   DataManagement/mitkAnatomicalStructureColorPresets.cpp
   DataManagement/mitkArbitraryTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseGeometry.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataStorage.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGeometryTransformHolder.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkGenericIDRelationRule.cpp
   DataManagement/mitkIdentifiable.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageReadAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageVtkReadAccessor.cpp
   DataManagement/mitkImageVtkWriteAccessor.cpp
   DataManagement/mitkImageWriteAccessor.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkIPersistenceService.cpp
   DataManagement/mitkIPropertyAliases.cpp
   DataManagement/mitkIPropertyDescriptions.cpp
   DataManagement/mitkIPropertyExtensions.cpp
   DataManagement/mitkIPropertyFilters.cpp
   DataManagement/mitkIPropertyOwner.cpp
   DataManagement/mitkIPropertyPersistence.cpp
   DataManagement/mitkIPropertyProvider.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLine.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTableProperty.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModifiedLock.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDataUID.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateFunction.cpp
   DataManagement/mitkNodePredicateGeometry.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateDataProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkNodePredicateSubGeometry.cpp
   DataManagement/mitkNumericConstants.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneGeometryData.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkPropertyKeyPath.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkPropertyNameHelper.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkPropertyPersistence.cpp
   DataManagement/mitkPropertyPersistenceInfo.cpp
   DataManagement/mitkPropertyRelationRuleBase.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkScaleOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkSourceImageRelationRule.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTemporoSpatialStringProperty.cpp
   DataManagement/mitkUIDManipulator.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVectorProperty.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkIPropertyRelations.cpp
   DataManagement/mitkPropertyRelations.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayActionEventBroadcast.cpp
   Interactions/mitkDisplayActionEventFunctions.cpp
   Interactions/mitkDisplayActionEventHandler.cpp
   Interactions/mitkDisplayActionEventHandlerDesynchronized.cpp
   Interactions/mitkDisplayActionEventHandlerStd.cpp
   Interactions/mitkDisplayActionEventHandlerSynchronized.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkInteractionEventObserver.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionSchemeSwitcher.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkSinglePointDataInteractor.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkXML2EventParser.cpp
 
   IO/mitkAbstractFileIO.cpp
   IO/mitkAbstractFileReader.cpp
   IO/mitkAbstractFileWriter.cpp
   IO/mitkCustomMimeType.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileReaderRegistry.cpp
   IO/mitkFileReaderSelector.cpp
   IO/mitkFileReaderWriterBase.cpp
   IO/mitkFileWriter.cpp
   IO/mitkFileWriterRegistry.cpp
   IO/mitkFileWriterSelector.cpp
   IO/mitkGeometry3DToXML.cpp
   IO/mitkIFileIO.cpp
   IO/mitkIFileReader.cpp
   IO/mitkIFileWriter.cpp
   IO/mitkGeometryDataReaderService.cpp
   IO/mitkGeometryDataWriterService.cpp
   IO/mitkImageGenerator.cpp
   IO/mitkImageVtkLegacyIO.cpp
   IO/mitkImageVtkXmlIO.cpp
   IO/mitkIMimeTypeProvider.cpp
   IO/mitkIOConstants.cpp
   IO/mitkIOMimeTypes.cpp
   IO/mitkIOUtil.cpp
   IO/mitkItkImageIO.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkLegacyFileReaderService.cpp
   IO/mitkLegacyFileWriterService.cpp
   IO/mitkLocaleSwitch.cpp
   IO/mitkLog.cpp
   IO/mitkMimeType.cpp
   IO/mitkMimeTypeProvider.cpp
   IO/mitkOperation.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetReaderService.cpp
   IO/mitkPointSetWriterService.cpp
   IO/mitkProportionalTimeGeometryToXML.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSurfaceStlIO.cpp
   IO/mitkSurfaceVtkIO.cpp
   IO/mitkSurfaceVtkLegacyIO.cpp
   IO/mitkSurfaceVtkXmlIO.cpp
+  IO/mitkUtf8Util.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkPreferenceListReaderOptionsFunctor.cpp
   IO/mitkIOMetaInformationPropertyConstants.cpp
 
   Rendering/mitkAbstractAnnotationRenderer.cpp
   Rendering/mitkAnnotationUtils.cpp
   Rendering/mitkBaseRenderer.cpp
   #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkAnnotation.cpp
   Rendering/mitkPlaneGeometryDataMapper2D.cpp
   Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowFrame.cpp
   #Rendering/mitkSurfaceGLMapper2D.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkSurfaceVtkMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfig.xml
 Interactions/DisplayConfigMITKBase.xml
 Interactions/DisplayConfigPACSBase.xml
 Interactions/DisplayConfigCrosshair.xml
 Interactions/DisplayConfigRotation.xml
 Interactions/DisplayConfigActivateCoupling.xml
 Interactions/DisplayConfigSwivel.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITKLimited.xml
 Interactions/DisplayConfigBlockLMB.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 mitkAnatomicalStructureColorPresets.xml
 )
diff --git a/Modules/Core/include/mitkIOUtil.h b/Modules/Core/include/mitkIOUtil.h
index 946016eb9c..24f878efa2 100644
--- a/Modules/Core/include/mitkIOUtil.h
+++ b/Modules/Core/include/mitkIOUtil.h
@@ -1,456 +1,434 @@
 /*============================================================================
 
 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 MITKIOUTIL_H
 #define MITKIOUTIL_H
 
 #include <MitkCoreExports.h>
 #include <mitkDataStorage.h>
 #include <mitkImage.h>
 #include <mitkPointSet.h>
 #include <mitkSurface.h>
 
 #include <mitkFileReaderSelector.h>
 #include <mitkFileWriterSelector.h>
 #include <mitkIFileReader.h>
 #include <mitkIFileWriter.h>
 
 #include <fstream>
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
   /**
    * \ingroup IO
    *
    * \brief A utility class to load and save data from/to the local file system.
    *
    * \see QmitkIOUtil
    */
   class MITKCORE_EXPORT IOUtil
   {
   public:
     /**Struct that containes information regarding the current loading process. (e.g. Path that should be loaded,
     all found readers for the load path,...). It is set be IOUtil and used to pass information via the option callback
     in load operations.
     */
     struct MITKCORE_EXPORT LoadInfo
     {
       LoadInfo(const std::string &path);
 
       std::string m_Path;
       std::vector<BaseData::Pointer> m_Output;
 
       FileReaderSelector m_ReaderSelector;
       bool m_Cancel;
     };
 
     /**Struct that is the base class for option callbacks used in load operations. The callback is used by IOUtil, if
     more than one suitable reader was found or the a reader containes options that can be set. The callback allows to
     change option settings and select the reader that should be used (via loadInfo).
     */
     struct MITKCORE_EXPORT ReaderOptionsFunctorBase
     {
       virtual bool operator()(LoadInfo &loadInfo) const = 0;
     };
 
     struct MITKCORE_EXPORT SaveInfo
     {
       SaveInfo(const BaseData *baseData, const MimeType &mimeType, const std::string &path);
 
       bool operator<(const SaveInfo &other) const;
 
       /// The BaseData object to save.
       const BaseData *m_BaseData;
 
       /// Contains a set of IFileWriter objects.
       FileWriterSelector m_WriterSelector;
       /// The selected mime-type, used to restrict results from FileWriterSelector.
       MimeType m_MimeType;
       /// The path to write the BaseData object to.
       std::string m_Path;
       /// Flag indicating if sub-sequent save operations are to be canceled.
       bool m_Cancel;
     };
 
     /**Struct that is the base class for option callbacks used in save operations. The callback is used by IOUtil, if
     more than one suitable writer was found or the a writer containes options that can be set. The callback allows to
     change option settings and select the writer that should be used (via saveInfo).
     */
     struct MITKCORE_EXPORT WriterOptionsFunctorBase
     {
       virtual bool operator()(SaveInfo &saveInfo) const = 0;
     };
 
     /**
      * Get the file system path where the running executable is located.
      *
      * @return The location of the currently running executable, without the filename.
      */
     static std::string GetProgramPath();
 
     /**
      * Get the default temporary path.
      *
      * @return The default path for temporary data.
      */
     static std::string GetTempPath();
 
     /**
     * Returns the Directory Seperator for the current OS.
     *
     * @return the Directory Seperator for the current OS, i.e. "\\" for Windows and "/" otherwise.
     */
     static char GetDirectorySeparator();
 
     /**
      * Create and open a temporary file.
      *
      * This method generates a unique temporary filename from \c templateName, creates
      * and opens the file using the output stream \c tmpStream and returns the name of
      * the newly create file.
      *
      * The \c templateName argument must contain six consective 'X' characters ("XXXXXX")
      * and these are replaced with a string that makes the filename unique.
      *
      * The file is created with read and write permissions for owner only.
      *
      * @param tmpStream The output stream for writing to the temporary file.
      * @param templateName An optional template for the filename.
      * @param path An optional path where the temporary file should be created. Defaults
      *        to the default temp path as returned by GetTempPath().
      * @return The filename of the created temporary file.
      *
      * @throw mitk::Exception if the temporary file could not be created.
      */
     static std::string CreateTemporaryFile(std::ofstream &tmpStream,
                                            const std::string &templateName = "XXXXXX",
                                            std::string path = std::string());
 
     /**
      * Create and open a temporary file.
      *
      * This method generates a unique temporary filename from \c templateName, creates
      * and opens the file using the output stream \c tmpStream and the specified open
      * mode \c mode and returns the name of the newly create file. The open mode is always
      * OR'd with <code>std::ios_base::out | std::ios_base::trunc</code>.
      *
      * The \c templateName argument must contain six consective 'X' characters ("XXXXXX")
      * and these are replaced with a string that makes the filename unique.
      *
      * The file is created with read and write permissions for owner only.
      *
      * @param tmpStream The output stream for writing to the temporary file.
      * @param mode The open mode for the temporary file stream.
      * @param templateName An optional template for the filename.
      * @param path An optional path where the temporary file should be created. Defaults
      *        to the default temp path as returned by GetTempPath().
      * @return The filename of the created temporary file.
      *
      * @throw mitk::Exception if the temporary file could not be created.
      */
     static std::string CreateTemporaryFile(std::ofstream &tmpStream,
                                            std::ios_base::openmode mode,
                                            const std::string &templateName = "XXXXXX",
                                            std::string path = std::string());
 
     /**
     * Creates an empty temporary file.
     *
     * This method generates a unique temporary filename from \c templateName and creates
     * this file.
     *
     * The file is created with read and write permissions for owner only.
     *
     * ---
     * This version is potentially unsafe because the created temporary file is not kept open
     * and could be used by another process between calling this method and opening the returned
     * file path for reading or writing.
     * ---
     *
     * @return The filename of the created temporary file.
     * @param templateName An optional template for the filename.
     * @param path An optional path where the temporary file should be created. Defaults
     *        to the default temp path as returned by GetTempPath().
     * @throw mitk::Exception if the temporary file could not be created.
     */
     static std::string CreateTemporaryFile(const std::string &templateName = "XXXXXX",
                                            std::string path = std::string());
 
     /**
      * Create a temporary directory.
      *
      * This method generates a uniquely named temporary directory from \c templateName.
      * The last set of six consecutive 'X' characters in \c templateName is replaced
      * with a string that makes the directory name unique.
      *
      * The directory is created with read, write and executable permissions for owner only.
      *
      * @param templateName An optional template for the directory name.
      * @param path An optional path where the temporary directory should be created. Defaults
      *        to the default temp path as returned by GetTempPath().
      * @return The filename of the created temporary file.
      *
      * @throw mitk::Exception if the temporary directory could not be created.
      */
     static std::string CreateTemporaryDirectory(const std::string &templateName = "XXXXXX",
                                                 std::string path = std::string());
 
     /**
      * @brief Load a file into the given DataStorage.
      *
      * This method calls Load(const std::vector<std::string>&, DataStorage&) with a
      * one-element vector.
      *
      * @param path The absolute file name including the file extension.
      * @param storage A DataStorage object to which the loaded data will be added.
      * @param optionsCallback Pointer to a callback instance. The callback is used by
      * the load operation if more the suitable reader was found or the reader has options
      * that can be set.
      * @return The set of added DataNode objects.
      * @throws mitk::Exception if \c path could not be loaded.
      *
      * @sa Load(const std::vector<std::string>&, DataStorage&)
      */
     static DataStorage::SetOfObjects::Pointer Load(const std::string &path, DataStorage &storage,
                                                    const ReaderOptionsFunctorBase *optionsCallback = nullptr);
 
     /**
     * @brief Load a file into the given DataStorage given user defined IFileReader::Options.
     *
     * This method calls Load(const std::vector<std::string>&, DataStorage&) with a
     * one-element vector.
     *
     * @param path The absolute file name including the file extension.
     * @param options IFileReader option instance that should be used if selected reader
     * has options.
     * @param storage A DataStorage object to which the loaded data will be added.
     * @return The set of added DataNode objects.
     * @throws mitk::Exception if \c path could not be loaded.
     *
     * @sa Load(const std::vector<std::string>&, DataStorage&)
     */
     static DataStorage::SetOfObjects::Pointer Load(const std::string &path,
                                                    const IFileReader::Options &options,
                                                    DataStorage &storage);
 
     /**
     * @brief Load a file and return the loaded data.
     *
     * This method calls Load(const std::vector<std::string>&) with a
     * one-element vector.
     *
     * @param path The absolute file name including the file extension.
     * @param optionsCallback Pointer to a callback instance. The callback is used by
     * the load operation if more the suitable reader was found or the reader has options
     * that can be set.
     * @return The set of added DataNode objects.
     * @throws mitk::Exception if \c path could not be loaded.
     *
     * @sa Load(const std::vector<std::string>&, DataStorage&)
     */
     static std::vector<BaseData::Pointer> Load(const std::string &path,
                                                const ReaderOptionsFunctorBase *optionsCallback = nullptr);
 
     template <typename T>
     static typename T::Pointer Load(const std::string& path, const ReaderOptionsFunctorBase *optionsCallback = nullptr)
     {
       return dynamic_cast<T*>(Load(path, optionsCallback).at(0).GetPointer());
     }
 
     /**
     * @brief Load a file and return the loaded data.
     *
     * This method calls Load(const std::vector<std::string>&) with a
     * one-element vector.
     *
     * @param path The absolute file name including the file extension.
     * @param options IFileReader option instance that should be used if selected reader
     * has options.
     * @return The set of added DataNode objects.
     * @throws mitk::Exception if \c path could not be loaded.
     *
     * @sa Load(const std::vector<std::string>&, DataStorage&)
     */
     static std::vector<BaseData::Pointer> Load(const std::string &path, const IFileReader::Options &options);
 
     template <typename T>
     static typename T::Pointer Load(const std::string& path, const IFileReader::Options &options)
     {
       return dynamic_cast<T*>(Load(path, options).at(0).GetPointer());
     }
 
     /**
      * @brief Loads a list of file paths into the given DataStorage.
      *
      * If an entry in \c paths cannot be loaded, this method will continue to load
      * the remaining entries into \c storage and throw an exception afterwards.
      *
      * @param paths A list of absolute file names including the file extension.
      * @param storage A DataStorage object to which the loaded data will be added.
      * @param optionsCallback Pointer to a callback instance. The callback is used by
      * the load operation if more the suitable reader was found or the reader has options
      * that can be set.
      * @return The set of added DataNode objects.
      * @throws mitk::Exception if an entry in \c paths could not be loaded.
      */
     static DataStorage::SetOfObjects::Pointer Load(const std::vector<std::string> &paths, DataStorage &storage,
                                                    const ReaderOptionsFunctorBase *optionsCallback = nullptr);
 
     static std::vector<BaseData::Pointer> Load(const std::vector<std::string> &paths,
                                                const ReaderOptionsFunctorBase *optionsCallback = nullptr);
 
     /**
      * @brief Loads the contents of a us::ModuleResource and returns the corresponding mitk::BaseData
      * @param usResource a ModuleResource, representing a BaseData object
      * @param mode Optional parameter to set the openmode of the stream
      * @return The set of loaded BaseData objects. \c Should contain either one or zero elements, since a resource
      * stream
      * respresents one object.
      * @throws mitk::Exception if no reader was found for the stream.
      */
     static std::vector<BaseData::Pointer> Load(const us::ModuleResource &usResource,
                                                std::ios_base::openmode mode = std::ios_base::in);
 
     template <typename T>
     static typename T::Pointer Load(const us::ModuleResource &usResource, std::ios_base::openmode mode = std::ios_base::in)
     {
       return dynamic_cast<T*>(Load(usResource, mode).at(0).GetPointer());
     }
 
     /**
      * @brief Save a mitk::BaseData instance.
      * @param data The data to save.
      * @param path The path to the image including file name and and optional file extension.
      *        If no extension is set, the default extension and mime-type for the
      *        BaseData type of \c data is used.
      * @param setPathProperty
      * @throws mitk::Exception if no writer for \c data is available or the writer
      *         is not able to write the image.
      */
     static void Save(const mitk::BaseData *data, const std::string &path, bool setPathProperty = false);
 
     /**
      * @brief Save a mitk::BaseData instance.
      * @param data The data to save.
      * @param path The path to the image including file name and an optional file extension.
      *        If no extension is set, the default extension and mime-type for the
      *        BaseData type of \c data is used.
      * @param options The IFileWriter options to use for the selected writer.
      * @param setPathProperty
      * @throws mitk::Exception if no writer for \c data is available or the writer
      *         is not able to write the image.
      */
     static void Save(const mitk::BaseData *data, const std::string &path, const IFileWriter::Options &options, bool setPathProperty = false);
 
     /**
      * @brief Save a mitk::BaseData instance.
      * @param data The data to save.
      * @param mimeType The mime-type to use for writing \c data.
      * @param path The path to the image including file name and an optional file extension.
      * @param addExtension If \c true, an extension according to the given \c mimeType
      *        is added to \c path if it does not contain one. If \c path already contains
      *        a file name extension, it is not checked for compatibility with \c mimeType.
      * @param setPathProperty
      *
      * @throws mitk::Exception if no writer for the combination of \c data and \c mimeType is
      *         available or the writer is not able to write the image.
      */
     static void Save(const mitk::BaseData *data,
                      const std::string &mimeType,
                      const std::string &path,
                      bool addExtension = true,
                      bool setPathProperty = false);
 
     /**
      * @brief Save a mitk::BaseData instance.
      * @param data The data to save.
      * @param mimeType The mime-type to use for writing \c data.
      * @param path The path to the image including file name and an optional file extension.
      * @param options Configuration data for the used IFileWriter instance.
      * @param addExtension If \c true, an extension according to the given \c mimeType
      *        is added to \c path if it does not contain one. If \c path already contains
      *        a file name extension, it is not checked for compatibility with \c mimeType.
      * @param setPathProperty
      *
      * @throws mitk::Exception if no writer for the combination of \c data and \c mimeType is
      *         available or the writer is not able to write the image.
      */
     static void Save(const mitk::BaseData *data,
                      const std::string &mimeType,
                      const std::string &path,
                      const mitk::IFileWriter::Options &options,
                      bool addExtension = true,
                      bool setPathProperty = false);
 
     /**
      * @brief Use SaveInfo objects to save BaseData instances.
      *
      * This is a low-level method for directly working with SaveInfo objects. Usually,
      * the Save() methods taking a BaseData object as an argument are more appropriate.
      *
      * @param saveInfos A list of SaveInfo objects for saving contained BaseData objects.
      * @param setPathProperty
      *
      * @see Save(const mitk::BaseData*, const std::string&)
      */
     static void Save(std::vector<SaveInfo> &saveInfos, bool setPathProperty = false);
 
-    /**
-     * @brief Convert a string encoded with the current code page to an UTF-8 encoded string (Windows)
-     *
-     * The conversion happens on Windows only. On all other platforms, the input string
-     * is returned unmodified as it is assumed to be UTF-8 encoded already.
-     *
-     * If the conversion fails, a warning is printed and the input string is returned
-     * instead. This matches the behavior before this method was introduced.
-     */
-    static std::string Local8BitToUtf8(const std::string& local8BitStr);
-
-    /**
-     * @brief Convert a UTF-8 encoded string to a string encoded with the current code page (Windows)
-     *
-     * The conversion happens on Windows only. On all other platforms, the input string
-     * is returned unmodified as strings are assumed to be always UTF-8 encoded by default.
-     *
-     * If the conversion fails, a warning is printed and the input string is returned
-     * instead. This matches the behavior before this method was introduced.
-     */
-    static std::string Utf8ToLocal8Bit(const std::string& utf8Str);
-
   protected:
     static std::string Load(std::vector<LoadInfo> &loadInfos,
                             DataStorage::SetOfObjects *nodeResult,
                             DataStorage *ds,
                             const ReaderOptionsFunctorBase *optionsCallback);
 
     static std::string Save(const BaseData *data,
                             const std::string &mimeType,
                             const std::string &path,
                             WriterOptionsFunctorBase *optionsCallback,
                             bool addExtension,
                             bool setPathProperty);
 
     static std::string Save(std::vector<SaveInfo> &saveInfos,
                             WriterOptionsFunctorBase *optionsCallback,
                             bool setPathProperty);
 
   private:
     struct Impl;
   };
 }
 
 #endif // MITKIOUTIL_H
diff --git a/Modules/Core/include/mitkUtf8Util.h b/Modules/Core/include/mitkUtf8Util.h
new file mode 100644
index 0000000000..fd14bead54
--- /dev/null
+++ b/Modules/Core/include/mitkUtf8Util.h
@@ -0,0 +1,47 @@
+/*============================================================================
+
+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 mitkUtf8Util_h
+#define mitkUtf8Util_h
+
+#include <MitkCoreExports.h>
+#include <string>
+
+namespace mitk
+{
+  namespace Utf8Util
+  {
+    /**
+     * @brief Convert a string encoded with the current code page to an UTF-8 encoded string (Windows)
+     *
+     * The conversion happens on Windows only. On all other platforms, the input string
+     * is returned unmodified as it is assumed to be UTF-8 encoded already.
+     *
+     * If the conversion fails, a warning is printed and the input string is returned
+     * instead. This matches the behavior before this method was introduced.
+     */
+    MITKCORE_EXPORT std::string Local8BitToUtf8(const std::string& local8BitStr);
+
+    /**
+     * @brief Convert a UTF-8 encoded string to a string encoded with the current code page (Windows)
+     *
+     * The conversion happens on Windows only. On all other platforms, the input string
+     * is returned unmodified as strings are assumed to be always UTF-8 encoded by default.
+     *
+     * If the conversion fails, a warning is printed and the input string is returned
+     * instead. This matches the behavior before this method was introduced.
+     */
+    MITKCORE_EXPORT std::string Utf8ToLocal8Bit(const std::string& utf8Str);
+  }
+}
+
+#endif
diff --git a/Modules/Core/src/IO/mitkAbstractFileReader.cpp b/Modules/Core/src/IO/mitkAbstractFileReader.cpp
index 4ac0024740..3085cb6efd 100644
--- a/Modules/Core/src/IO/mitkAbstractFileReader.cpp
+++ b/Modules/Core/src/IO/mitkAbstractFileReader.cpp
@@ -1,334 +1,334 @@
 /*============================================================================
 
 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 <mitkAbstractFileReader.h>
 
 #include <mitkCustomMimeType.h>
 #include <mitkIOUtil.h>
+#include <mitkUtf8Util.h>
 
 #include <mitkFileReaderWriterBase.h>
 #include <mitkVersion.h>
 #include <mitkIOMetaInformationPropertyConstants.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usPrototypeServiceFactory.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <fstream>
 
 namespace mitk
 {
   AbstractFileReader::InputStream::InputStream(IFileReader *reader, std::ios_base::openmode mode)
     : std::istream(nullptr), m_Stream(nullptr)
   {
     std::istream *stream = reader->GetInputStream();
     if (stream)
     {
       this->init(stream->rdbuf());
     }
     else
     {
       m_Stream = new std::ifstream(reader->GetInputLocation().c_str(), mode);
       this->init(m_Stream->rdbuf());
     }
   }
 
   AbstractFileReader::InputStream::~InputStream() { delete m_Stream; }
   class AbstractFileReader::Impl : public FileReaderWriterBase
   {
   public:
     Impl() : FileReaderWriterBase(), m_Stream(nullptr), m_PrototypeFactory(nullptr) {}
     Impl(const Impl &other) : FileReaderWriterBase(other), m_Stream(nullptr), m_PrototypeFactory(nullptr) {}
     std::string m_Location;
     std::string m_TmpFile;
     std::istream *m_Stream;
 
     us::PrototypeServiceFactory *m_PrototypeFactory;
     us::ServiceRegistration<IFileReader> m_Reg;
   };
 
   AbstractFileReader::AbstractFileReader() : d(new Impl) {}
   AbstractFileReader::~AbstractFileReader()
   {
     UnregisterService();
 
     delete d->m_PrototypeFactory;
 
     if (!d->m_TmpFile.empty())
     {
       std::remove(d->m_TmpFile.c_str());
     }
   }
 
   AbstractFileReader::AbstractFileReader(const AbstractFileReader &other) : IFileReader(), d(new Impl(*other.d.get()))
   {
   }
 
   AbstractFileReader::AbstractFileReader(const CustomMimeType &mimeType, const std::string &description) : d(new Impl)
   {
     d->SetMimeType(mimeType);
     d->SetDescription(description);
   }
 
   ////////////////////// Reading /////////////////////////
 
   std::vector<BaseData::Pointer> AbstractFileReader::Read()
   {
     std::vector<BaseData::Pointer> result = this->DoRead();
 
     const auto options = this->GetOptions();
 
     for (auto& data : result)
     {
       data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_DESCRIPTION()), StringProperty::New(d->GetDescription()));
       data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_VERSION()), StringProperty::New(MITK_VERSION_STRING));
       data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_MIME_NAME()), StringProperty::New(d->GetMimeType()->GetName()));
       data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_MIME_CATEGORY()), StringProperty::New(d->GetMimeType()->GetCategory()));
       if (this->GetInputStream() == nullptr)
       {
-        data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_INPUTLOCATION()), StringProperty::New(IOUtil::Local8BitToUtf8(this->GetInputLocation())));
+        data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_INPUTLOCATION()), StringProperty::New(Utf8Util::Local8BitToUtf8(this->GetInputLocation())));
       }
 
       for (const auto& option : options)
       {
         auto optionpath = IOMetaInformationPropertyConstants::READER_OPTION_ROOT().AddElement(option.first);
         data->SetProperty(PropertyKeyPathToPropertyName(optionpath), StringProperty::New(option.second.ToString()));
       }
     }
 
     return result;
   }
 
   DataStorage::SetOfObjects::Pointer AbstractFileReader::Read(DataStorage &ds)
   {
     DataStorage::SetOfObjects::Pointer result = DataStorage::SetOfObjects::New();
     std::vector<BaseData::Pointer> data = this->Read();
     for (auto iter = data.begin(); iter != data.end(); ++iter)
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(*iter);
       this->SetDefaultDataNodeProperties(node, this->GetInputLocation());
       ds.Add(node);
       result->InsertElement(result->Size(), node);
     }
     return result;
   }
 
   IFileReader::ConfidenceLevel AbstractFileReader::GetConfidenceLevel() const
   {
     if (d->m_Stream)
     {
       if (*d->m_Stream)
         return Supported;
     }
     else
     {
-      if (itksys::SystemTools::FileExists(this->GetInputLocation().c_str(), true))
+      if (itksys::SystemTools::FileExists(Utf8Util::Local8BitToUtf8(this->GetInputLocation()).c_str(), true))
       {
         return Supported;
       }
     }
     return Unsupported;
   }
 
   //////////// µS Registration & Properties //////////////
 
   us::ServiceRegistration<IFileReader> AbstractFileReader::RegisterService(us::ModuleContext *context)
   {
     if (d->m_PrototypeFactory)
       return us::ServiceRegistration<IFileReader>();
 
     if (context == nullptr)
     {
       context = us::GetModuleContext();
     }
 
     d->RegisterMimeType(context);
 
     if (this->GetMimeType()->GetName().empty())
     {
       MITK_WARN << "Not registering reader due to empty MIME type.";
       return us::ServiceRegistration<IFileReader>();
     }
 
     struct PrototypeFactory : public us::PrototypeServiceFactory
     {
       AbstractFileReader *const m_Prototype;
 
       PrototypeFactory(AbstractFileReader *prototype) : m_Prototype(prototype) {}
       us::InterfaceMap GetService(us::Module * /*module*/,
                                   const us::ServiceRegistrationBase & /*registration*/) override
       {
         return us::MakeInterfaceMap<IFileReader>(m_Prototype->Clone());
       }
 
       void UngetService(us::Module * /*module*/,
                         const us::ServiceRegistrationBase & /*registration*/,
                         const us::InterfaceMap &service) override
       {
         delete us::ExtractInterface<IFileReader>(service);
       }
     };
 
     d->m_PrototypeFactory = new PrototypeFactory(this);
     us::ServiceProperties props = this->GetServiceProperties();
     d->m_Reg = context->RegisterService<IFileReader>(d->m_PrototypeFactory, props);
     return d->m_Reg;
   }
 
   void AbstractFileReader::UnregisterService()
   {
     try
     {
       d->m_Reg.Unregister();
     }
     catch (const std::exception &)
     {
     }
   }
 
   us::ServiceProperties AbstractFileReader::GetServiceProperties() const
   {
     us::ServiceProperties result;
 
     result[IFileReader::PROP_DESCRIPTION()] = this->GetDescription();
     result[IFileReader::PROP_MIMETYPE()] = this->GetMimeType()->GetName();
     result[us::ServiceConstants::SERVICE_RANKING()] = this->GetRanking();
     return result;
   }
 
   us::ServiceRegistration<CustomMimeType> AbstractFileReader::RegisterMimeType(us::ModuleContext *context)
   {
     return d->RegisterMimeType(context);
   }
 
   std::vector< std::string > AbstractFileReader::GetReadFiles(){ return m_ReadFiles; }
 
   void AbstractFileReader::SetMimeType(const CustomMimeType &mimeType) { d->SetMimeType(mimeType); }
   void AbstractFileReader::SetDescription(const std::string &description) { d->SetDescription(description); }
   void AbstractFileReader::SetRanking(int ranking) { d->SetRanking(ranking); }
   int AbstractFileReader::GetRanking() const { return d->GetRanking(); }
   std::string AbstractFileReader::GetLocalFileName() const
   {
     std::string localFileName;
     if (d->m_Stream)
     {
       if (d->m_TmpFile.empty())
       {
         // write the stream contents to temporary file
-        std::string ext = itksys::SystemTools::GetFilenameExtension(this->GetInputLocation());
+        std::string ext = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetFilenameExtension(Utf8Util::Local8BitToUtf8(this->GetInputLocation())));
         std::ofstream tmpStream;
         localFileName = mitk::IOUtil::CreateTemporaryFile(
           tmpStream, std::ios_base::out | std::ios_base::trunc | std::ios_base::binary, "XXXXXX" + ext);
         tmpStream << d->m_Stream->rdbuf();
         d->m_TmpFile = localFileName;
       }
       else
       {
         localFileName = d->m_TmpFile;
       }
     }
     else
     {
       localFileName = d->m_Location;
     }
     return localFileName;
   }
 
   //////////////////////// Options ///////////////////////
 
   void AbstractFileReader::SetDefaultOptions(const IFileReader::Options &defaultOptions)
   {
     d->SetDefaultOptions(defaultOptions);
   }
 
   IFileReader::Options AbstractFileReader::GetDefaultOptions() const { return d->GetDefaultOptions(); }
   void AbstractFileReader::SetInput(const std::string &location)
   {
     d->m_Location = location;
     d->m_Stream = nullptr;
   }
 
   void AbstractFileReader::SetInput(const std::string &location, std::istream *is)
   {
     if (d->m_Stream != is && !d->m_TmpFile.empty())
     {
       std::remove(d->m_TmpFile.c_str());
       d->m_TmpFile.clear();
     }
     d->m_Location = location;
     d->m_Stream = is;
   }
 
   std::string AbstractFileReader::GetInputLocation() const { return d->m_Location; }
   std::istream *AbstractFileReader::GetInputStream() const { return d->m_Stream; }
   MimeType AbstractFileReader::GetRegisteredMimeType() const { return d->GetRegisteredMimeType(); }
   IFileReader::Options AbstractFileReader::GetOptions() const { return d->GetOptions(); }
   us::Any AbstractFileReader::GetOption(const std::string &name) const { return d->GetOption(name); }
   void AbstractFileReader::SetOptions(const Options &options) { d->SetOptions(options); }
   void AbstractFileReader::SetOption(const std::string &name, const us::Any &value) { d->SetOption(name, value); }
   ////////////////// MISC //////////////////
 
   void AbstractFileReader::AddProgressCallback(const ProgressCallback &callback) { d->AddProgressCallback(callback); }
   void AbstractFileReader::RemoveProgressCallback(const ProgressCallback &callback)
   {
     d->RemoveProgressCallback(callback);
   }
 
   ////////////////// µS related Getters //////////////////
 
   const CustomMimeType *AbstractFileReader::GetMimeType() const { return d->GetMimeType(); }
   void AbstractFileReader::SetMimeTypePrefix(const std::string &prefix) { d->SetMimeTypePrefix(prefix); }
   std::string AbstractFileReader::GetMimeTypePrefix() const { return d->GetMimeTypePrefix(); }
   std::string AbstractFileReader::GetDescription() const { return d->GetDescription(); }
   void AbstractFileReader::SetDefaultDataNodeProperties(DataNode *node, const std::string &filePath)
   {
     // path
     if (!filePath.empty())
     {
-      auto path = itksys::SystemTools::GetFilenamePath(filePath);
-      path = IOUtil::Local8BitToUtf8(path);
+      auto path = itksys::SystemTools::GetFilenamePath(Utf8Util::Local8BitToUtf8(filePath));
       node->SetProperty(StringProperty::PATH, mitk::StringProperty::New(path));
     }
 
     // name already defined?
     mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty *>(node->GetProperty("name"));
     if (nameProp.IsNull() || nameProp->GetValue() == DataNode::NO_NAME_VALUE())
     {
       // name already defined in BaseData
       mitk::StringProperty::Pointer baseDataNameProp =
         dynamic_cast<mitk::StringProperty *>(node->GetData()->GetProperty("name").GetPointer());
       if (baseDataNameProp.IsNull() || baseDataNameProp->GetValue() == DataNode::NO_NAME_VALUE())
       {
         // name neither defined in node, nor in BaseData -> name = filebasename;
         auto name = this->GetRegisteredMimeType().GetFilenameWithoutExtension(filePath);
-        name = IOUtil::Local8BitToUtf8(name);
+        name = Utf8Util::Local8BitToUtf8(name);
         nameProp = mitk::StringProperty::New(name);
         node->SetProperty("name", nameProp);
       }
       else
       {
         // name defined in BaseData!
         nameProp = mitk::StringProperty::New(baseDataNameProp->GetValue());
         node->SetProperty("name", nameProp);
       }
     }
 
     // visibility
     if (!node->GetProperty("visible"))
     {
       node->SetVisibility(true);
     }
   }
 }
diff --git a/Modules/Core/src/IO/mitkAbstractFileWriter.cpp b/Modules/Core/src/IO/mitkAbstractFileWriter.cpp
index 30220b75d7..072460a076 100644
--- a/Modules/Core/src/IO/mitkAbstractFileWriter.cpp
+++ b/Modules/Core/src/IO/mitkAbstractFileWriter.cpp
@@ -1,288 +1,289 @@
 /*============================================================================
 
 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 <mitkAbstractFileWriter.h>
 
 #include <mitkBaseData.h>
 #include <mitkCustomMimeType.h>
 #include <mitkExceptionMacro.h>
 #include <mitkIOUtil.h>
+#include <mitkUtf8Util.h>
 
 #include <mitkFileReaderWriterBase.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usPrototypeServiceFactory.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <fstream>
 
 namespace mitk
 {
   struct AbstractFileWriter::LocalFile::Impl
   {
     Impl(const std::string &location, std::ostream *os) : m_Location(location), m_Stream(os) {}
     std::string m_Location;
     std::string m_TmpFileName;
     std::ostream *m_Stream;
   };
 
   AbstractFileWriter::LocalFile::LocalFile(IFileWriter *writer)
     : d(new Impl(writer->GetOutputLocation(), writer->GetOutputStream()))
   {
   }
 
   AbstractFileWriter::LocalFile::~LocalFile()
   {
     if (d->m_Stream && !d->m_TmpFileName.empty())
     {
       std::ifstream ifs(d->m_TmpFileName.c_str(), std::ios_base::binary);
       *d->m_Stream << ifs.rdbuf();
       d->m_Stream->flush();
       ifs.close();
       std::remove(d->m_TmpFileName.c_str());
     }
   }
 
   std::string AbstractFileWriter::LocalFile::GetFileName()
   {
     if (d->m_Stream == nullptr)
     {
       return d->m_Location;
     }
     else if (d->m_TmpFileName.empty())
     {
-      std::string ext = itksys::SystemTools::GetFilenameExtension(d->m_Location);
+      std::string ext = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetFilenameExtension(Utf8Util::Local8BitToUtf8(d->m_Location)));
       d->m_TmpFileName = IOUtil::CreateTemporaryFile("XXXXXX" + ext);
     }
     return d->m_TmpFileName;
   }
 
   AbstractFileWriter::OutputStream::OutputStream(IFileWriter *writer, std::ios_base::openmode mode)
     : std::ostream(nullptr), m_Stream(nullptr)
   {
     std::ostream *stream = writer->GetOutputStream();
     if (stream)
     {
       this->init(stream->rdbuf());
     }
     else
     {
       m_Stream = new std::ofstream(writer->GetOutputLocation().c_str(), mode);
       this->init(m_Stream->rdbuf());
     }
   }
 
   AbstractFileWriter::OutputStream::~OutputStream() { delete m_Stream; }
   class AbstractFileWriter::Impl : public FileReaderWriterBase
   {
   public:
     Impl() : FileReaderWriterBase(), m_BaseData(nullptr), m_Stream(nullptr), m_PrototypeFactory(nullptr) {}
     Impl(const Impl &other)
       : FileReaderWriterBase(other),
         m_BaseDataType(other.m_BaseDataType),
         m_BaseData(nullptr),
         m_Stream(nullptr),
         m_PrototypeFactory(nullptr)
     {
     }
 
     std::string m_BaseDataType;
     const BaseData *m_BaseData;
     std::string m_Location;
     std::ostream *m_Stream;
 
     us::PrototypeServiceFactory *m_PrototypeFactory;
     us::ServiceRegistration<IFileWriter> m_Reg;
   };
 
   void AbstractFileWriter::SetInput(const BaseData *data) { d->m_BaseData = data; }
   const BaseData *AbstractFileWriter::GetInput() const { return d->m_BaseData; }
   void AbstractFileWriter::SetOutputLocation(const std::string &location)
   {
     d->m_Location = location;
     d->m_Stream = nullptr;
   }
 
   std::string AbstractFileWriter::GetOutputLocation() const { return d->m_Location; }
   void AbstractFileWriter::SetOutputStream(const std::string &location, std::ostream *os)
   {
     d->m_Location = location;
     d->m_Stream = os;
   }
 
   std::ostream *AbstractFileWriter::GetOutputStream() const { return d->m_Stream; }
   AbstractFileWriter::~AbstractFileWriter()
   {
     UnregisterService();
 
     delete d->m_PrototypeFactory;
   }
 
   AbstractFileWriter::AbstractFileWriter(const AbstractFileWriter &other) : IFileWriter(), d(new Impl(*other.d.get()))
   {
   }
 
   AbstractFileWriter::AbstractFileWriter(const std::string &baseDataType) : d(new Impl)
   {
     d->m_BaseDataType = baseDataType;
   }
 
   AbstractFileWriter::AbstractFileWriter(const std::string &baseDataType,
                                          const CustomMimeType &mimeType,
                                          const std::string &description)
     : d(new Impl)
   {
     d->m_BaseDataType = baseDataType;
     d->SetMimeType(mimeType);
     d->SetDescription(description);
   }
 
   ////////////////////// Writing /////////////////////////
 
   IFileWriter::ConfidenceLevel AbstractFileWriter::GetConfidenceLevel() const
   {
     if (d->m_BaseData == nullptr)
       return Unsupported;
 
     std::vector<std::string> classHierarchy = d->m_BaseData->GetClassHierarchy();
     if (std::find(classHierarchy.begin(), classHierarchy.end(), d->m_BaseDataType) == classHierarchy.end())
     {
       return Unsupported;
     }
     return Supported;
   }
 
   MimeType AbstractFileWriter::GetRegisteredMimeType() const { return d->GetRegisteredMimeType(); }
   //////////// µS Registration & Properties //////////////
 
   us::ServiceRegistration<IFileWriter> AbstractFileWriter::RegisterService(us::ModuleContext *context)
   {
     if (d->m_PrototypeFactory)
       return us::ServiceRegistration<IFileWriter>();
 
     if (context == nullptr)
     {
       context = us::GetModuleContext();
     }
 
     d->RegisterMimeType(context);
 
     if (this->GetMimeType()->GetName().empty())
     {
       MITK_WARN << "Not registering writer due to empty MIME type.";
       return us::ServiceRegistration<IFileWriter>();
     }
 
     struct PrototypeFactory : public us::PrototypeServiceFactory
     {
       AbstractFileWriter *const m_Prototype;
 
       PrototypeFactory(AbstractFileWriter *prototype) : m_Prototype(prototype) {}
       us::InterfaceMap GetService(us::Module * /*module*/,
                                   const us::ServiceRegistrationBase & /*registration*/) override
       {
         return us::MakeInterfaceMap<IFileWriter>(m_Prototype->Clone());
       }
 
       void UngetService(us::Module * /*module*/,
                         const us::ServiceRegistrationBase & /*registration*/,
                         const us::InterfaceMap &service) override
       {
         delete us::ExtractInterface<IFileWriter>(service);
       }
     };
 
     d->m_PrototypeFactory = new PrototypeFactory(this);
     us::ServiceProperties props = this->GetServiceProperties();
     d->m_Reg = context->RegisterService<IFileWriter>(d->m_PrototypeFactory, props);
     return d->m_Reg;
   }
 
   void AbstractFileWriter::UnregisterService()
   {
     try
     {
       d->m_Reg.Unregister();
     }
     catch (const std::exception &)
     {
     }
   }
 
   us::ServiceProperties AbstractFileWriter::GetServiceProperties() const
   {
     us::ServiceProperties result;
     result[IFileWriter::PROP_DESCRIPTION()] = this->GetDescription();
     result[IFileWriter::PROP_MIMETYPE()] = this->GetMimeType()->GetName();
     result[IFileWriter::PROP_BASEDATA_TYPE()] = d->m_BaseDataType;
     result[us::ServiceConstants::SERVICE_RANKING()] = this->GetRanking();
 
     //  for (IFileWriter::OptionList::const_iterator it = d->m_Options.begin(); it != d->m_Options.end(); ++it)
     //  {
     //    result[it->first] = std::string("true");
     //  }
     return result;
   }
 
   const CustomMimeType *AbstractFileWriter::GetMimeType() const { return d->GetMimeType(); }
   void AbstractFileWriter::SetMimeTypePrefix(const std::string &prefix) { d->SetMimeTypePrefix(prefix); }
   std::string AbstractFileWriter::GetMimeTypePrefix() const { return d->GetMimeTypePrefix(); }
   us::ServiceRegistration<CustomMimeType> AbstractFileWriter::RegisterMimeType(us::ModuleContext *context)
   {
     return d->RegisterMimeType(context);
   }
 
   void AbstractFileWriter::SetMimeType(const CustomMimeType &mimeType) { d->SetMimeType(mimeType); }
   void AbstractFileWriter::SetRanking(int ranking) { d->SetRanking(ranking); }
   //////////////////////// Options ///////////////////////
 
   void AbstractFileWriter::SetDefaultOptions(const IFileWriter::Options &defaultOptions)
   {
     d->SetDefaultOptions(defaultOptions);
   }
 
   IFileWriter::Options AbstractFileWriter::GetDefaultOptions() const { return d->GetDefaultOptions(); }
   IFileWriter::Options AbstractFileWriter::GetOptions() const { return d->GetOptions(); }
   us::Any AbstractFileWriter::GetOption(const std::string &name) const { return d->GetOption(name); }
   void AbstractFileWriter::SetOption(const std::string &name, const us::Any &value) { d->SetOption(name, value); }
   void AbstractFileWriter::SetOptions(const Options &options) { d->SetOptions(options); }
   ////////////////// MISC //////////////////
 
   void AbstractFileWriter::AddProgressCallback(const ProgressCallback &callback) { d->AddProgressCallback(callback); }
   void AbstractFileWriter::RemoveProgressCallback(const ProgressCallback &callback)
   {
     d->RemoveProgressCallback(callback);
   }
 
   ////////////////// µS related Getters //////////////////
 
   int AbstractFileWriter::GetRanking() const { return d->GetRanking(); }
   void AbstractFileWriter::SetBaseDataType(const std::string &baseDataType) { d->m_BaseDataType = baseDataType; }
   std::string AbstractFileWriter::GetDescription() const { return d->GetDescription(); }
   std::string AbstractFileWriter::GetBaseDataType() const { return d->m_BaseDataType; }
   void AbstractFileWriter::ValidateOutputLocation() const
   {
     if (this->GetOutputStream() == nullptr)
     {
       // check if a file name is set and if we can write to it
       const std::string fileName = this->GetOutputLocation();
       if (fileName.empty())
       {
         mitkThrow() << "No output location or stream specified";
       }
     }
   }
 
   void AbstractFileWriter::SetDescription(const std::string &description) { d->SetDescription(description); }
 }
diff --git a/Modules/Core/src/IO/mitkCustomMimeType.cpp b/Modules/Core/src/IO/mitkCustomMimeType.cpp
index 30b54ef962..77b3aa0507 100644
--- a/Modules/Core/src/IO/mitkCustomMimeType.cpp
+++ b/Modules/Core/src/IO/mitkCustomMimeType.cpp
@@ -1,161 +1,163 @@
 /*============================================================================
 
 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 "mitkCustomMimeType.h"
 
 #include "mitkMimeType.h"
 
+#include <mitkUtf8Util.h>
+
 #include <algorithm>
 
 #include <itksys/SystemTools.hxx>
 
 namespace mitk
 {
   class FindCaseInsensitive
   {
   public:
     FindCaseInsensitive(std::string value)
     {
       lcValue.resize(value.size());
       std::transform(value.begin(), value.end(), lcValue.begin(), ::tolower);
     }
 
     bool operator()(std::string elem)
     {
       std::transform(elem.begin(), elem.end(), elem.begin(), ::tolower);
       return elem == lcValue;
     }
 
   private:
     std::string lcValue;
   };
 
   struct CustomMimeType::Impl
   {
     std::string m_Name;
     std::string m_Category;
     std::vector<std::string> m_Extensions;
     std::string m_Comment;
   };
 
   CustomMimeType::~CustomMimeType() { delete d; }
   CustomMimeType::CustomMimeType() : d(new Impl) {}
   CustomMimeType::CustomMimeType(const std::string &name) : d(new Impl) { d->m_Name = name; }
   CustomMimeType::CustomMimeType(const CustomMimeType &other) : d(new Impl(*other.d)) {}
   CustomMimeType::CustomMimeType(const MimeType &other) : d(new Impl)
   {
     d->m_Name = other.GetName();
     d->m_Category = other.GetCategory();
     d->m_Extensions = other.GetExtensions();
     d->m_Comment = other.GetComment();
   }
 
   CustomMimeType &CustomMimeType::operator=(const CustomMimeType &other)
   {
     CustomMimeType tmp(other);
     Swap(tmp);
     return *this;
   }
 
   CustomMimeType &CustomMimeType::operator=(const MimeType &other)
   {
     CustomMimeType tmp(other);
     Swap(tmp);
     return *this;
   }
 
   std::string CustomMimeType::GetName() const { return d->m_Name; }
   std::string CustomMimeType::GetCategory() const { return d->m_Category; }
   std::vector<std::string> CustomMimeType::GetExtensions() const { return d->m_Extensions; }
   std::string CustomMimeType::GetComment() const
   {
     if (!d->m_Comment.empty())
       return d->m_Comment;
     if (!d->m_Extensions.empty())
     {
       return d->m_Extensions.front() + " File";
     }
     return "Unknown";
   }
 
   bool CustomMimeType::AppliesTo(const std::string &path) const { return MatchesExtension(path); }
   bool CustomMimeType::MatchesExtension(const std::string &path) const
   {
     std::string extension, filename;
     return ParsePathForExtension(path, extension, filename);
   }
 
   std::string CustomMimeType::GetExtension(const std::string &path) const
   {
     std::string extension, filename;
     ParsePathForExtension(path, extension, filename);
     return extension;
   }
 
   std::string CustomMimeType::GetFilenameWithoutExtension(const std::string &path) const
   {
     std::string extension, filename;
     ParsePathForExtension(path, extension, filename);
     return filename;
   }
 
   bool CustomMimeType::ParsePathForExtension(const std::string &path,
                                              std::string &extension,
                                              std::string &filename) const
   {
     for (std::vector<std::string>::const_iterator iter = d->m_Extensions.begin(), iterEnd = d->m_Extensions.end();
          iter != iterEnd;
          ++iter)
     {
       if (!iter->empty() && path.size() >= iter->size())
       {
         FindCaseInsensitive cmp(*iter);
         if (cmp(path.substr(path.size() - iter->size())))
         {
           extension = "." + *iter;
-          std::string filenameWithExtension = itksys::SystemTools::GetFilenameName(path);
+          std::string filenameWithExtension = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetFilenameName(Utf8Util::Local8BitToUtf8(path)));
           filename = filenameWithExtension.substr(0, filenameWithExtension.size() - extension.size());
           return true;
         }
       }
     }
     return false;
   }
 
   void CustomMimeType::SetName(const std::string &name) { d->m_Name = name; }
   void CustomMimeType::SetCategory(const std::string &category) { d->m_Category = category; }
   void CustomMimeType::SetExtension(const std::string &extension)
   {
     d->m_Extensions.clear();
     d->m_Extensions.push_back(extension);
   }
 
   void CustomMimeType::AddExtension(const std::string &extension)
   {
     if (std::find_if(d->m_Extensions.begin(), d->m_Extensions.end(), FindCaseInsensitive(extension)) ==
         d->m_Extensions.end())
     {
       d->m_Extensions.push_back(extension);
     }
   }
 
   void CustomMimeType::SetComment(const std::string &comment) { d->m_Comment = comment; }
   void CustomMimeType::Swap(CustomMimeType &r)
   {
     Impl *d1 = d;
     d = r.d;
     r.d = d1;
   }
 
   CustomMimeType *CustomMimeType::Clone() const { return new CustomMimeType(*this); }
   void swap(CustomMimeType &l, CustomMimeType &r) { l.Swap(r); }
 }
diff --git a/Modules/Core/src/IO/mitkFileReaderSelector.cpp b/Modules/Core/src/IO/mitkFileReaderSelector.cpp
index 5f7e2fb579..e4ef79a8a5 100644
--- a/Modules/Core/src/IO/mitkFileReaderSelector.cpp
+++ b/Modules/Core/src/IO/mitkFileReaderSelector.cpp
@@ -1,222 +1,223 @@
 /*============================================================================
 
 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 "mitkFileReaderSelector.h"
 
 #include <mitkCoreServices.h>
 #include <mitkFileReaderRegistry.h>
 #include <mitkIMimeTypeProvider.h>
+#include <mitkUtf8Util.h>
 
 #include <usAny.h>
 #include <usServiceProperties.h>
 #include <usServiceReference.h>
 
 #include <itksys/SystemTools.hxx>
 
 namespace mitk
 {
   struct FileReaderSelector::Item::Impl : us::SharedData
   {
     Impl() : m_FileReader(nullptr), m_ConfidenceLevel(IFileReader::Unsupported), m_Id(-1) {}
     us::ServiceReference<IFileReader> m_FileReaderRef;
     IFileReader *m_FileReader;
     IFileReader::ConfidenceLevel m_ConfidenceLevel;
     MimeType m_MimeType;
     long m_Id;
   };
 
   struct FileReaderSelector::Impl : us::SharedData
   {
     Impl() : m_BestId(-1), m_SelectedId(m_BestId) {}
     Impl(const Impl &other) : us::SharedData(other), m_BestId(-1), m_SelectedId(m_BestId) {}
     FileReaderRegistry m_ReaderRegistry;
     std::map<long, FileReaderSelector::Item> m_Items;
     std::vector<MimeType> m_MimeTypes;
     long m_BestId;
     long m_SelectedId;
   };
 
   FileReaderSelector::FileReaderSelector(const FileReaderSelector &other) : m_Data(other.m_Data) {}
   FileReaderSelector::FileReaderSelector(const std::string &path) : m_Data(new Impl)
   {
-    if (!itksys::SystemTools::FileExists(path.c_str()))
+    if (!itksys::SystemTools::FileExists(Utf8Util::Local8BitToUtf8(path).c_str()))
     {
       return;
     }
 
     mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
 
     // Get all mime types and associated readers for the given file path
 
     m_Data->m_MimeTypes = mimeTypeProvider->GetMimeTypesForFile(path);
     if (m_Data->m_MimeTypes.empty())
       return;
 
     for (std::vector<MimeType>::const_iterator mimeTypeIter = m_Data->m_MimeTypes.begin(),
                                                mimeTypeIterEnd = m_Data->m_MimeTypes.end();
          mimeTypeIter != mimeTypeIterEnd;
          ++mimeTypeIter)
     {
       std::vector<FileReaderRegistry::ReaderReference> refs = m_Data->m_ReaderRegistry.GetReferences(*mimeTypeIter);
       for (std::vector<FileReaderRegistry::ReaderReference>::const_iterator readerIter = refs.begin(),
                                                                             iterEnd = refs.end();
            readerIter != iterEnd;
            ++readerIter)
       {
         IFileReader *reader = m_Data->m_ReaderRegistry.GetReader(*readerIter);
         if (reader == nullptr)
           continue;
         try
         {
           reader->SetInput(path);
           IFileReader::ConfidenceLevel confidenceLevel = reader->GetConfidenceLevel();
           if (confidenceLevel == IFileReader::Unsupported)
           {
             continue;
           }
 
           Item item;
           item.d->m_FileReaderRef = *readerIter;
           item.d->m_FileReader = reader;
           item.d->m_ConfidenceLevel = confidenceLevel;
           item.d->m_MimeType = *mimeTypeIter;
           item.d->m_Id = us::any_cast<long>(readerIter->GetProperty(us::ServiceConstants::SERVICE_ID()));
           m_Data->m_Items.insert(std::make_pair(item.d->m_Id, item));
           // m_Data->m_MimeTypes.insert(mimeType);
         }
         catch (const us::BadAnyCastException &e)
         {
           MITK_WARN << "Unexpected: " << e.what();
         }
         catch (const std::exception &e)
         {
           // Log the error but continue
           MITK_WARN << "IFileWriter::GetConfidenceLevel exception: " << e.what();
         }
       }
     }
 
     // get the "best" reader
 
     if (!m_Data->m_Items.empty())
     {
       std::set<Item> sortedItems;
       for (std::map<long, Item>::const_iterator iter = m_Data->m_Items.begin(), iterEnd = m_Data->m_Items.end();
            iter != iterEnd;
            ++iter)
       {
         sortedItems.insert(iter->second);
       }
       m_Data->m_BestId = sortedItems.rbegin()->GetServiceId();
       m_Data->m_SelectedId = m_Data->m_BestId;
     }
   }
 
   FileReaderSelector::~FileReaderSelector() {}
   FileReaderSelector &FileReaderSelector::operator=(const FileReaderSelector &other)
   {
     m_Data = other.m_Data;
     return *this;
   }
 
   bool FileReaderSelector::IsEmpty() const { return m_Data->m_Items.empty(); }
   std::vector<MimeType> FileReaderSelector::GetMimeTypes() const { return m_Data->m_MimeTypes; }
   std::vector<FileReaderSelector::Item> FileReaderSelector::Get() const
   {
     std::vector<Item> result;
     for (std::map<long, Item>::const_iterator iter = m_Data->m_Items.begin(), iterEnd = m_Data->m_Items.end();
          iter != iterEnd;
          ++iter)
     {
       result.push_back(iter->second);
     }
     std::sort(result.begin(), result.end());
     return result;
   }
 
   FileReaderSelector::Item FileReaderSelector::Get(long id) const
   {
     std::map<long, Item>::const_iterator iter = m_Data->m_Items.find(id);
     if (iter != m_Data->m_Items.end())
     {
       return iter->second;
     }
     return Item();
   }
 
   FileReaderSelector::Item FileReaderSelector::GetDefault() const { return Get(m_Data->m_BestId); }
   long FileReaderSelector::GetDefaultId() const { return m_Data->m_BestId; }
   FileReaderSelector::Item FileReaderSelector::GetSelected() const { return Get(m_Data->m_SelectedId); }
   long FileReaderSelector::GetSelectedId() const { return m_Data->m_SelectedId; }
   bool FileReaderSelector::Select(const FileReaderSelector::Item &item) { return Select(item.d->m_Id); }
   bool FileReaderSelector::Select(long id)
   {
     if (id > -1)
     {
       if (m_Data->m_Items.find(id) == m_Data->m_Items.end())
       {
         return false;
       }
       m_Data->m_SelectedId = id;
       return true;
     }
     return false;
   }
 
   void FileReaderSelector::Swap(FileReaderSelector &fws) { m_Data.Swap(fws.m_Data); }
   FileReaderSelector::Item::Item(const FileReaderSelector::Item &other) : d(other.d) {}
   FileReaderSelector::Item::~Item() {}
   FileReaderSelector::Item &FileReaderSelector::Item::operator=(const FileReaderSelector::Item &other)
   {
     d = other.d;
     return *this;
   }
 
   IFileReader *FileReaderSelector::Item::GetReader() const { return d->m_FileReader; }
   std::string FileReaderSelector::Item::GetDescription() const
   {
     us::Any descr = d->m_FileReaderRef.GetProperty(IFileReader::PROP_DESCRIPTION());
     if (descr.Empty())
       return std::string();
     return descr.ToString();
   }
 
   IFileReader::ConfidenceLevel FileReaderSelector::Item::GetConfidenceLevel() const { return d->m_ConfidenceLevel; }
   MimeType FileReaderSelector::Item::GetMimeType() const { return d->m_MimeType; }
   us::ServiceReference<IFileReader> FileReaderSelector::Item::GetReference() const { return d->m_FileReaderRef; }
   long FileReaderSelector::Item::GetServiceId() const { return d->m_Id; }
   bool FileReaderSelector::Item::operator<(const FileReaderSelector::Item &other) const
   {
     // sort by confidence level first (ascending)
     if (d->m_ConfidenceLevel == other.d->m_ConfidenceLevel)
     {
       // sort by mime-type ranking
       if (d->m_MimeType < other.d->m_MimeType)
       {
         return true;
       }
       else if (other.d->m_MimeType < d->m_MimeType)
       {
         return false;
       }
       else
       {
         // sort by file writer service ranking
         return d->m_FileReaderRef < other.d->m_FileReaderRef;
       }
     }
     return d->m_ConfidenceLevel < other.d->m_ConfidenceLevel;
   }
 
   FileReaderSelector::Item::Item() : d(new Impl()) {}
   void swap(FileReaderSelector &frs1, FileReaderSelector &frs2) { frs1.Swap(frs2); }
 }
diff --git a/Modules/Core/src/IO/mitkFileWriterSelector.cpp b/Modules/Core/src/IO/mitkFileWriterSelector.cpp
index dbc14e6be4..116d6a2596 100644
--- a/Modules/Core/src/IO/mitkFileWriterSelector.cpp
+++ b/Modules/Core/src/IO/mitkFileWriterSelector.cpp
@@ -1,290 +1,291 @@
 /*============================================================================
 
 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 "mitkFileWriterSelector.h"
 
 #include <mitkBaseData.h>
 #include <mitkCoreServices.h>
 #include <mitkFileWriterRegistry.h>
 #include <mitkIMimeTypeProvider.h>
+#include <mitkUtf8Util.h>
 
 #include <usAny.h>
 #include <usServiceProperties.h>
 #include <usServiceReference.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <iterator>
 #include <limits>
 #include <set>
 
 namespace mitk
 {
   struct FileWriterSelector::Item::Impl : us::SharedData
   {
     Impl() : m_FileWriter(nullptr), m_ConfidenceLevel(IFileWriter::Unsupported), m_BaseDataIndex(0), m_Id(-1) {}
     us::ServiceReference<IFileWriter> m_FileWriterRef;
     IFileWriter *m_FileWriter;
     IFileWriter::ConfidenceLevel m_ConfidenceLevel;
     std::size_t m_BaseDataIndex;
     MimeType m_MimeType;
     long m_Id;
   };
 
   struct FileWriterSelector::Impl : us::SharedData
   {
     Impl() : m_BestId(-1), m_SelectedId(m_BestId) {}
     Impl(const Impl &other) : us::SharedData(other), m_BestId(-1), m_SelectedId(m_BestId) {}
     FileWriterRegistry m_WriterRegistry;
     std::map<long, FileWriterSelector::Item> m_Items;
     std::set<MimeType> m_MimeTypes;
     long m_BestId;
     long m_SelectedId;
   };
 
   FileWriterSelector::FileWriterSelector(const FileWriterSelector &other) : m_Data(other.m_Data) {}
   FileWriterSelector::FileWriterSelector(const BaseData *baseData, const std::string &mimeType, const std::string &path)
     : m_Data(new Impl)
   {
     mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
 
     std::vector<FileWriterRegistry::WriterReference> refs;
 
     std::string destMimeType = mimeType;
     if (destMimeType.empty() && !path.empty())
     {
       // try to derive a mime-type from the file
       std::vector<MimeType> mimeTypes = mimeTypeProvider->GetMimeTypesForFile(path);
       if (!mimeTypes.empty())
       {
         for (unsigned int index = 0; index < mimeTypes.size(); index++)
         {
           std::vector<FileWriterRegistry::WriterReference> tempRefs =
             m_Data->m_WriterRegistry.GetReferences(baseData, mimeTypes.at(index).GetName());
           for (unsigned int innerIndex = 0; innerIndex < tempRefs.size(); innerIndex++)
           {
             refs.push_back(tempRefs.at(innerIndex));
           }
         }
       }
-      else if (!itksys::SystemTools::GetFilenameExtension(path).empty())
+      else if (!itksys::SystemTools::GetFilenameExtension(Utf8Util::Local8BitToUtf8(path)).empty())
       {
         // If there are no suitable mime-type for the file AND an extension
         // was supplied, we stop here.
         return;
       }
       else
       {
         refs = m_Data->m_WriterRegistry.GetReferences(baseData, destMimeType);
       }
     }
     else
     {
       refs = m_Data->m_WriterRegistry.GetReferences(baseData, destMimeType);
     }
 
     std::vector<std::string> classHierarchy = baseData->GetClassHierarchy();
 
     // Get all writers and their mime types for the given base data type
     Item bestItem;
     for (std::vector<FileWriterRegistry::WriterReference>::const_iterator iter = refs.begin(), iterEnd = refs.end();
          iter != iterEnd;
          ++iter)
     {
       std::string mimeTypeName = iter->GetProperty(IFileWriter::PROP_MIMETYPE()).ToString();
       if (!mimeTypeName.empty())
       {
         MimeType mimeType = mimeTypeProvider->GetMimeTypeForName(mimeTypeName);
         if (mimeType.IsValid())
         {
           // There is a registered mime-type for this writer. Now get the confidence level
           // of this writer for writing the given base data object.
 
           IFileWriter *writer = m_Data->m_WriterRegistry.GetWriter(*iter);
           if (writer == nullptr)
             continue;
           try
           {
             writer->SetInput(baseData);
             IFileWriter::ConfidenceLevel confidenceLevel = writer->GetConfidenceLevel();
             if (confidenceLevel == IFileWriter::Unsupported)
             {
               continue;
             }
 
             std::string baseDataType = iter->GetProperty(IFileWriter::PROP_BASEDATA_TYPE()).ToString();
             auto idxIter =
               std::find(classHierarchy.begin(), classHierarchy.end(), baseDataType);
             std::size_t baseDataIndex = std::numeric_limits<std::size_t>::max();
             if (idxIter != classHierarchy.end())
             {
               baseDataIndex = std::distance(classHierarchy.begin(), idxIter);
             }
 
             Item item;
             item.d->m_FileWriterRef = *iter;
             item.d->m_FileWriter = writer;
             item.d->m_ConfidenceLevel = confidenceLevel;
             item.d->m_BaseDataIndex = baseDataIndex;
             item.d->m_MimeType = mimeType;
             item.d->m_Id = us::any_cast<long>(iter->GetProperty(us::ServiceConstants::SERVICE_ID()));
             m_Data->m_Items.insert(std::make_pair(item.d->m_Id, item));
             m_Data->m_MimeTypes.insert(mimeType);
             if (!bestItem.GetReference() || bestItem < item)
             {
               bestItem = item;
             }
           }
           catch (const us::BadAnyCastException &e)
           {
             MITK_WARN << "Unexpected: " << e.what();
           }
           catch (const std::exception &e)
           {
             // Log the error but continue
             MITK_WARN << "IFileWriter::GetConfidenceLevel exception: " << e.what();
           }
         }
       }
     }
 
     if (bestItem.GetReference())
     {
       m_Data->m_BestId = bestItem.GetServiceId();
       m_Data->m_SelectedId = m_Data->m_BestId;
     }
   }
 
   FileWriterSelector::~FileWriterSelector() {}
   FileWriterSelector &FileWriterSelector::operator=(const FileWriterSelector &other)
   {
     m_Data = other.m_Data;
     return *this;
   }
 
   bool FileWriterSelector::IsEmpty() const { return m_Data->m_Items.empty(); }
   std::vector<FileWriterSelector::Item> FileWriterSelector::Get(const std::string &mimeType) const
   {
     std::vector<Item> result;
     for (std::map<long, Item>::const_iterator iter = m_Data->m_Items.begin(), iterEnd = m_Data->m_Items.end();
          iter != iterEnd;
          ++iter)
     {
       if (mimeType.empty() || iter->second.GetMimeType().GetName() == mimeType)
       {
         result.push_back(iter->second);
       }
     }
     std::sort(result.begin(), result.end());
     return result;
   }
 
   std::vector<FileWriterSelector::Item> FileWriterSelector::Get() const
   {
     return Get(this->GetSelected().d->m_MimeType.GetName());
   }
 
   FileWriterSelector::Item FileWriterSelector::Get(long id) const
   {
     std::map<long, Item>::const_iterator iter = m_Data->m_Items.find(id);
     if (iter != m_Data->m_Items.end())
     {
       return iter->second;
     }
     return Item();
   }
 
   FileWriterSelector::Item FileWriterSelector::GetDefault() const { return Get(m_Data->m_BestId); }
   long FileWriterSelector::GetDefaultId() const { return m_Data->m_BestId; }
   FileWriterSelector::Item FileWriterSelector::GetSelected() const { return Get(m_Data->m_SelectedId); }
   long FileWriterSelector::GetSelectedId() const { return m_Data->m_SelectedId; }
   bool FileWriterSelector::Select(const std::string &mimeType)
   {
     std::vector<Item> items = Get(mimeType);
     if (items.empty())
       return false;
     return Select(items.back());
   }
 
   bool FileWriterSelector::Select(const FileWriterSelector::Item &item) { return Select(item.d->m_Id); }
   bool FileWriterSelector::Select(long id)
   {
     if (id > -1)
     {
       if (m_Data->m_Items.find(id) == m_Data->m_Items.end())
       {
         return false;
       }
       m_Data->m_SelectedId = id;
       return true;
     }
     return false;
   }
 
   std::vector<MimeType> FileWriterSelector::GetMimeTypes() const
   {
     std::vector<MimeType> result;
     result.reserve(m_Data->m_MimeTypes.size());
     result.assign(m_Data->m_MimeTypes.begin(), m_Data->m_MimeTypes.end());
     return result;
   }
 
   void FileWriterSelector::Swap(FileWriterSelector &fws) { m_Data.Swap(fws.m_Data); }
   FileWriterSelector::Item::Item(const FileWriterSelector::Item &other) : d(other.d) {}
   FileWriterSelector::Item::~Item() {}
   FileWriterSelector::Item &FileWriterSelector::Item::operator=(const FileWriterSelector::Item &other)
   {
     d = other.d;
     return *this;
   }
 
   IFileWriter *FileWriterSelector::Item::GetWriter() const { return d->m_FileWriter; }
   std::string FileWriterSelector::Item::GetDescription() const
   {
     us::Any descr = d->m_FileWriterRef.GetProperty(IFileWriter::PROP_DESCRIPTION());
     if (descr.Empty())
       return std::string();
     return descr.ToString();
   }
 
   IFileWriter::ConfidenceLevel FileWriterSelector::Item::GetConfidenceLevel() const { return d->m_ConfidenceLevel; }
   MimeType FileWriterSelector::Item::GetMimeType() const { return d->m_MimeType; }
   std::string FileWriterSelector::Item::GetBaseDataType() const
   {
     us::Any any = d->m_FileWriterRef.GetProperty(IFileWriter::PROP_BASEDATA_TYPE());
     if (any.Empty())
       return std::string();
     return any.ToString();
   }
 
   us::ServiceReference<IFileWriter> FileWriterSelector::Item::GetReference() const { return d->m_FileWriterRef; }
   long FileWriterSelector::Item::GetServiceId() const { return d->m_Id; }
   bool FileWriterSelector::Item::operator<(const FileWriterSelector::Item &other) const
   {
     // sort by confidence level first (ascending)
     if (d->m_ConfidenceLevel == other.d->m_ConfidenceLevel)
     {
       // sort by class hierarchy index (writers for more derived
       // based data types are considered a better match)
       if (d->m_BaseDataIndex == other.d->m_BaseDataIndex)
       {
         // sort by file writer service ranking
         return d->m_FileWriterRef < other.d->m_FileWriterRef;
       }
       return other.d->m_BaseDataIndex < d->m_BaseDataIndex;
     }
     return d->m_ConfidenceLevel < other.d->m_ConfidenceLevel;
   }
 
   FileWriterSelector::Item::Item() : d(new Impl()) {}
   void swap(FileWriterSelector &fws1, FileWriterSelector &fws2) { fws1.Swap(fws2); }
 }
diff --git a/Modules/Core/src/IO/mitkIOMimeTypes.cpp b/Modules/Core/src/IO/mitkIOMimeTypes.cpp
index 34c558825a..0dd2af91a8 100644
--- a/Modules/Core/src/IO/mitkIOMimeTypes.cpp
+++ b/Modules/Core/src/IO/mitkIOMimeTypes.cpp
@@ -1,363 +1,365 @@
 /*============================================================================
 
 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 "mitkIOMimeTypes.h"
 
 #include "mitkCustomMimeType.h"
 #include "mitkLogMacros.h"
+#include <mitkUtf8Util.h>
 
 #include "itkGDCMImageIO.h"
 #include "itkMetaDataObject.h"
 
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 
 namespace mitk
 {
   IOMimeTypes::BaseDicomMimeType::BaseDicomMimeType(const std::string& name) : CustomMimeType(name)
   {
     this->AddExtension("gdcm");
     this->AddExtension("dcm");
     this->AddExtension("DCM");
     this->AddExtension("dc3");
     this->AddExtension("DC3");
     this->AddExtension("ima");
     this->AddExtension("img");
 
     this->SetCategory(CATEGORY_IMAGES());
     this->SetComment("DICOM");
   }
 
   bool IOMimeTypes::BaseDicomMimeType::AppliesTo(const std::string &path) const
   {
     // check whether directory or file
     // if directory try to find first file within it instead
-    bool pathIsDirectory = itksys::SystemTools::FileIsDirectory(path);
+    bool pathIsDirectory = itksys::SystemTools::FileIsDirectory(Utf8Util::Local8BitToUtf8(path));
 
     std::string filepath = path;
 
     if (pathIsDirectory)
     {
       itksys::Directory input;
       input.Load(path.c_str());
 
       std::vector<std::string> files;
       for (unsigned long idx = 0; idx<input.GetNumberOfFiles(); idx++)
       {
-        auto filename = input.GetFile(idx);
+        auto filename = Utf8Util::Local8BitToUtf8(input.GetFile(idx));
+
         if (!itksys::SystemTools::FileIsDirectory(filename) && this->MatchesExtension(filename))
         {
           std::string fullpath = path + "/" + std::string(input.GetFile(idx));
           files.push_back(fullpath.c_str());
         }
       }
       if (!files.empty())
       {
         filepath = files.front();
       }
     }
 
     // Ask the GDCM ImageIO class directly
     itk::GDCMImageIO::Pointer gdcmIO = itk::GDCMImageIO::New();
     gdcmIO->SetFileName(filepath);
     try {
       gdcmIO->ReadImageInformation();
     }
     catch (const itk::ExceptionObject & /*err*/) {
       return false;
     }
 
     //DICOMRT modalities have specific reader, don't read with normal DICOM readers
     std::string modality;
     itk::MetaDataDictionary& dict = gdcmIO->GetMetaDataDictionary();
     itk::ExposeMetaData<std::string>(dict, "0008|0060", modality);
     MITK_DEBUG << "DICOM Modality detected by MimeType "<< this->GetName() << " is " << modality;
     if (modality == "RTSTRUCT" || modality == "RTDOSE" || modality == "RTPLAN") {
       return false;
     }
     else {
       return gdcmIO->CanReadFile(filepath.c_str());
     }
   }
 
   IOMimeTypes::BaseDicomMimeType*IOMimeTypes::BaseDicomMimeType::Clone() const { return new BaseDicomMimeType(*this); }
 
   IOMimeTypes::DicomMimeType::DicomMimeType() : BaseDicomMimeType(DICOM_MIMETYPE_NAME())
   {
   }
 
   IOMimeTypes::DicomMimeType* IOMimeTypes::DicomMimeType::Clone() const { return new DicomMimeType(*this); }
 
   std::vector<CustomMimeType *> IOMimeTypes::Get()
   {
     std::vector<CustomMimeType *> mimeTypes;
 
     // order matters here (descending rank for mime types)
 
     mimeTypes.push_back(NRRD_MIMETYPE().Clone());
     mimeTypes.push_back(NIFTI_MIMETYPE().Clone());
 
     mimeTypes.push_back(VTK_IMAGE_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_PARALLEL_IMAGE_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_IMAGE_LEGACY_MIMETYPE().Clone());
 
     mimeTypes.push_back(DICOM_MIMETYPE().Clone());
 
     mimeTypes.push_back(VTK_POLYDATA_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_PARALLEL_POLYDATA_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_POLYDATA_LEGACY_MIMETYPE().Clone());
 
     mimeTypes.push_back(STEREOLITHOGRAPHY_MIMETYPE().Clone());
     mimeTypes.push_back(WAVEFRONT_OBJ_MIMETYPE().Clone());
     mimeTypes.push_back(STANFORD_PLY_MIMETYPE().Clone());
 
     mimeTypes.push_back(RAW_MIMETYPE().Clone());
     mimeTypes.push_back(POINTSET_MIMETYPE().Clone());
     return mimeTypes;
   }
 
   CustomMimeType IOMimeTypes::VTK_IMAGE_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_IMAGE_NAME());
     mimeType.AddExtension("vti");
     mimeType.SetCategory(CATEGORY_IMAGES());
     mimeType.SetComment("VTK Image");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_IMAGE_LEGACY_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_IMAGE_LEGACY_NAME());
     mimeType.AddExtension("vtk");
     mimeType.SetCategory(CATEGORY_IMAGES());
     mimeType.SetComment("VTK Legacy Image");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_PARALLEL_IMAGE_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_PARALLEL_IMAGE_NAME());
     mimeType.AddExtension("pvti");
     mimeType.SetCategory(CATEGORY_IMAGES());
     mimeType.SetComment("VTK Parallel Image");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_POLYDATA_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_POLYDATA_NAME());
     mimeType.AddExtension("vtp");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("VTK PolyData");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_POLYDATA_LEGACY_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_POLYDATA_LEGACY_NAME());
     mimeType.AddExtension("vtk");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("VTK Legacy PolyData");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_PARALLEL_POLYDATA_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_PARALLEL_POLYDATA_NAME());
     mimeType.AddExtension("pvtp");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("VTK Parallel PolyData");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::STEREOLITHOGRAPHY_MIMETYPE()
   {
     CustomMimeType mimeType(STEREOLITHOGRAPHY_NAME());
     mimeType.AddExtension("stl");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("Stereolithography");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::WAVEFRONT_OBJ_MIMETYPE()
   {
     CustomMimeType mimeType(WAVEFRONT_OBJ_NAME());
     mimeType.AddExtension("obj");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("Wavefront OBJ");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::STANFORD_PLY_MIMETYPE()
   {
     CustomMimeType mimeType(STANFORD_PLY_NAME());
     mimeType.AddExtension("ply");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("Stanford PLY");
     return mimeType;
   }
 
   std::string IOMimeTypes::STEREOLITHOGRAPHY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".stl";
     return name;
   }
 
   std::string IOMimeTypes::WAVEFRONT_OBJ_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".obj";
     return name;
   }
 
   std::string IOMimeTypes::STANFORD_PLY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".ply";
     return name;
   }
 
   std::string IOMimeTypes::DEFAULT_BASE_NAME()
   {
     static std::string name = "application/vnd.mitk";
     return name;
   }
 
   std::string IOMimeTypes::CATEGORY_IMAGES()
   {
     static std::string cat = "Images";
     return cat;
   }
 
   std::string IOMimeTypes::CATEGORY_SURFACES()
   {
     static std::string cat = "Surfaces";
     return cat;
   }
 
   std::string IOMimeTypes::VTK_IMAGE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.image";
     return name;
   }
 
   std::string IOMimeTypes::VTK_IMAGE_LEGACY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.image.legacy";
     return name;
   }
 
   std::string IOMimeTypes::VTK_PARALLEL_IMAGE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.parallel.image";
     return name;
   }
 
   std::string IOMimeTypes::VTK_POLYDATA_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.polydata";
     return name;
   }
 
   std::string IOMimeTypes::VTK_POLYDATA_LEGACY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.polydata.legacy";
     return name;
   }
 
   std::string IOMimeTypes::VTK_PARALLEL_POLYDATA_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.parallel.polydata";
     return name;
   }
 
   CustomMimeType IOMimeTypes::NRRD_MIMETYPE()
   {
     CustomMimeType mimeType(NRRD_MIMETYPE_NAME());
     mimeType.AddExtension("nrrd");
     mimeType.AddExtension("nhdr");
     mimeType.SetCategory("Images");
     mimeType.SetComment("NRRD");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::NIFTI_MIMETYPE()
   {
     CustomMimeType mimeType(NIFTI_MIMETYPE_NAME());
     mimeType.AddExtension("nii");
     mimeType.AddExtension("nii.gz");
     mimeType.AddExtension("hdr");
     mimeType.AddExtension("hdr.gz");
     mimeType.AddExtension("img");
     mimeType.AddExtension("img.gz");
     mimeType.AddExtension("nia");
     mimeType.SetCategory("Images");
     mimeType.SetComment("Nifti");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::RAW_MIMETYPE()
   {
     CustomMimeType mimeType(RAW_MIMETYPE_NAME());
     mimeType.AddExtension("raw");
     mimeType.SetCategory("Images");
     mimeType.SetComment("Raw data");
     return mimeType;
   }
 
   IOMimeTypes::DicomMimeType IOMimeTypes::DICOM_MIMETYPE() { return DicomMimeType(); }
   std::string IOMimeTypes::NRRD_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.nrrd";
     return name;
   }
 
   std::string IOMimeTypes::NIFTI_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.nifti";
     return name;
   }
 
   std::string IOMimeTypes::RAW_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.raw";
     return name;
   }
 
   std::string IOMimeTypes::DICOM_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.dicom";
     return name;
   }
 
   CustomMimeType IOMimeTypes::POINTSET_MIMETYPE()
   {
     CustomMimeType mimeType(POINTSET_MIMETYPE_NAME());
     mimeType.AddExtension("mps");
     mimeType.SetCategory("Point Sets");
     mimeType.SetComment("MITK Point Set");
     return mimeType;
   }
 
   std::string IOMimeTypes::POINTSET_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".pointset";
     return name;
   }
 
   CustomMimeType IOMimeTypes::GEOMETRY_DATA_MIMETYPE()
   {
     mitk::CustomMimeType mimeType(DEFAULT_BASE_NAME() + ".geometrydata");
     mimeType.AddExtension("mitkgeometry");
     mimeType.SetCategory("Geometries");
     mimeType.SetComment("GeometryData object");
     return mimeType;
   }
 }
diff --git a/Modules/Core/src/IO/mitkIOUtil.cpp b/Modules/Core/src/IO/mitkIOUtil.cpp
index 4be4cfbadf..5cf1ecba84 100644
--- a/Modules/Core/src/IO/mitkIOUtil.cpp
+++ b/Modules/Core/src/IO/mitkIOUtil.cpp
@@ -1,1063 +1,991 @@
 /*============================================================================
 
 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 "mitkIOUtil.h"
 
 #include <mitkCoreObjectFactory.h>
 #include <mitkCoreServices.h>
 #include <mitkExceptionMacro.h>
 #include <mitkFileReaderRegistry.h>
 #include <mitkFileWriterRegistry.h>
 #include <mitkIMimeTypeProvider.h>
 #include <mitkProgressBar.h>
 #include <mitkStandaloneDataStorage.h>
 #include <usGetModuleContext.h>
 #include <usLDAPProp.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <mitkAbstractFileReader.h>
+#include <mitkUtf8Util.h>
 
 // ITK
 #include <itksys/SystemTools.hxx>
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 #include <vtkTriangleFilter.h>
 
 #include <cerrno>
 #include <cstdlib>
 
-#ifdef US_PLATFORM_WINDOWS
-
-#include <Windows.h>
-
-namespace
-{
-  std::wstring MultiByteToWideChar(const std::string& mbString, UINT codePage)
-  {
-    auto numChars = ::MultiByteToWideChar(codePage, 0, mbString.data(), mbString.size(), nullptr, 0);
-
-    if (0 >= numChars)
-      mitkThrow() << "Failure to convert multi-byte character string to wide character string";
-
-    std::wstring wString;
-    wString.resize(numChars);
-
-    ::MultiByteToWideChar(codePage, 0, mbString.data(), mbString.size(), &wString[0], static_cast<int>(wString.size()));
-
-    return wString;
-  }
-
-  std::string WideCharToMultiByte(const std::wstring& wString, UINT codePage)
-  {
-    auto numChars = ::WideCharToMultiByte(codePage, 0, wString.data(), wString.size(), nullptr, 0, nullptr, nullptr);
-
-    if (0 >= numChars)
-      mitkThrow() << "Failure to convert wide character string to multi-byte character string";
-
-    std::string mbString;
-    mbString.resize(numChars);
-
-    ::WideCharToMultiByte(codePage, 0, wString.data(), wString.size(), &mbString[0], static_cast<int>(mbString.size()), nullptr, nullptr);
-
-    return mbString;
-  }
-}
-
-#endif
-
 static 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
 }
 
 #ifdef US_PLATFORM_WINDOWS
 
 #include <direct.h>
 #include <io.h>
 
 // make the posix flags point to the obsolte bsd types on windows
 #define S_IRUSR S_IREAD
 #define S_IWUSR S_IWRITE
 
 #else
 
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #endif
 
 #include <fcntl.h>
 #include <sys/stat.h>
 
 static const char validLetters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 
 // A cross-platform version of the mkstemps function
 static int mkstemps_compat(char *tmpl, int suffixlen)
 {
   static unsigned long long value = 0;
   int savedErrno = errno;
 
 // Lower bound on the number of temporary files to attempt to generate.
 #define ATTEMPTS_MIN (62 * 62 * 62)
 
 /* The number of times to attempt to generate a temporary file.  To
    conform to POSIX, this must be no smaller than TMP_MAX.  */
 #if ATTEMPTS_MIN < TMP_MAX
   const unsigned int attempts = TMP_MAX;
 #else
   const unsigned int attempts = ATTEMPTS_MIN;
 #endif
 
   const int len = strlen(tmpl);
   if ((len - suffixlen) < 6 || strncmp(&tmpl[len - 6 - suffixlen], "XXXXXX", 6))
   {
     errno = EINVAL;
     return -1;
   }
 
   /* This is where the Xs start.  */
   char *XXXXXX = &tmpl[len - 6 - suffixlen];
 
 /* Get some more or less random data.  */
 #ifdef US_PLATFORM_WINDOWS
   {
     SYSTEMTIME stNow;
     FILETIME ftNow;
 
     // get system time
     GetSystemTime(&stNow);
     stNow.wMilliseconds = 500;
     if (!SystemTimeToFileTime(&stNow, &ftNow))
     {
       errno = -1;
       return -1;
     }
     unsigned long long randomTimeBits = ((static_cast<unsigned long long>(ftNow.dwHighDateTime) << 32) |
                                          static_cast<unsigned long long>(ftNow.dwLowDateTime));
     value = randomTimeBits ^ static_cast<unsigned long long>(GetCurrentThreadId());
   }
 #else
   {
     struct timeval tv;
     gettimeofday(&tv, nullptr);
     unsigned long long randomTimeBits =
       ((static_cast<unsigned long long>(tv.tv_usec) << 32) | static_cast<unsigned long long>(tv.tv_sec));
     value = randomTimeBits ^ static_cast<unsigned long long>(getpid());
   }
 #endif
 
   for (unsigned int count = 0; count < attempts; value += 7777, ++count)
   {
     unsigned long long v = value;
 
     /* Fill in the random bits.  */
     XXXXXX[0] = validLetters[v % 62];
     v /= 62;
     XXXXXX[1] = validLetters[v % 62];
     v /= 62;
     XXXXXX[2] = validLetters[v % 62];
     v /= 62;
     XXXXXX[3] = validLetters[v % 62];
     v /= 62;
     XXXXXX[4] = validLetters[v % 62];
     v /= 62;
     XXXXXX[5] = validLetters[v % 62];
 
     int fd = open(tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
     if (fd >= 0)
     {
       errno = savedErrno;
       return fd;
     }
     else if (errno != EEXIST)
     {
       return -1;
     }
   }
 
   /* We got out of the loop because we ran out of combinations to try.  */
   errno = EEXIST;
   return -1;
 }
 
 // A cross-platform version of the POSIX mkdtemp function
 static char *mkdtemps_compat(char *tmpl, int suffixlen)
 {
   static unsigned long long value = 0;
   int savedErrno = errno;
 
 // Lower bound on the number of temporary dirs to attempt to generate.
 #define ATTEMPTS_MIN (62 * 62 * 62)
 
 /* The number of times to attempt to generate a temporary dir.  To
    conform to POSIX, this must be no smaller than TMP_MAX.  */
 #if ATTEMPTS_MIN < TMP_MAX
   const unsigned int attempts = TMP_MAX;
 #else
   const unsigned int attempts = ATTEMPTS_MIN;
 #endif
 
   const int len = strlen(tmpl);
   if ((len - suffixlen) < 6 || strncmp(&tmpl[len - 6 - suffixlen], "XXXXXX", 6))
   {
     errno = EINVAL;
     return nullptr;
   }
 
   /* This is where the Xs start.  */
   char *XXXXXX = &tmpl[len - 6 - suffixlen];
 
 /* Get some more or less random data.  */
 #ifdef US_PLATFORM_WINDOWS
   {
     SYSTEMTIME stNow;
     FILETIME ftNow;
 
     // get system time
     GetSystemTime(&stNow);
     stNow.wMilliseconds = 500;
     if (!SystemTimeToFileTime(&stNow, &ftNow))
     {
       errno = -1;
       return nullptr;
     }
     unsigned long long randomTimeBits = ((static_cast<unsigned long long>(ftNow.dwHighDateTime) << 32) |
                                          static_cast<unsigned long long>(ftNow.dwLowDateTime));
     value = randomTimeBits ^ static_cast<unsigned long long>(GetCurrentThreadId());
   }
 #else
   {
     struct timeval tv;
     gettimeofday(&tv, nullptr);
     unsigned long long randomTimeBits =
       ((static_cast<unsigned long long>(tv.tv_usec) << 32) | static_cast<unsigned long long>(tv.tv_sec));
     value = randomTimeBits ^ static_cast<unsigned long long>(getpid());
   }
 #endif
 
   unsigned int count = 0;
   for (; count < attempts; value += 7777, ++count)
   {
     unsigned long long v = value;
 
     /* Fill in the random bits.  */
     XXXXXX[0] = validLetters[v % 62];
     v /= 62;
     XXXXXX[1] = validLetters[v % 62];
     v /= 62;
     XXXXXX[2] = validLetters[v % 62];
     v /= 62;
     XXXXXX[3] = validLetters[v % 62];
     v /= 62;
     XXXXXX[4] = validLetters[v % 62];
     v /= 62;
     XXXXXX[5] = validLetters[v % 62];
 
 #ifdef US_PLATFORM_WINDOWS
     int fd = _mkdir(tmpl); //, _S_IREAD | _S_IWRITE | _S_IEXEC);
 #else
     int fd = mkdir(tmpl, S_IRUSR | S_IWUSR | S_IXUSR);
 #endif
     if (fd >= 0)
     {
       errno = savedErrno;
       return tmpl;
     }
     else if (errno != EEXIST)
     {
       return nullptr;
     }
   }
 
   /* We got out of the loop because we ran out of combinations to try.  */
   errno = EEXIST;
   return nullptr;
 }
 
 //#endif
 
 //**************************************************************
 // mitk::IOUtil method definitions
 
 namespace mitk
 {
   struct IOUtil::Impl
   {
     struct FixedReaderOptionsFunctor : public ReaderOptionsFunctorBase
     {
       FixedReaderOptionsFunctor(const IFileReader::Options &options) : m_Options(options) {}
       bool operator()(LoadInfo &loadInfo) const override
       {
         IFileReader *reader = loadInfo.m_ReaderSelector.GetSelected().GetReader();
         if (reader)
         {
           reader->SetOptions(m_Options);
         }
         return false;
       }
 
     private:
       const IFileReader::Options &m_Options;
     };
 
     struct FixedWriterOptionsFunctor : public WriterOptionsFunctorBase
     {
       FixedWriterOptionsFunctor(const IFileReader::Options &options) : m_Options(options) {}
       bool operator()(SaveInfo &saveInfo) const override
       {
         IFileWriter *writer = saveInfo.m_WriterSelector.GetSelected().GetWriter();
         if (writer)
         {
           writer->SetOptions(m_Options);
         }
         return false;
       }
 
     private:
       const IFileWriter::Options &m_Options;
     };
 
     static BaseData::Pointer LoadBaseDataFromFile(const std::string &path, const ReaderOptionsFunctorBase* optionsCallback = nullptr);
   };
 
   BaseData::Pointer IOUtil::Impl::LoadBaseDataFromFile(const std::string &path,
                                                        const ReaderOptionsFunctorBase *optionsCallback)
   {
     std::vector<BaseData::Pointer> baseDataList = Load(path, optionsCallback);
 
     // The Load(path) call above should throw an exception if nothing could be loaded
     assert(!baseDataList.empty());
     return baseDataList.front();
   }
 
-  std::string IOUtil::Local8BitToUtf8(const std::string& local8BitStr)
-  {
-#ifdef US_PLATFORM_WINDOWS
-    try
-    {
-      return WideCharToMultiByte(MultiByteToWideChar(local8BitStr, CP_ACP), CP_UTF8);
-    }
-    catch (const mitk::Exception&)
-    {
-      MITK_WARN << "String conversion from current code page to UTF-8 failed. Input string is returned unmodified.";
-    }
-#endif
-
-    return local8BitStr;
-  }
-
-  std::string IOUtil::Utf8ToLocal8Bit(const std::string& utf8Str)
-  {
-#ifdef US_PLATFORM_WINDOWS
-    try
-    {
-      return WideCharToMultiByte(MultiByteToWideChar(utf8Str, CP_UTF8), CP_ACP);
-    }
-    catch (const mitk::Exception&)
-    {
-      MITK_WARN << "String conversion from UTF-8 to current code page failed. Input string is returned unmodified.";
-    }
-#endif
-
-    return utf8Str;
-  }
-
 #ifdef US_PLATFORM_WINDOWS
   std::string IOUtil::GetProgramPath()
   {
     char path[512];
     std::size_t index = std::string(path, GetModuleFileName(nullptr, path, 512)).find_last_of('\\');
     return std::string(path, index);
   }
 #elif defined(US_PLATFORM_APPLE)
 #include <mach-o/dyld.h>
   std::string IOUtil::GetProgramPath()
   {
     char path[512];
     uint32_t size = sizeof(path);
     if (_NSGetExecutablePath(path, &size) == 0)
     {
       std::size_t index = std::string(path).find_last_of('/');
       std::string strPath = std::string(path, index);
       // const char* execPath = strPath.c_str();
       // mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch(execPath,false);
       return strPath;
     }
     return std::string();
   }
 #else
 #include <sstream>
 #include <sys/types.h>
 #include <unistd.h>
   std::string IOUtil::GetProgramPath()
   {
     std::stringstream ss;
     ss << "/proc/" << getpid() << "/exe";
     char proc[512] = {0};
     ssize_t ch = readlink(ss.str().c_str(), proc, 512);
     if (ch == -1)
       return std::string();
     std::size_t index = std::string(proc).find_last_of('/');
     return std::string(proc, index);
   }
 #endif
 
   char IOUtil::GetDirectorySeparator()
   {
 #ifdef US_PLATFORM_WINDOWS
     return '\\';
 #else
     return '/';
 #endif
   }
 
   std::string IOUtil::GetTempPath()
   {
     static std::string result;
     if (result.empty())
     {
 #ifdef US_PLATFORM_WINDOWS
       char tempPathTestBuffer[1];
       DWORD bufferLength = ::GetTempPath(1, tempPathTestBuffer);
       if (bufferLength == 0)
       {
         mitkThrow() << GetLastErrorStr();
       }
       std::vector<char> tempPath(bufferLength);
       bufferLength = ::GetTempPath(bufferLength, &tempPath[0]);
       if (bufferLength == 0)
       {
         mitkThrow() << GetLastErrorStr();
       }
       result.assign(tempPath.begin(), tempPath.begin() + static_cast<std::size_t>(bufferLength));
 #else
       result = "/tmp/";
 #endif
     }
 
     return result;
   }
 
   std::string IOUtil::CreateTemporaryFile(const std::string &templateName, std::string path)
   {
     std::ofstream tmpOutputStream;
     std::string returnValue = CreateTemporaryFile(tmpOutputStream, templateName, path);
     tmpOutputStream.close();
     return returnValue;
   }
 
   std::string IOUtil::CreateTemporaryFile(std::ofstream &f, const std::string &templateName, std::string path)
   {
     return CreateTemporaryFile(f, std::ios_base::out | std::ios_base::trunc, templateName, path);
   }
 
   std::string IOUtil::CreateTemporaryFile(std::ofstream &f,
                                           std::ios_base::openmode mode,
                                           const std::string &templateName,
                                           std::string path)
   {
     if (path.empty())
     {
       path = GetTempPath();
     }
 
     path += templateName;
 
     std::vector<char> dst_path(path.begin(), path.end());
     dst_path.push_back('\0');
 
     std::size_t lastX = path.find_last_of('X');
     std::size_t firstX = path.find_last_not_of('X', lastX);
     int firstNonX = firstX == std::string::npos ? -1 : firstX - 1;
     while (lastX != std::string::npos && (lastX - firstNonX) < 6)
     {
       lastX = path.find_last_of('X', firstX);
       firstX = path.find_last_not_of('X', lastX);
       firstNonX = firstX == std::string::npos ? -1 : firstX - 1;
     }
     std::size_t suffixlen = lastX == std::string::npos ? path.size() : path.size() - lastX - 1;
 
     int fd = mkstemps_compat(&dst_path[0], suffixlen);
     if (fd != -1)
     {
       path.assign(dst_path.begin(), dst_path.end() - 1);
       f.open(path.c_str(), mode | std::ios_base::out | std::ios_base::trunc);
       close(fd);
     }
     else
     {
       mitkThrow() << "Creating temporary file " << &dst_path[0] << " failed: " << GetLastErrorStr();
     }
     return path;
   }
 
   std::string IOUtil::CreateTemporaryDirectory(const std::string &templateName, std::string path)
   {
     if (path.empty())
     {
       path = GetTempPath();
     }
 
     path += GetDirectorySeparator() + templateName;
     std::vector<char> dst_path(path.begin(), path.end());
     dst_path.push_back('\0');
 
     std::size_t lastX = path.find_last_of('X');
     std::size_t firstX = path.find_last_not_of('X', lastX);
     int firstNonX = firstX == std::string::npos ? -1 : firstX - 1;
     while (lastX != std::string::npos && (lastX - firstNonX) < 6)
     {
       lastX = path.find_last_of('X', firstX);
       firstX = path.find_last_not_of('X', lastX);
       firstNonX = firstX == std::string::npos ? -1 : firstX - 1;
     }
     std::size_t suffixlen = lastX == std::string::npos ? path.size() : path.size() - lastX - 1;
 
     if (mkdtemps_compat(&dst_path[0], suffixlen) == nullptr)
     {
       mitkThrow() << "Creating temporary directory " << &dst_path[0] << " failed: " << GetLastErrorStr();
     }
 
     path.assign(dst_path.begin(), dst_path.end() - 1);
     return path;
   }
 
   DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::string &path, DataStorage &storage, const ReaderOptionsFunctorBase *optionsCallback)
   {
     std::vector<std::string> paths;
     paths.push_back(path);
     return Load(paths, storage, optionsCallback);
   }
 
   DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::string &path,
                                                   const IFileReader::Options &options,
                                                   DataStorage &storage)
   {
     std::vector<LoadInfo> loadInfos;
     loadInfos.push_back(LoadInfo(path));
     DataStorage::SetOfObjects::Pointer nodeResult = DataStorage::SetOfObjects::New();
     Impl::FixedReaderOptionsFunctor optionsCallback(options);
     std::string errMsg = Load(loadInfos, nodeResult, &storage, &optionsCallback);
     if (!errMsg.empty())
     {
       mitkThrow() << errMsg;
     }
     return nodeResult;
   }
 
   std::vector<BaseData::Pointer> IOUtil::Load(const std::string &path, const ReaderOptionsFunctorBase *optionsCallback)
   {
     std::vector<std::string> paths;
     paths.push_back(path);
     return Load(paths, optionsCallback);
   }
 
   std::vector<BaseData::Pointer> IOUtil::Load(const std::string &path, const IFileReader::Options &options)
   {
     std::vector<LoadInfo> loadInfos;
     loadInfos.push_back(LoadInfo(path));
     Impl::FixedReaderOptionsFunctor optionsCallback(options);
     std::string errMsg = Load(loadInfos, nullptr, nullptr, &optionsCallback);
     if (!errMsg.empty())
     {
       mitkThrow() << errMsg;
     }
     return loadInfos.front().m_Output;
   }
 
   DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::vector<std::string> &paths, DataStorage &storage, const ReaderOptionsFunctorBase *optionsCallback)
   {
     DataStorage::SetOfObjects::Pointer nodeResult = DataStorage::SetOfObjects::New();
     std::vector<LoadInfo> loadInfos;
     for (const auto &loadInfo : paths)
     {
-      loadInfos.push_back(loadInfo);
+      loadInfos.emplace_back(loadInfo);
     }
     std::string errMsg = Load(loadInfos, nodeResult, &storage, optionsCallback);
     if (!errMsg.empty())
     {
       mitkThrow() << errMsg;
     }
     return nodeResult;
   }
 
   std::vector<BaseData::Pointer> IOUtil::Load(const std::vector<std::string> &paths, const ReaderOptionsFunctorBase *optionsCallback)
   {
     std::vector<BaseData::Pointer> result;
     std::vector<LoadInfo> loadInfos;
     for (const auto &loadInfo : paths)
     {
-      loadInfos.push_back(loadInfo);
+      loadInfos.emplace_back(loadInfo);
     }
     std::string errMsg = Load(loadInfos, nullptr, nullptr, optionsCallback);
     if (!errMsg.empty())
     {
       mitkThrow() << errMsg;
     }
 
     for (std::vector<LoadInfo>::const_iterator iter = loadInfos.begin(), iterEnd = loadInfos.end(); iter != iterEnd;
          ++iter)
     {
       result.insert(result.end(), iter->m_Output.begin(), iter->m_Output.end());
     }
     return result;
   }
 
   std::string IOUtil::Load(std::vector<LoadInfo> &loadInfos,
                            DataStorage::SetOfObjects *nodeResult,
                            DataStorage *ds,
                            const ReaderOptionsFunctorBase *optionsCallback)
   {
     if (loadInfos.empty())
     {
       return "No input files given";
     }
 
     int filesToRead = loadInfos.size();
     mitk::ProgressBar::GetInstance()->AddStepsToDo(2 * filesToRead);
 
     std::string errMsg;
 
     std::map<std::string, FileReaderSelector::Item> usedReaderItems;
 
     std::vector< std::string > read_files;
     for (auto &loadInfo : loadInfos)
     {
       if(std::find(read_files.begin(), read_files.end(), loadInfo.m_Path) != read_files.end())
         continue;
 
       std::vector<FileReaderSelector::Item> readers = loadInfo.m_ReaderSelector.Get();
 
       if (readers.empty())
       {
-        if (!itksys::SystemTools::FileExists(Local8BitToUtf8(loadInfo.m_Path).c_str()))
+        if (!itksys::SystemTools::FileExists(Utf8Util::Local8BitToUtf8(loadInfo.m_Path).c_str()))
         {
           errMsg += "File '" + loadInfo.m_Path + "' does not exist\n";
         }
         else
         {
           errMsg += "No reader available for '" + loadInfo.m_Path + "'\n";
         }
         continue;
       }
 
       bool callOptionsCallback = readers.size() > 1 || !readers.front().GetReader()->GetOptions().empty();
 
       // check if we already used a reader which should be re-used
       std::vector<MimeType> currMimeTypes = loadInfo.m_ReaderSelector.GetMimeTypes();
       std::string selectedMimeType;
       for (std::vector<MimeType>::const_iterator mimeTypeIter = currMimeTypes.begin(),
                                                  mimeTypeIterEnd = currMimeTypes.end();
            mimeTypeIter != mimeTypeIterEnd;
            ++mimeTypeIter)
       {
         std::map<std::string, FileReaderSelector::Item>::const_iterator oldSelectedItemIter =
           usedReaderItems.find(mimeTypeIter->GetName());
         if (oldSelectedItemIter != usedReaderItems.end())
         {
           // we found an already used item for a mime-type which is contained
           // in the current reader set, check all current readers if there service
           // id equals the old reader
           for (std::vector<FileReaderSelector::Item>::const_iterator currReaderItem = readers.begin(),
                                                                      currReaderItemEnd = readers.end();
                currReaderItem != currReaderItemEnd;
                ++currReaderItem)
           {
             if (currReaderItem->GetMimeType().GetName() == mimeTypeIter->GetName() &&
                 currReaderItem->GetServiceId() == oldSelectedItemIter->second.GetServiceId() &&
                 currReaderItem->GetConfidenceLevel() >= oldSelectedItemIter->second.GetConfidenceLevel())
             {
               // okay, we used the same reader already, re-use its options
               selectedMimeType = mimeTypeIter->GetName();
               callOptionsCallback = false;
               loadInfo.m_ReaderSelector.Select(oldSelectedItemIter->second.GetServiceId());
               loadInfo.m_ReaderSelector.GetSelected().GetReader()->SetOptions(
                 oldSelectedItemIter->second.GetReader()->GetOptions());
               break;
             }
           }
           if (!selectedMimeType.empty())
             break;
         }
       }
 
       if (callOptionsCallback && optionsCallback)
       {
         callOptionsCallback = (*optionsCallback)(loadInfo);
         if (!callOptionsCallback && !loadInfo.m_Cancel)
         {
           usedReaderItems.erase(selectedMimeType);
           FileReaderSelector::Item selectedItem = loadInfo.m_ReaderSelector.GetSelected();
           usedReaderItems.insert(std::make_pair(selectedItem.GetMimeType().GetName(), selectedItem));
         }
       }
 
       if (loadInfo.m_Cancel)
       {
         errMsg += "Reading operation(s) cancelled.";
         break;
       }
 
       IFileReader *reader = loadInfo.m_ReaderSelector.GetSelected().GetReader();
       if (reader == nullptr)
       {
         errMsg += "Unexpected nullptr reader.";
         break;
       }
 
       // Do the actual reading
       try
       {
         DataStorage::SetOfObjects::Pointer nodes;
         if (ds != nullptr)
         {
           nodes = reader->Read(*ds);
 
           std::vector< std::string > new_files =  reader->GetReadFiles();
           read_files.insert( read_files.end(), new_files.begin(), new_files.end() );
         }
         else
         {
           nodes = DataStorage::SetOfObjects::New();
           std::vector<mitk::BaseData::Pointer> baseData = reader->Read();
           for (auto iter = baseData.begin(); iter != baseData.end(); ++iter)
           {
             if (iter->IsNotNull())
             {
               mitk::DataNode::Pointer node = mitk::DataNode::New();
               node->SetData(*iter);
               nodes->InsertElement(nodes->Size(), node);
             }
           }
 
           std::vector< std::string > new_files =  reader->GetReadFiles();
           read_files.insert( read_files.end(), new_files.begin(), new_files.end() );
         }
 
         for (DataStorage::SetOfObjects::ConstIterator nodeIter = nodes->Begin(), nodeIterEnd = nodes->End();
              nodeIter != nodeIterEnd;
              ++nodeIter)
         {
           const mitk::DataNode::Pointer &node = nodeIter->Value();
           mitk::BaseData::Pointer data = node->GetData();
           if (data.IsNull())
           {
             continue;
           }
 
-          auto path = Local8BitToUtf8(loadInfo.m_Path);
-          auto pathProp = mitk::StringProperty::New(path);
-          data->SetProperty("path", pathProp);
+          data->SetProperty("path", mitk::StringProperty::New(Utf8Util::Local8BitToUtf8(loadInfo.m_Path)));
 
           loadInfo.m_Output.push_back(data);
           if (nodeResult)
           {
             nodeResult->push_back(nodeIter->Value());
           }
         }
 
         if (loadInfo.m_Output.empty() || (nodeResult && nodeResult->Size() == 0))
         {
           errMsg += "Unknown read error occurred reading " + loadInfo.m_Path;
         }
       }
       catch (const std::exception &e)
       {
         errMsg += "Exception occured when reading file " + loadInfo.m_Path + ":\n" + e.what() + "\n\n";
       }
       mitk::ProgressBar::GetInstance()->Progress(2);
       --filesToRead;
     }
 
     if (!errMsg.empty())
     {
       MITK_ERROR << errMsg;
     }
 
     mitk::ProgressBar::GetInstance()->Progress(2 * filesToRead);
 
     return errMsg;
   }
 
   std::vector<BaseData::Pointer> IOUtil::Load(const us::ModuleResource &usResource, std::ios_base::openmode mode)
   {
     us::ModuleResourceStream resStream(usResource, mode);
 
     mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
     std::vector<MimeType> mimetypes = mimeTypeProvider->GetMimeTypesForFile(usResource.GetResourcePath());
 
     std::vector<mitk::BaseData::Pointer> data;
     if (mimetypes.empty())
     {
       mitkThrow() << "No mimetype for resource stream: " << usResource.GetResourcePath();
       return data;
     }
 
     mitk::FileReaderRegistry fileReaderRegistry;
     std::vector<us::ServiceReference<IFileReader>> refs = fileReaderRegistry.GetReferences(mimetypes[0]);
     if (refs.empty())
     {
       mitkThrow() << "No reader available for resource stream: " << usResource.GetResourcePath();
       return data;
     }
 
     mitk::IFileReader *reader = fileReaderRegistry.GetReader(refs[0]);
     reader->SetInput(usResource.GetResourcePath(), &resStream);
     data = reader->Read();
 
     return data;
   }
 
   void IOUtil::Save(const BaseData *data, const std::string &path, bool setPathProperty) { Save(data, path, IFileWriter::Options(), setPathProperty); }
   void IOUtil::Save(const BaseData *data, const std::string &path, const IFileWriter::Options &options, bool setPathProperty)
   {
     Save(data, std::string(), path, options, setPathProperty);
   }
 
   void IOUtil::Save(const BaseData *data, const std::string &mimeType, const std::string &path, bool addExtension, bool setPathProperty)
   {
     Save(data, mimeType, path, IFileWriter::Options(), addExtension, setPathProperty);
   }
 
   void IOUtil::Save(const BaseData *data,
                     const std::string &mimeType,
                     const std::string &path,
                     const IFileWriter::Options &options,
                     bool addExtension,
                     bool setPathProperty)
   {
     if ((data == nullptr) || (data->IsEmpty()))
       mitkThrow() << "BaseData cannotbe null or empty for save methods in IOUtil.h.";
 
     std::string errMsg;
     if (options.empty())
     {
       errMsg = Save(data, mimeType, path, nullptr, addExtension, setPathProperty);
     }
     else
     {
       Impl::FixedWriterOptionsFunctor optionsCallback(options);
       errMsg = Save(data, mimeType, path, &optionsCallback, addExtension, setPathProperty);
     }
 
     if (!errMsg.empty())
     {
       mitkThrow() << errMsg;
     }
   }
 
   void IOUtil::Save(std::vector<IOUtil::SaveInfo> &saveInfos, bool setPathProperty)
   {
     std::string errMsg = Save(saveInfos, nullptr, setPathProperty);
     if (!errMsg.empty())
     {
       mitkThrow() << errMsg;
     }
   }
 
   std::string IOUtil::Save(const BaseData *data,
                            const std::string &mimeTypeName,
                            const std::string &path,
                            WriterOptionsFunctorBase *optionsCallback,
                            bool addExtension,
                            bool setPathProperty)
   {
     if (path.empty())
     {
       return "No output filename given";
     }
 
     mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
 
     MimeType mimeType = mimeTypeProvider->GetMimeTypeForName(mimeTypeName);
 
     SaveInfo saveInfo(data, mimeType, path);
 
-    std::string ext = itksys::SystemTools::GetFilenameExtension(path);
+    std::string ext = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetFilenameExtension(Utf8Util::Local8BitToUtf8(path)));
 
     if (saveInfo.m_WriterSelector.IsEmpty())
     {
       return std::string("No suitable writer found for the current data of type ") + data->GetNameOfClass() +
              (mimeType.IsValid() ? (std::string(" and mime-type ") + mimeType.GetName()) : std::string()) +
              (ext.empty() ? std::string() : (std::string(" with extension ") + ext));
     }
 
     // Add an extension if not already specified
     if (ext.empty() && addExtension)
     {
       ext = saveInfo.m_MimeType.GetExtensions().empty() ? std::string() : "." + saveInfo.m_MimeType.GetExtensions().front();
       saveInfo.m_Path += ext;
     }
 
     std::vector<SaveInfo> infos;
     infos.push_back(saveInfo);
     return Save(infos, optionsCallback, setPathProperty);
   }
 
   std::string IOUtil::Save(std::vector<SaveInfo> &saveInfos, WriterOptionsFunctorBase *optionsCallback, bool setPathProperty)
   {
     if (saveInfos.empty())
     {
       return "No data for saving available";
     }
 
     int filesToWrite = saveInfos.size();
     mitk::ProgressBar::GetInstance()->AddStepsToDo(2 * filesToWrite);
 
     std::string errMsg;
 
     std::set<SaveInfo> usedSaveInfos;
 
     for (auto &saveInfo : saveInfos)
     {
       const std::string baseDataType = saveInfo.m_BaseData->GetNameOfClass();
 
       std::vector<FileWriterSelector::Item> writers = saveInfo.m_WriterSelector.Get();
 
       // Error out if no compatible Writer was found
       if (writers.empty())
       {
         errMsg += std::string("No writer available for ") + baseDataType + " data.\n";
         continue;
       }
 
       bool callOptionsCallback = writers.size() > 1 || !writers[0].GetWriter()->GetOptions().empty();
 
       // check if we already used a writer for this base data type
       // which should be re-used
       auto oldSaveInfoIter = usedSaveInfos.find(saveInfo);
       if (oldSaveInfoIter != usedSaveInfos.end())
       {
         // we previously saved a base data object of the same data with the same mime-type,
         // check if the same writer is contained in the current writer set and if the
         // confidence level matches
         FileWriterSelector::Item oldSelectedItem =
           oldSaveInfoIter->m_WriterSelector.Get(oldSaveInfoIter->m_WriterSelector.GetSelectedId());
         for (std::vector<FileWriterSelector::Item>::const_iterator currWriterItem = writers.begin(),
                                                                    currWriterItemEnd = writers.end();
              currWriterItem != currWriterItemEnd;
              ++currWriterItem)
         {
           if (currWriterItem->GetServiceId() == oldSelectedItem.GetServiceId() &&
               currWriterItem->GetConfidenceLevel() >= oldSelectedItem.GetConfidenceLevel())
           {
             // okay, we used the same writer already, re-use its options
             callOptionsCallback = false;
             saveInfo.m_WriterSelector.Select(oldSaveInfoIter->m_WriterSelector.GetSelectedId());
             saveInfo.m_WriterSelector.GetSelected().GetWriter()->SetOptions(oldSelectedItem.GetWriter()->GetOptions());
             break;
           }
         }
       }
 
       if (callOptionsCallback && optionsCallback)
       {
         callOptionsCallback = (*optionsCallback)(saveInfo);
         if (!callOptionsCallback && !saveInfo.m_Cancel)
         {
           usedSaveInfos.erase(saveInfo);
           usedSaveInfos.insert(saveInfo);
         }
       }
 
       if (saveInfo.m_Cancel)
       {
         errMsg += "Writing operation(s) cancelled.";
         break;
       }
 
       IFileWriter *writer = saveInfo.m_WriterSelector.GetSelected().GetWriter();
       if (writer == nullptr)
       {
         errMsg += "Unexpected nullptr writer.";
         break;
       }
 
       // Do the actual writing
       try
       {
         writer->SetOutputLocation(saveInfo.m_Path);
         writer->Write();
       }
       catch (const std::exception &e)
       {
         errMsg += std::string("Exception occurred when writing to ") + saveInfo.m_Path + ":\n" + e.what() + "\n";
       }
 
       if (setPathProperty)
-        saveInfo.m_BaseData->GetPropertyList()->SetStringProperty("path", Local8BitToUtf8(saveInfo.m_Path).c_str());
+        saveInfo.m_BaseData->GetPropertyList()->SetStringProperty("path", Utf8Util::Local8BitToUtf8(saveInfo.m_Path).c_str());
 
       mitk::ProgressBar::GetInstance()->Progress(2);
       --filesToWrite;
     }
 
     if (!errMsg.empty())
     {
       MITK_ERROR << errMsg;
     }
 
     mitk::ProgressBar::GetInstance()->Progress(2 * filesToWrite);
 
     return errMsg;
   }
 
   IOUtil::SaveInfo::SaveInfo(const BaseData *baseData, const MimeType &mimeType, const std::string &path)
     : m_BaseData(baseData),
       m_WriterSelector(baseData, mimeType.GetName(), path),
       m_MimeType(mimeType.IsValid() ? mimeType // use the original mime-type
                                       :
                                       (m_WriterSelector.IsEmpty() ?
                                          mimeType // no writer found, use the original invalid mime-type
                                          :
                                          m_WriterSelector.GetDefault().GetMimeType() // use the found default mime-type
                                        )),
       m_Path(path),
       m_Cancel(false)
   {
   }
 
   bool IOUtil::SaveInfo::operator<(const IOUtil::SaveInfo &other) const
   {
     int r = strcmp(m_BaseData->GetNameOfClass(), other.m_BaseData->GetNameOfClass());
     if (r == 0)
     {
       return m_WriterSelector.GetSelected().GetMimeType() < other.m_WriterSelector.GetSelected().GetMimeType();
     }
     return r < 0;
   }
 
   IOUtil::LoadInfo::LoadInfo(const std::string &path) : m_Path(path), m_ReaderSelector(path), m_Cancel(false) {}
 }
diff --git a/Modules/Core/src/IO/mitkStandardFileLocations.cpp b/Modules/Core/src/IO/mitkStandardFileLocations.cpp
index d92045120e..07b069fece 100644
--- a/Modules/Core/src/IO/mitkStandardFileLocations.cpp
+++ b/Modules/Core/src/IO/mitkStandardFileLocations.cpp
@@ -1,238 +1,239 @@
 /*============================================================================
 
 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 <mitkStandardFileLocations.h>
 
 #include <itkMacro.h>
 #include <itkObject.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkConfig.h>
+#include <mitkUtf8Util.h>
 
 #include <algorithm>
 
 mitk::StandardFileLocations::StandardFileLocations()
 {
 }
 
 mitk::StandardFileLocations::~StandardFileLocations()
 {
 }
 
 mitk::StandardFileLocations *mitk::StandardFileLocations::GetInstance()
 {
   static StandardFileLocations::Pointer m_Instance = nullptr;
 
   if (m_Instance.IsNull())
     m_Instance = StandardFileLocations::New();
   return m_Instance;
 }
 
 void mitk::StandardFileLocations::AddDirectoryForSearch(const char *dir, bool insertInFrontOfSearchList)
 {
   // Do nothing if directory is already included into search list (TODO more clever: search only once!)
   FileSearchVectorType::iterator iter;
   if (m_SearchDirectories.size() > 0)
   {
     iter = std::find(m_SearchDirectories.begin(), m_SearchDirectories.end(), std::string(dir));
     if (iter != m_SearchDirectories.end())
       return;
   }
   // insert dir into queue
   if (insertInFrontOfSearchList)
   {
     auto it = m_SearchDirectories.begin();
     m_SearchDirectories.insert(it, std::string(dir));
   }
   else
     m_SearchDirectories.push_back(std::string(dir));
 }
 
 void mitk::StandardFileLocations::RemoveDirectoryForSearch(const char *dir)
 {
   FileSearchVectorType::iterator it;
   // background layers
   if (m_SearchDirectories.size() > 0)
   {
     it = std::find(m_SearchDirectories.begin(), m_SearchDirectories.end(), std::string(dir));
     if (it != m_SearchDirectories.end())
     {
       m_SearchDirectories.erase(it);
       return;
     }
   }
 }
 
 std::string mitk::StandardFileLocations::SearchDirectoriesForFile(const char *filename)
 {
   FileSearchVectorType::iterator it;
 
   for (it = m_SearchDirectories.begin(); it != m_SearchDirectories.end(); ++it)
   {
     std::string currDir = (*it);
 
     // Perhaps append "/" before appending filename
     if (currDir.find_last_of("\\") + 1 != currDir.size() || currDir.find_last_of("/") + 1 != currDir.size())
       currDir += "/";
 
     // Append filename
     currDir += filename;
 
     // Perhaps remove "/" after filename
     if (currDir.find_last_of("\\") + 1 == currDir.size() || currDir.find_last_of("/") + 1 == currDir.size())
       currDir.erase(currDir.size() - 1, currDir.size());
 
     // convert to OS dependent path schema
-    currDir = itksys::SystemTools::ConvertToOutputPath(currDir.c_str());
+    currDir = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::ConvertToOutputPath(Utf8Util::Local8BitToUtf8(currDir).c_str()));
 
     // On windows systems, the ConvertToOutputPath method quotes pathes that contain empty spaces.
     // These quotes are not expected by the FileExists method and therefore removed, if existing.
     if (currDir.find_last_of("\"") + 1 == currDir.size())
       currDir.erase(currDir.size() - 1, currDir.size());
     if (currDir.find_last_of("\"") == 0)
       currDir.erase(0, 1);
 
     // Return first found path
-    if (itksys::SystemTools::FileExists(currDir.c_str()))
+    if (itksys::SystemTools::FileExists(Utf8Util::Local8BitToUtf8(currDir).c_str()))
       return currDir;
   }
   return std::string("");
 }
 
 std::string mitk::StandardFileLocations::FindFile(const char *filename, const char *pathInSourceDir)
 {
   std::string directoryPath;
 
   // 1. look for MITKCONF environment variable
   const char *mitkConf = itksys::SystemTools::GetEnv("MITKCONF");
   if (mitkConf != nullptr)
     AddDirectoryForSearch(mitkConf, false);
 
 // 2. use .mitk-subdirectory in home directory of the user
 #if defined(_WIN32) && !defined(__CYGWIN__)
   const char *homeDrive = itksys::SystemTools::GetEnv("HOMEDRIVE");
   const char *homePath = itksys::SystemTools::GetEnv("HOMEPATH");
 
   if ((homeDrive != nullptr) || (homePath != nullptr))
   {
     directoryPath = homeDrive;
     directoryPath += homePath;
     directoryPath += "/.mitk/";
     AddDirectoryForSearch(directoryPath.c_str(), false);
   }
 
 #else
   const char *homeDirectory = itksys::SystemTools::GetEnv("HOME");
   if (homeDirectory != nullptr)
   {
     directoryPath = homeDirectory;
     directoryPath += "/.mitk/";
     AddDirectoryForSearch(directoryPath.c_str(), false);
   }
 
 #endif // defined(_WIN32) && !defined(__CYGWIN__)
 
   // 3. look in the current working directory
   directoryPath = "";
   AddDirectoryForSearch(directoryPath.c_str());
 
-  directoryPath = itksys::SystemTools::GetCurrentWorkingDirectory();
+  directoryPath = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetCurrentWorkingDirectory());
   AddDirectoryForSearch(directoryPath.c_str(), false);
 
   std::string directoryBinPath = directoryPath + "/bin";
   AddDirectoryForSearch(directoryBinPath.c_str(), false);
   // 4. use a source tree location from compile time
   directoryPath = MITK_ROOT;
   if (pathInSourceDir)
   {
     directoryPath += pathInSourceDir;
   }
   directoryPath += '/';
   AddDirectoryForSearch(directoryPath.c_str(), false);
 
   return SearchDirectoriesForFile(filename);
 }
 
 std::string mitk::StandardFileLocations::GetOptionDirectory()
 {
   const char *mitkoptions = itksys::SystemTools::GetEnv("MITKOPTIONS");
   std::string optionsDirectory;
 
   if (mitkoptions != nullptr)
   {
     // 1. look for MITKOPTIONS environment variable
     optionsDirectory = mitkoptions;
     optionsDirectory += "/";
   }
   else
   {
     // 2. use .mitk-subdirectory in home directory of the user
     std::string homeDirectory;
 #if defined(_WIN32) && !defined(__CYGWIN__)
     const char *homeDrive = itksys::SystemTools::GetEnv("HOMEDRIVE");
     const char *homePath = itksys::SystemTools::GetEnv("HOMEPATH");
     if ((homeDrive == nullptr) || (homePath == nullptr))
     {
       itkGenericOutputMacro(<< "Environment variables HOMEDRIVE and/or HOMEPATH not set"
                             << ". Using current working directory as home directory: "
-                            << itksys::SystemTools::GetCurrentWorkingDirectory());
-      homeDirectory = itksys::SystemTools::GetCurrentWorkingDirectory();
+                            << Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetCurrentWorkingDirectory()));
+      homeDirectory = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetCurrentWorkingDirectory());
     }
     else
     {
       homeDirectory = homeDrive;
       homeDirectory += homePath;
     }
-    if (itksys::SystemTools::FileExists(homeDirectory.c_str()) == false)
+    if (itksys::SystemTools::FileExists(Utf8Util::Local8BitToUtf8(homeDirectory).c_str()) == false)
     {
       itkGenericOutputMacro(<< "Could not find home directory at " << homeDirectory
                             << ". Using current working directory as home directory: "
-                            << itksys::SystemTools::GetCurrentWorkingDirectory());
-      homeDirectory = itksys::SystemTools::GetCurrentWorkingDirectory();
+                            << Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetCurrentWorkingDirectory()));
+      homeDirectory = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetCurrentWorkingDirectory());
     }
 #else
     const char *home = itksys::SystemTools::GetEnv("HOME");
     if (home == nullptr)
     {
       itkGenericOutputMacro(<< "Environment variable HOME not set"
                             << ". Using current working directory as home directory: "
                             << itksys::SystemTools::GetCurrentWorkingDirectory());
       homeDirectory = itksys::SystemTools::GetCurrentWorkingDirectory();
     }
     else
       homeDirectory = home;
     if (itksys::SystemTools::FileExists(homeDirectory.c_str()) == false)
     {
       itkGenericOutputMacro(<< "Could not find home directory at " << homeDirectory
                             << ". Using current working directory as home directory: "
                             << itksys::SystemTools::GetCurrentWorkingDirectory());
       homeDirectory = itksys::SystemTools::GetCurrentWorkingDirectory();
     }
 #endif // defined(_WIN32) && !defined(__CYGWIN__)
 
     optionsDirectory = homeDirectory;
     optionsDirectory += "/.mitk";
   }
 
-  optionsDirectory = itksys::SystemTools::ConvertToOutputPath(optionsDirectory.c_str());
+  optionsDirectory = itksys::SystemTools::ConvertToOutputPath(Utf8Util::Local8BitToUtf8(optionsDirectory).c_str());
   if (itksys::SystemTools::CountChar(optionsDirectory.c_str(), '"') > 0)
   {
     char *unquoted = itksys::SystemTools::RemoveChars(optionsDirectory.c_str(), "\"");
     optionsDirectory = unquoted;
     delete[] unquoted;
   }
 
   if (itksys::SystemTools::MakeDirectory(optionsDirectory.c_str()) == false)
   {
-    itkGenericExceptionMacro(<< "Could not create .mitk directory at " << optionsDirectory);
+    itkGenericExceptionMacro(<< "Could not create .mitk directory at " << Utf8Util::Utf8ToLocal8Bit(optionsDirectory));
   }
-  return optionsDirectory;
+  return Utf8Util::Utf8ToLocal8Bit(optionsDirectory);
 }
diff --git a/Modules/Core/src/IO/mitkSurfaceVtkIO.cpp b/Modules/Core/src/IO/mitkSurfaceVtkIO.cpp
index 8ffbd3bb34..a8a1af5ec1 100644
--- a/Modules/Core/src/IO/mitkSurfaceVtkIO.cpp
+++ b/Modules/Core/src/IO/mitkSurfaceVtkIO.cpp
@@ -1,97 +1,98 @@
 /*============================================================================
 
 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 "mitkSurfaceVtkIO.h"
 
 #include "mitkSurface.h"
+#include <mitkUtf8Util.h>
 
 #include <vtkLinearTransform.h>
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransformPolyDataFilter.h>
 
 #include <itksys/SystemTools.hxx>
 
 namespace mitk
 {
   SurfaceVtkIO::SurfaceVtkIO(const std::string &baseDataType,
                              const CustomMimeType &mimeType,
                              const std::string &description)
     : AbstractFileIO(baseDataType, mimeType, description)
   {
   }
 
   vtkSmartPointer<vtkPolyData> SurfaceVtkIO::GetPolyData(unsigned int t, std::string &fileName)
   {
     const auto *input = dynamic_cast<const Surface *>(this->GetInput());
 
     vtkSmartPointer<vtkTransformPolyDataFilter> transformPolyData = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
 
     // surfaces do not have to exist in all timesteps; therefor, only write valid surfaces
     if (input->GetVtkPolyData(t) == nullptr)
       return vtkSmartPointer<vtkPolyData>();
 
     std::string baseName = this->GetOutputLocation();
-    std::string extension = itksys::SystemTools::GetFilenameExtension(baseName);
+    std::string extension = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetFilenameExtension(Utf8Util::Local8BitToUtf8(baseName)));
     if (!extension.empty())
     {
       baseName = baseName.substr(0, baseName.size() - extension.size());
     }
 
     std::ostringstream ss;
     ss.imbue(::std::locale::classic());
 
     BaseGeometry *geometry = input->GetGeometry(t);
     if (input->GetTimeGeometry()->IsValidTimeStep(t))
     {
       if (input->GetTimeGeometry()->CountTimeSteps() > 1)
       {
         const TimeBounds &timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
         ss << baseName << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1]
            << "_T" << t << extension;
       }
       else
       {
         // use the original file name
         ss << this->GetOutputLocation();
       }
     }
     else
     {
       MITK_WARN << "Error on write: TimeGeometry invalid of surface " << fileName << ".";
       return vtkSmartPointer<vtkPolyData>();
     }
 
     fileName = ss.str();
 
     transformPolyData->SetInputData(input->GetVtkPolyData(t));
     transformPolyData->SetTransform(geometry->GetVtkTransform());
     transformPolyData->UpdateWholeExtent();
 
     vtkSmartPointer<vtkPolyData> polyData = transformPolyData->GetOutput();
     return polyData;
   }
 
   IFileIO::ConfidenceLevel SurfaceVtkIO::GetWriterConfidenceLevel() const
   {
     if (AbstractFileIO::GetWriterConfidenceLevel() == Unsupported)
       return Unsupported;
     if (this->GetInput()->GetTimeGeometry()->CountTimeSteps() > 1)
     {
       // The VTK formats don't support multiple time points.
       // During writing, we write each time step into a separate file.
       // For output streams, we only write the first time-step and print a warning.
       return PartiallySupported;
     }
     return Supported;
   }
 }
diff --git a/Modules/Core/src/IO/mitkUtf8Util.cpp b/Modules/Core/src/IO/mitkUtf8Util.cpp
new file mode 100644
index 0000000000..ee1604f144
--- /dev/null
+++ b/Modules/Core/src/IO/mitkUtf8Util.cpp
@@ -0,0 +1,87 @@
+/*============================================================================
+
+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 <mitkUtf8Util.h>
+#include <mitkExceptionMacro.h>
+
+#include <usGlobalConfig.h>
+
+#ifdef US_PLATFORM_WINDOWS
+
+#include <Windows.h>
+
+namespace
+{
+  std::wstring MultiByteToWideChar(const std::string& mbString, UINT codePage)
+  {
+    auto numChars = ::MultiByteToWideChar(codePage, 0, mbString.data(), mbString.size(), nullptr, 0);
+
+    if (0 >= numChars)
+      mitkThrow() << "Failure to convert multi-byte character string to wide character string";
+
+    std::wstring wString;
+    wString.resize(numChars);
+
+    ::MultiByteToWideChar(codePage, 0, mbString.data(), mbString.size(), &wString[0], static_cast<int>(wString.size()));
+
+    return wString;
+  }
+
+  std::string WideCharToMultiByte(const std::wstring& wString, UINT codePage)
+  {
+    auto numChars = ::WideCharToMultiByte(codePage, 0, wString.data(), wString.size(), nullptr, 0, nullptr, nullptr);
+
+    if (0 >= numChars)
+      mitkThrow() << "Failure to convert wide character string to multi-byte character string";
+
+    std::string mbString;
+    mbString.resize(numChars);
+
+    ::WideCharToMultiByte(codePage, 0, wString.data(), wString.size(), &mbString[0], static_cast<int>(mbString.size()), nullptr, nullptr);
+
+    return mbString;
+  }
+}
+
+#endif
+
+std::string mitk::Utf8Util::Local8BitToUtf8(const std::string& local8BitStr)
+{
+#ifdef US_PLATFORM_WINDOWS
+  try
+  {
+    return WideCharToMultiByte(MultiByteToWideChar(local8BitStr, CP_ACP), CP_UTF8);
+  }
+  catch (const mitk::Exception&)
+  {
+    MITK_WARN << "String conversion from current code page to UTF-8 failed. Input string is returned unmodified.";
+  }
+#endif
+
+  return local8BitStr;
+}
+
+std::string mitk::Utf8Util::Utf8ToLocal8Bit(const std::string& utf8Str)
+{
+#ifdef US_PLATFORM_WINDOWS
+  try
+  {
+    return WideCharToMultiByte(MultiByteToWideChar(utf8Str, CP_UTF8), CP_ACP);
+  }
+  catch (const mitk::Exception&)
+  {
+    MITK_WARN << "String conversion from UTF-8 to current code page failed. Input string is returned unmodified.";
+  }
+#endif
+
+  return utf8Str;
+}
diff --git a/Modules/Core/test/mitkIOUtilTest.cpp b/Modules/Core/test/mitkIOUtilTest.cpp
index 31fadfb024..eaad746e4a 100644
--- a/Modules/Core/test/mitkIOUtilTest.cpp
+++ b/Modules/Core/test/mitkIOUtilTest.cpp
@@ -1,311 +1,312 @@
 /*============================================================================
 
 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 <mitkTestFixture.h>
 #include <mitkTestingConfig.h>
 
 #include <mitkIOUtil.h>
+#include <mitkUtf8Util.h>
 #include <mitkImageGenerator.h>
 #include <mitkIOMetaInformationPropertyConstants.h>
 #include <mitkVersion.h>
 
 #include <itkMetaDataObject.h>
 #include <itkNrrdImageIO.h>
 #include <itksys/SystemTools.hxx>
 
 class mitkIOUtilTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkIOUtilTestSuite);
   MITK_TEST(TestTempMethods);
   MITK_TEST(TestSaveEmptyData);
   MITK_TEST(TestLoadAndSaveImage);
   MITK_TEST(TestNullLoad);
   MITK_TEST(TestNullSave);
   MITK_TEST(TestLoadAndSavePointSet);
   MITK_TEST(TestLoadAndSaveSurface);
   MITK_TEST(TestTempMethodsForUniqueFilenames);
   MITK_TEST(TestTempMethodsForUniqueFilenames);
   MITK_TEST(TestIOMetaInformation);
   MITK_TEST(TestUtf8);
   CPPUNIT_TEST_SUITE_END();
 
 private:
   std::string m_ImagePath;
   std::string m_SurfacePath;
   std::string m_PointSetPath;
 
 public:
   void setUp() override
   {
     m_ImagePath = GetTestDataFilePath("Pic3D.nrrd");
     m_SurfacePath = GetTestDataFilePath("binary.stl");
     m_PointSetPath = GetTestDataFilePath("pointSet.mps");
   }
 
   void TestSaveEmptyData()
   {
     mitk::Surface::Pointer data = mitk::Surface::New();
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(data, "/tmp/dummy"), mitk::Exception);
   }
 
   void TestTempMethods()
   {
     std::string tmpPath = mitk::IOUtil::GetTempPath();
     CPPUNIT_ASSERT(!tmpPath.empty());
 
     std::ofstream tmpFile;
     std::string tmpFilePath = mitk::IOUtil::CreateTemporaryFile(tmpFile);
     CPPUNIT_ASSERT(tmpFile && tmpFile.is_open());
     CPPUNIT_ASSERT(tmpFilePath.size() > tmpPath.size());
     CPPUNIT_ASSERT(tmpFilePath.substr(0, tmpPath.size()) == tmpPath);
 
     tmpFile.close();
     CPPUNIT_ASSERT(std::remove(tmpFilePath.c_str()) == 0);
 
     std::string programPath = mitk::IOUtil::GetProgramPath();
     CPPUNIT_ASSERT(!programPath.empty());
     std::ofstream tmpFile2;
     std::string tmpFilePath2 = mitk::IOUtil::CreateTemporaryFile(tmpFile2, "my-XXXXXX", programPath);
     CPPUNIT_ASSERT(tmpFile2 && tmpFile2.is_open());
     CPPUNIT_ASSERT(tmpFilePath2.size() > programPath.size());
     CPPUNIT_ASSERT(tmpFilePath2.substr(0, programPath.size()) == programPath);
     tmpFile2.close();
     CPPUNIT_ASSERT(std::remove(tmpFilePath2.c_str()) == 0);
 
     std::ofstream tmpFile3;
     std::string tmpFilePath3 =
       mitk::IOUtil::CreateTemporaryFile(tmpFile3, std::ios_base::binary, "my-XXXXXX.TXT", programPath);
     CPPUNIT_ASSERT(tmpFile3 && tmpFile3.is_open());
     CPPUNIT_ASSERT(tmpFilePath3.size() > programPath.size());
     CPPUNIT_ASSERT(tmpFilePath3.substr(0, programPath.size()) == programPath);
     CPPUNIT_ASSERT(tmpFilePath3.substr(tmpFilePath3.size() - 13, 3) == "my-");
     CPPUNIT_ASSERT(tmpFilePath3.substr(tmpFilePath3.size() - 4) == ".TXT");
     tmpFile3.close();
     // CPPUNIT_ASSERT(std::remove(tmpFilePath3.c_str()) == 0)
 
     std::string tmpFilePath4 = mitk::IOUtil::CreateTemporaryFile();
     std::ofstream file;
     file.open(tmpFilePath4.c_str());
     CPPUNIT_ASSERT_MESSAGE("Testing if file exists after CreateTemporaryFile()", file.is_open());
 
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::CreateTemporaryFile(tmpFile2, "XX"), mitk::Exception);
 
     std::string tmpDir = mitk::IOUtil::CreateTemporaryDirectory();
     CPPUNIT_ASSERT(tmpDir.size() > tmpPath.size());
     CPPUNIT_ASSERT(tmpDir.substr(0, tmpPath.size()) == tmpPath);
-    CPPUNIT_ASSERT(itksys::SystemTools::RemoveADirectory(tmpDir.c_str()));
+    CPPUNIT_ASSERT(itksys::SystemTools::RemoveADirectory(mitk::Utf8Util::Local8BitToUtf8(tmpDir).c_str()));
 
     std::string tmpDir2 = mitk::IOUtil::CreateTemporaryDirectory("my-XXXXXX", programPath);
     CPPUNIT_ASSERT(tmpDir2.size() > programPath.size());
     CPPUNIT_ASSERT(tmpDir2.substr(0, programPath.size()) == programPath);
-    CPPUNIT_ASSERT(itksys::SystemTools::RemoveADirectory(tmpDir2.c_str()));
+    CPPUNIT_ASSERT(itksys::SystemTools::RemoveADirectory(mitk::Utf8Util::Local8BitToUtf8(tmpDir2).c_str()));
   }
 
   void TestTempMethodsForUniqueFilenames()
   {
     int numberOfFiles = 100;
 
     // create 100 empty files
     std::vector<std::string> v100filenames;
     for (int i = 0; i < numberOfFiles; i++)
     {
       v100filenames.push_back(mitk::IOUtil::CreateTemporaryFile());
     }
 
     // check if all of them are unique
     for (int i = 0; i < numberOfFiles; i++)
       for (int j = 0; j < numberOfFiles; j++)
       {
         if (i != j)
         {
           std::stringstream message;
           message << "Checking if file " << i << " and file " << j
                   << " are different, which should be the case because each of them should be unique.";
           CPPUNIT_ASSERT_MESSAGE(message.str(), (v100filenames.at(i) != v100filenames.at(j)));
         }
       }
 
     // delete all the files / clean up
     for (int i = 0; i < numberOfFiles; i++)
     {
       std::remove(v100filenames.at(i).c_str());
     }
   }
 
   void TestLoadAndSaveImage()
   {
     mitk::Image::Pointer img1 = mitk::IOUtil::Load<mitk::Image>(m_ImagePath);
     CPPUNIT_ASSERT(img1.IsNotNull());
 
     std::ofstream tmpStream;
     std::string imagePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "diffpic3d-XXXXXX.nrrd");
     tmpStream.close();
     std::string imagePath2 = mitk::IOUtil::CreateTemporaryFile(tmpStream, "diffpic3d-XXXXXX.nii.gz");
     tmpStream.close();
 
     // the cases where no exception should be thrown
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(img1, imagePath));
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(img1.GetPointer(), imagePath2));
 
     // load data which does not exist
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Load("fileWhichDoesNotExist.nrrd"), mitk::Exception);
 
     // delete the files after the test is done
     std::remove(imagePath.c_str());
     std::remove(imagePath2.c_str());
 
     mitk::Image::Pointer relativImage = mitk::ImageGenerator::GenerateGradientImage<float>(4, 4, 4, 1);
     std::string imagePath3 = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.nrrd");
     tmpStream.close();
     mitk::IOUtil::Save(relativImage, imagePath3);
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Load(imagePath3));
     std::remove(imagePath3.c_str());
   }
 
   /**
   * \brief This method calls all available load methods with a nullpointer and an empty pathand expects an exception
   **/
   void TestNullLoad()
   {
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Load(""), mitk::Exception);
   }
 
   /**
   * \brief This method calls the save method (to which all other convenience save methods reference) with null
   *parameters
   **/
   void TestNullSave()
   {
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(nullptr, mitk::IOUtil::CreateTemporaryFile()), mitk::Exception);
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(mitk::Image::New().GetPointer(), ""), mitk::Exception);
   }
 
   void TestLoadAndSavePointSet()
   {
     mitk::PointSet::Pointer pointset = mitk::IOUtil::Load<mitk::PointSet>(m_PointSetPath);
     CPPUNIT_ASSERT(pointset.IsNotNull());
 
     std::ofstream tmpStream;
     std::string pointSetPath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.mps");
     tmpStream.close();
     std::string pointSetPathWithDefaultExtension = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.mps");
     tmpStream.close();
     std::string pointSetPathWithoutDefaultExtension = mitk::IOUtil::CreateTemporaryFile(tmpStream);
     tmpStream.close();
 
     // the cases where no exception should be thrown
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(pointset, pointSetPathWithDefaultExtension));
 
     // test if defaultextension is inserted if no extension is present
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(pointset, pointSetPathWithoutDefaultExtension.c_str()));
 
     // delete the files after the test is done
     std::remove(pointSetPath.c_str());
     std::remove(pointSetPathWithDefaultExtension.c_str());
     std::remove(pointSetPathWithoutDefaultExtension.c_str());
   }
 
   void TestLoadAndSaveSurface()
   {
     mitk::Surface::Pointer surface = mitk::IOUtil::Load<mitk::Surface>(m_SurfacePath);
     CPPUNIT_ASSERT(surface.IsNotNull());
 
     std::ofstream tmpStream;
     std::string surfacePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "diffsurface-XXXXXX.stl");
 
     // the cases where no exception should be thrown
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(surface, surfacePath));
 
     // test if exception is thrown as expected on unknown extsension
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(surface, "testSurface.xXx"), mitk::Exception);
 
     // delete the files after the test is done
     std::remove(surfacePath.c_str());
   }
 
   std::string GenerateMetaDictKey(const mitk::PropertyKeyPath& propKey)
   {
     auto result = mitk::PropertyKeyPathToPropertyName(propKey);
     std::replace(result.begin(), result.end(), '.', '_');
     return result;
   }
 
   std::string GetValueFromMetaDict(const itk::MetaDataDictionary& dict, const mitk::PropertyKeyPath& propKey)
   {
     auto metaValueBase = dict.Get(GenerateMetaDictKey(propKey));
     auto metaValue = dynamic_cast<const itk::MetaDataObject<std::string>*>(metaValueBase);
     return metaValue->GetMetaDataObjectValue();
   }
 
   void TestIOMetaInformation()
   {
     mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(m_ImagePath);
     CPPUNIT_ASSERT(img.IsNotNull());
     
     auto value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_DESCRIPTION()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(std::string("ITK NrrdImageIO"), value);
     value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_INPUTLOCATION()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(m_ImagePath, value);
     value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_MIME_CATEGORY()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(std::string("Images"), value);
     value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_MIME_NAME()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(std::string("application/vnd.mitk.image.nrrd"), value);
     value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_VERSION()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(std::string(MITK_VERSION_STRING), value);
 
     //check if the information is persistet correctly on save.
     std::ofstream tmpStream;
     std::string imagePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "ioMeta_XXXXXX.nrrd");
     tmpStream.close();
     mitk::IOUtil::Save(img, imagePath);
 
     auto io = itk::NrrdImageIO::New();
     io->SetFileName(imagePath);
     io->ReadImageInformation();
     auto metaDict = io->GetMetaDataDictionary();
 
     auto metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_DESCRIPTION());
     CPPUNIT_ASSERT_EQUAL(std::string("ITK NrrdImageIO"), metaValue);
     metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_INPUTLOCATION());
     CPPUNIT_ASSERT_EQUAL(m_ImagePath, metaValue);
     metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_MIME_CATEGORY());
     CPPUNIT_ASSERT_EQUAL(std::string("Images"), metaValue);
     metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_MIME_NAME());
     CPPUNIT_ASSERT_EQUAL(std::string("application/vnd.mitk.image.nrrd"), metaValue);
     metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_VERSION());
     CPPUNIT_ASSERT_EQUAL(std::string(MITK_VERSION_STRING), metaValue);
 
     // delete the files after the test is done
     std::remove(imagePath.c_str());
   }
 
   void TestUtf8()
   {
     const std::string utf8Path = u8"UTF-8/\u00c4.nrrd"; // LATIN CAPITAL LETTER A WITH DIAERESIS (U+00C4)
-    const std::string local8BitPath = mitk::IOUtil::Utf8ToLocal8Bit(utf8Path);
+    const std::string local8BitPath = mitk::Utf8Util::Utf8ToLocal8Bit(utf8Path);
 
-    CPPUNIT_ASSERT(utf8Path == mitk::IOUtil::Local8BitToUtf8(local8BitPath));
+    CPPUNIT_ASSERT(utf8Path == mitk::Utf8Util::Local8BitToUtf8(local8BitPath));
 
     const std::string path = GetTestDataFilePath(local8BitPath);
 
     std::fstream file;
     file.open(path);
     CPPUNIT_ASSERT(file.is_open());
 
     auto image = mitk::IOUtil::Load<mitk::Image>(path);
     CPPUNIT_ASSERT(image.IsNotNull());
   }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkIOUtil)
diff --git a/Modules/Core/test/mitkItkImageIOTest.cpp b/Modules/Core/test/mitkItkImageIOTest.cpp
index 1f608cc5f2..a9d8d6d9eb 100644
--- a/Modules/Core/test/mitkItkImageIOTest.cpp
+++ b/Modules/Core/test/mitkItkImageIOTest.cpp
@@ -1,427 +1,428 @@
 /*============================================================================
 
 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 "mitkException.h"
 #include <mitkStandardFileLocations.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 #include "mitkIOUtil.h"
+#include <mitkUtf8Util.h>
 #include "mitkITKImageImport.h"
 #include <mitkExtractSliceFilter.h>
 
 #include "itksys/SystemTools.hxx"
 #include <itkImageRegionIterator.h>
 
 #include <fstream>
 #include <iostream>
 
 #ifdef WIN32
 #include "process.h"
 #else
 #include <unistd.h>
 #endif
 
 class mitkItkImageIOTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkItkImageIOTestSuite);
   MITK_TEST(TestImageWriterJpg);
   MITK_TEST(TestImageWriterPng1);
   MITK_TEST(TestImageWriterPng2);
   MITK_TEST(TestImageWriterPng3);
   MITK_TEST(TestImageWriterSimple);
   MITK_TEST(TestWrite3DImageWithOnePlane);
   MITK_TEST(TestWrite3DImageWithTwoPlanes);
   MITK_TEST(TestWrite3DplusT_ArbitraryTG);
   MITK_TEST(TestWrite3DplusT_ProportionalTG);
   CPPUNIT_TEST_SUITE_END();
 
 public:
   void setUp() override {}
   void tearDown() override {}
   void TestImageWriterJpg() { TestImageWriter("NrrdWritingTestImage.jpg"); }
   void TestImageWriterPng1() { TestImageWriter("Png2D-bw.png"); }
   void TestImageWriterPng2() { TestImageWriter("RenderingTestData/rgbImage.png"); }
   void TestImageWriterPng3() { TestImageWriter("RenderingTestData/rgbaImage.png"); }
   void TestWrite3DplusT_ArbitraryTG()
   {
     TestImageWriter("3D+t-ITKIO-TestData/LinearModel_4D_arbitrary_time_geometry.nrrd");
   }
 
   void TestWrite3DplusT_ProportionalTG()
   {
     TestImageWriter("3D+t-ITKIO-TestData/LinearModel_4D_prop_time_geometry.nrrd");
   }
 
   void TestImageWriterSimple()
   {
     // TODO
   }
 
   std::string AppendExtension(const std::string &filename, const char *extension)
   {
     std::string new_filename = filename;
 
     new_filename += extension;
     return new_filename;
   }
 
   bool CompareImageMetaData(mitk::Image::Pointer image, mitk::Image::Pointer reference, bool checkPixelType = true)
   {
     // switch to AreIdentical() methods as soon as Bug 11925 (Basic comparison operators) is fixed
 
     if (image->GetDimension() != reference->GetDimension())
     {
       MITK_ERROR << "The image dimension differs: IN (" << image->GetDimension() << ") REF("
                  << reference->GetDimension() << ")";
       return false;
     }
 
     // pixel type
     if (checkPixelType &&
         (image->GetPixelType() != reference->GetPixelType() &&
          image->GetPixelType().GetBitsPerComponent() != reference->GetPixelType().GetBitsPerComponent()))
     {
       MITK_ERROR << "Pixeltype differs ( image=" << image->GetPixelType().GetPixelTypeAsString() << "["
                  << image->GetPixelType().GetBitsPerComponent() << "]"
                  << " reference=" << reference->GetPixelType().GetPixelTypeAsString() << "["
                  << reference->GetPixelType().GetBitsPerComponent() << "]"
                  << " )";
       return false;
     }
 
     return true;
   }
 
   /*
   Test writing picture formats like *.bmp, *.png, *.tiff or *.jpg
   NOTE: Saving as picture format must ignore PixelType comparison - not all bits per components are supported (see
   specification of the format)
   */
   void TestPictureWriting(mitk::Image *image, const std::string &filename, const std::string &extension)
   {
     const std::string fullFileName = AppendExtension(filename, extension.c_str());
 
     mitk::Image::Pointer singleSliceImage = nullptr;
     if (image->GetDimension() == 3)
     {
       mitk::ExtractSliceFilter::Pointer extractFilter = mitk::ExtractSliceFilter::New();
       extractFilter->SetInput(image);
       extractFilter->SetWorldGeometry(image->GetSlicedGeometry()->GetPlaneGeometry(0));
 
       extractFilter->Update();
       singleSliceImage = extractFilter->GetOutput();
 
       // test 3D writing in format supporting only 2D
       mitk::IOUtil::Save(image, fullFileName);
 
       // test images
       unsigned int foundImagesCount = 0;
 
       // if the image only contains one sinlge slice the itkImageSeriesWriter won't add a number like
       // filename.XX.extension
       if (image->GetDimension(2) == 1)
       {
         std::stringstream series_filenames;
         series_filenames << filename << extension;
         mitk::Image::Pointer compareImage = mitk::IOUtil::Load<mitk::Image>(series_filenames.str());
         if (compareImage.IsNotNull())
         {
           foundImagesCount++;
           MITK_TEST_CONDITION(
             CompareImageMetaData(singleSliceImage, compareImage, false),
             "Image meta data unchanged after writing and loading again. "); // ignore bits per component
         }
         remove(series_filenames.str().c_str());
       }
       else // test the whole slice stack
       {
         for (unsigned int i = 0; i < image->GetDimension(2); i++)
         {
           std::stringstream series_filenames;
           series_filenames << filename << "." << i + 1 << extension;
           mitk::Image::Pointer compareImage = mitk::IOUtil::Load<mitk::Image>(series_filenames.str());
           if (compareImage.IsNotNull())
           {
             foundImagesCount++;
             MITK_TEST_CONDITION(
               CompareImageMetaData(singleSliceImage, compareImage, false),
               "Image meta data unchanged after writing and loading again. "); // ignore bits per component
           }
           remove(series_filenames.str().c_str());
         }
       }
       MITK_TEST_CONDITION(foundImagesCount == image->GetDimension(2),
                           "All 2D-Slices of a 3D image were stored correctly.");
     }
     else if (image->GetDimension() == 2)
     {
       singleSliceImage = image;
     }
 
     // test 2D writing
     if (singleSliceImage.IsNotNull())
     {
       try
       {
         mitk::IOUtil::Save(singleSliceImage, fullFileName);
 
         mitk::Image::Pointer compareImage = mitk::IOUtil::Load<mitk::Image>(fullFileName.c_str());
         MITK_TEST_CONDITION_REQUIRED(compareImage.IsNotNull(), "Image stored was succesfully loaded again");
 
         MITK_TEST_CONDITION_REQUIRED(
           CompareImageMetaData(singleSliceImage, compareImage, false),
           "Image meta data unchanged after writing and loading again. "); // ignore bits per component
         remove(fullFileName.c_str());
       }
       catch (itk::ExceptionObject &e)
       {
         MITK_TEST_FAILED_MSG(<< "Exception during file writing for ." << extension << ": " << e.what());
       }
     }
   }
 
   /**
   *  test for writing NRRDs
   */
   void TestNRRDWriting(const mitk::Image *image)
   {
     CPPUNIT_ASSERT_MESSAGE("Internal error. Passed reference image is null.", image);
 
     std::ofstream tmpStream;
     std::string tmpFilePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.nrrd");
     tmpStream.close();
 
     try
     {
       mitk::IOUtil::Save(image, tmpFilePath);
 
       mitk::Image::Pointer compareImage = mitk::IOUtil::Load<mitk::Image>(tmpFilePath);
       CPPUNIT_ASSERT_MESSAGE("Image stored in NRRD format was succesfully loaded again", compareImage.IsNotNull());
 
       /*It would make sence to check the images as well (see commented cppunit assert),
         but currently there seems to be a problem (exception) with most of the test images
         (partly it seems to be a problem when try to access the pixel content by AccessByItk_1
         in mitk::CompareImageDataFilter.
         This problem should be dealt with in Bug 19533 - mitkITKImageIOTest needs improvement */
       // CPPUNIT_ASSERT_MESSAGE("Images are equal.", mitk::Equal(*image, *compareImage, mitk::eps, true));
       CPPUNIT_ASSERT_MESSAGE(
         "TimeGeometries are equal.",
         mitk::Equal(*(image->GetTimeGeometry()), *(compareImage->GetTimeGeometry()), mitk::eps, true));
 
       CPPUNIT_ASSERT_EQUAL_MESSAGE("Error, read image has different UID", image->GetUID(), compareImage->GetUID());
 
       remove(tmpFilePath.c_str());
     }
     catch (...)
     {
       std::remove(tmpFilePath.c_str());
       CPPUNIT_FAIL("Exception during NRRD file writing");
     }
   }
 
   /**
   *  test for writing MHDs
   */
   void TestMHDWriting(const mitk::Image *image)
   {
     CPPUNIT_ASSERT_MESSAGE("Internal error. Passed reference image is null.", image);
 
     std::ofstream tmpStream;
     std::string tmpFilePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.mhd");
     tmpStream.close();
 
     std::string tmpFilePathWithoutExt = tmpFilePath.substr(0, tmpFilePath.size() - 4);
 
     try
     {
       mitk::IOUtil::Save(image, tmpFilePath);
 
       mitk::Image::Pointer compareImage = mitk::IOUtil::Load<mitk::Image>(tmpFilePath);
       CPPUNIT_ASSERT_MESSAGE("Image stored in MHD format was succesfully loaded again! ", compareImage.IsNotNull());
 
       CPPUNIT_ASSERT_MESSAGE(".mhd file exists",
-                             itksys::SystemTools::FileExists((tmpFilePathWithoutExt + ".mhd").c_str()));
+                             itksys::SystemTools::FileExists(mitk::Utf8Util::Local8BitToUtf8(tmpFilePathWithoutExt + ".mhd").c_str()));
       CPPUNIT_ASSERT_MESSAGE(".raw or .zraw exists",
-                             itksys::SystemTools::FileExists((tmpFilePathWithoutExt + ".raw").c_str()) ||
-                               itksys::SystemTools::FileExists((tmpFilePathWithoutExt + ".zraw").c_str()));
+                             itksys::SystemTools::FileExists(mitk::Utf8Util::Local8BitToUtf8(tmpFilePathWithoutExt + ".raw").c_str()) ||
+                               itksys::SystemTools::FileExists(mitk::Utf8Util::Local8BitToUtf8(tmpFilePathWithoutExt + ".zraw").c_str()));
 
       /*It would make sence to check the images as well (see commented cppunit assert),
       but currently there seems to be a problem (exception) with most of the test images
       (partly it seems to be a problem when try to access the pixel content by AccessByItk_1
       in mitk::CompareImageDataFilter.
       This problem should be dealt with in Bug 19533 - mitkITKImageIOTest needs improvement */
       // CPPUNIT_ASSERT_MESSAGE("Images are equal.", mitk::Equal(*image, *compareImage, mitk::eps, true));
       CPPUNIT_ASSERT_MESSAGE("TimeGeometries are equal.",
                              mitk::Equal(*(image->GetTimeGeometry()), *(compareImage->GetTimeGeometry()), 5e-4, true));
 
       CPPUNIT_ASSERT_EQUAL_MESSAGE("Error, read image has different UID", image->GetUID(), compareImage->GetUID());
 
       // delete
       remove(tmpFilePath.c_str());
       remove((tmpFilePathWithoutExt + ".raw").c_str());
       remove((tmpFilePathWithoutExt + ".zraw").c_str());
     }
     catch (...)
     {
       CPPUNIT_FAIL("Exception during.mhd file writing");
     }
   }
 
   /**
   *  test for "ImageWriter".
   *
   *  argc and argv are the command line parameters which were passed to
   *  the ADD_TEST command in the CMakeLists.txt file. For the automatic
   *  tests, argv is either empty for the simple tests or contains the filename
   *  of a test image for the image tests (see CMakeLists.txt).
   */
   void TestImageWriter(std::string sourcefile)
   {
     sourcefile = GetTestDataFilePath(sourcefile);
 
     // load image
-    CPPUNIT_ASSERT_MESSAGE("Checking whether source image exists", itksys::SystemTools::FileExists(sourcefile.c_str()));
+    CPPUNIT_ASSERT_MESSAGE("Checking whether source image exists", itksys::SystemTools::FileExists(mitk::Utf8Util::Local8BitToUtf8(sourcefile).c_str()));
 
     mitk::Image::Pointer image = nullptr;
 
     try
     {
       image = mitk::IOUtil::Load<mitk::Image>(sourcefile);
     }
     catch (...)
     {
       CPPUNIT_FAIL("Exception during file loading:");
     }
 
     CPPUNIT_ASSERT_MESSAGE("loaded image not nullptr", image.IsNotNull());
 
     // write ITK .mhd image (2D and 3D only)
     if (image->GetDimension() <= 3)
     {
       TestMHDWriting(image);
     }
 
     // testing more component image writing as nrrd files
     TestNRRDWriting(image);
 
     std::ofstream tmpStream;
     std::string tmpFilePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX");
     tmpStream.close();
 
     TestPictureWriting(image, tmpFilePath, ".png");
     TestPictureWriting(image, tmpFilePath, ".jpg");
     TestPictureWriting(image, tmpFilePath, ".tiff");
     TestPictureWriting(image, tmpFilePath, ".bmp");
     // always end with this!
   }
 
   /**
   * Try to write a 3D image with only one plane (a 2D images in disguise for all intents and purposes)
   */
   void TestWrite3DImageWithOnePlane()
   {
     typedef itk::Image<unsigned char, 3> ImageType;
 
     ImageType::Pointer itkImage = ImageType::New();
 
     ImageType::IndexType start;
     start.Fill(0);
 
     ImageType::SizeType size;
     size[0] = 100;
     size[1] = 100;
     size[2] = 1;
 
     ImageType::RegionType region;
     region.SetSize(size);
     region.SetIndex(start);
     itkImage->SetRegions(region);
     itkImage->Allocate();
     itkImage->FillBuffer(0);
 
     itk::ImageRegionIterator<ImageType> imageIterator(itkImage, itkImage->GetLargestPossibleRegion());
 
     // Make two squares
     while (!imageIterator.IsAtEnd())
     {
       if ((imageIterator.GetIndex()[0] > 5 && imageIterator.GetIndex()[0] < 20) &&
           (imageIterator.GetIndex()[1] > 5 && imageIterator.GetIndex()[1] < 20))
       {
         imageIterator.Set(255);
       }
 
       if ((imageIterator.GetIndex()[0] > 50 && imageIterator.GetIndex()[0] < 70) &&
           (imageIterator.GetIndex()[1] > 50 && imageIterator.GetIndex()[1] < 70))
       {
         imageIterator.Set(60);
       }
       ++imageIterator;
     }
 
     mitk::Image::Pointer image = mitk::ImportItkImage(itkImage);
 
     mitk::IOUtil::Save(image, mitk::IOUtil::CreateTemporaryFile("3Dto2DTestImageXXXXXX.nrrd"));
     mitk::IOUtil::Save(image, mitk::IOUtil::CreateTemporaryFile("3Dto2DTestImageXXXXXX.png"));
   }
 
   /**
   * Try to write a 3D image with only one plane (a 2D images in disguise for all intents and purposes)
   */
   void TestWrite3DImageWithTwoPlanes()
   {
     typedef itk::Image<unsigned char, 3> ImageType;
 
     ImageType::Pointer itkImage = ImageType::New();
 
     ImageType::IndexType start;
     start.Fill(0);
 
     ImageType::SizeType size;
     size[0] = 100;
     size[1] = 100;
     size[2] = 2;
 
     ImageType::RegionType region;
     region.SetSize(size);
     region.SetIndex(start);
     itkImage->SetRegions(region);
     itkImage->Allocate();
     itkImage->FillBuffer(0);
 
     itk::ImageRegionIterator<ImageType> imageIterator(itkImage, itkImage->GetLargestPossibleRegion());
 
     // Make two squares
     while (!imageIterator.IsAtEnd())
     {
       if ((imageIterator.GetIndex()[0] > 5 && imageIterator.GetIndex()[0] < 20) &&
           (imageIterator.GetIndex()[1] > 5 && imageIterator.GetIndex()[1] < 20))
       {
         imageIterator.Set(255);
       }
       if ((imageIterator.GetIndex()[0] > 50 && imageIterator.GetIndex()[0] < 70) &&
           (imageIterator.GetIndex()[1] > 50 && imageIterator.GetIndex()[1] < 70))
       {
         imageIterator.Set(60);
       }
       ++imageIterator;
     }
     mitk::Image::Pointer image = mitk::ImportItkImage(itkImage);
 
     mitk::IOUtil::Save(image, mitk::IOUtil::CreateTemporaryFile("3Dto2DTestImageXXXXXX.nrrd"));
 
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(image, mitk::IOUtil::CreateTemporaryFile("3Dto2DTestImageXXXXXX.png")),
                          mitk::Exception);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkItkImageIO)
diff --git a/Modules/Core/test/mitkLogTest.cpp b/Modules/Core/test/mitkLogTest.cpp
index c62143ba20..54fec7f105 100644
--- a/Modules/Core/test/mitkLogTest.cpp
+++ b/Modules/Core/test/mitkLogTest.cpp
@@ -1,299 +1,300 @@
 /*============================================================================
 
 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 "mitkCommon.h"
 #include "mitkTestingMacros.h"
 #include <itksys/SystemTools.hxx>
 #include <mitkLog.h>
 #include <mitkNumericTypes.h>
 #include <mitkStandardFileLocations.h>
 #include <thread>
+#include <mitkUtf8Util.h>
 
 /** Documentation
  *
  * @brief this class provides an accessible BackendCout to determine whether this backend was
  * used to process a message or not.
  * It is needed for the disable / enable backend test.
  */
 class TestBackendCout : public mbilog::BackendCout
 {
 public:
   TestBackendCout()
   {
     m_Called = false;
     mbilog::BackendCout();
   }
 
   void ProcessMessage(const mbilog::LogMessage &l) override
   {
     m_Called = true;
     mbilog::BackendCout::ProcessMessage(l);
   }
 
   bool WasCalled() { return m_Called; }
 private:
   bool m_Called;
 };
 /** Documentation
   *
   * @brief Objects of this class can start an internal thread by calling the Start() method.
   *        The thread is then logging messages until the method Stop() is called. The class
   *        can be used to test if logging is thread-save by using multiple objects and let
   *        them log simuntanously.
   */
 class mitkTestLoggingThread : public itk::Object
 {
 public:
   mitkClassMacroItkParent(mitkTestLoggingThread, itk::Object);
   itkFactorylessNewMacro(Self);
 
   int NumberOfMessages;
 
 protected:
   mitkTestLoggingThread()
     : NumberOfMessages(0),
       LoggingRunning(true)
   {
   }
 
   ~mitkTestLoggingThread()
   {
     this->Stop();
   }
 
   bool LoggingRunning;
   std::thread Thread;
 
   void LogMessages()
   {
     auto ThreadID = Thread.get_id();
 
     while (LoggingRunning)
     {
       MITK_INFO << "Test info stream in thread" << ThreadID << "\n even with newlines";
       MITK_WARN << "Test warning stream in thread " << ThreadID << ". "
                 << "Even with a very long text, even without meaning or implied meaning or content, just a long "
                    "sentence to see whether something has problems with long sentences or output in files or into "
                    "windows or commandlines or whatever.";
       MITK_DEBUG << "Test debugging stream in thread " << ThreadID;
       MITK_ERROR << "Test error stream in thread " << ThreadID;
       MITK_FATAL << "Test fatal stream in thread " << ThreadID;
 
       NumberOfMessages += 5;
     }
   }
 
   static void ThreadStartTracking(void *instance)
   {
     auto* thisthread = reinterpret_cast<mitkTestLoggingThread*>(instance);
 
     if (thisthread != nullptr)
       thisthread->LogMessages();
   }
 
 public:
   std::thread::id Start()
   {
     LoggingRunning = true;
     Thread.swap(std::thread(this->ThreadStartTracking, this));
     return Thread.get_id();
   }
 
   void Stop()
   {
     LoggingRunning = false;
 
     if(Thread.joinable())
       Thread.join();
   }
 };
 
 /** Documentation
  *
  *  @brief This class holds static test methods to sturcture the test of the mitk logging mechanism.
  */
 class mitkLogTestClass
 {
 public:
   static void TestSimpleLog()
   {
     bool testSucceded = true;
     try
     {
       MITK_INFO << "Test info stream.";
       MITK_WARN << "Test warning stream.";
       MITK_DEBUG << "Test debugging stream."; // only activated if cmake variable is on!
       // so no worries if you see no output for this line
       MITK_ERROR << "Test error stream.";
       MITK_FATAL << "Test fatal stream.";
     }
     catch (const mitk::Exception &)
     {
       testSucceded = false;
     }
     MITK_TEST_CONDITION_REQUIRED(testSucceded, "Test logging streams.");
   }
 
   static void TestObjectInfoLogging()
   {
     bool testSucceded = true;
     try
     {
       int i = 123;
       float f = .32234;
       double d = 123123;
       std::string testString = "testString";
       std::stringstream testStringStream;
       testStringStream << "test"
                        << "String"
                        << "Stream";
       mitk::Point3D testMitkPoint;
       testMitkPoint.Fill(2);
 
       MITK_INFO << i;
       MITK_INFO << f;
       MITK_INFO << d;
       MITK_INFO << testString;
       MITK_INFO << testStringStream.str();
       MITK_INFO << testMitkPoint;
     }
     catch (const mitk::Exception &)
     {
       testSucceded = false;
     }
     MITK_TEST_CONDITION_REQUIRED(testSucceded, "Test logging of object information.");
   }
 
   static void TestThreadSaveLog(bool toFile)
   {
     bool testSucceded = true;
 
     try
     {
       if (toFile)
       {
         std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() + "/testthreadlog.log";
-        itksys::SystemTools::RemoveFile(filename.c_str()); // remove old file, we do not want to append to large files
+        itksys::SystemTools::RemoveFile(mitk::Utf8Util::Local8BitToUtf8(filename).c_str()); // remove old file, we do not want to append to large files
         mitk::LoggingBackend::SetLogFile(filename.c_str());
       }
 
       unsigned int numberOfThreads = 20;
       unsigned int threadRuntimeInMilliseconds = 2000;
 
       std::vector<std::thread::id> threadIDs;
       std::vector<mitkTestLoggingThread::Pointer> threads;
 
       for (unsigned int threadIdx = 0; threadIdx < numberOfThreads; ++threadIdx)
       {
         // initialize threads...
         threads.push_back(mitkTestLoggingThread::New());
         std::cout << "Created " << threadIdx << ". thread." << std::endl;
       }
 
       for (unsigned int threadIdx = 0; threadIdx < numberOfThreads; ++threadIdx)
       {
         // start them
         std::cout << "Start " << threadIdx << ". thread." << std::endl;
         threadIDs.push_back(threads[threadIdx]->Start());
         std::cout << threadIdx << ". thread has ID " << threadIDs[threadIdx] << std::endl;
       }
 
       // wait for some time (milliseconds)
       itksys::SystemTools::Delay(threadRuntimeInMilliseconds);
 
       for (unsigned int threadIdx = 0; threadIdx < numberOfThreads; ++threadIdx)
       {
         // stop them and wait for them to end
         std::cout << "Stop " << threadIdx << ". thread." << std::endl;
         threads[threadIdx]->Stop();
         std::cout << "Terminated " << threadIdx << ". thread (" << threads[threadIdx]->NumberOfMessages << " messages)." << std::endl;
       }
     }
     catch (std::exception &e)
     {
       MITK_ERROR << "exception during 'TestThreadSaveLog': " << e.what();
       testSucceded = false;
     }
     catch (...)
     {
       MITK_ERROR << "unknown exception during 'TestThreadSaveLog'";
       testSucceded = false;
     }
 
     // if no error occured until now, everything is ok
     MITK_TEST_CONDITION_REQUIRED(testSucceded, "Test logging in different threads.");
   }
 
   static void TestLoggingToFile()
   {
     std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() + "/testlog.log";
     mitk::LoggingBackend::SetLogFile(filename.c_str());
     MITK_INFO << "Test logging to default filename: " << mitk::LoggingBackend::GetLogFile();
-    MITK_TEST_CONDITION_REQUIRED(itksys::SystemTools::FileExists(filename.c_str()), "Testing if log file exists.");
+    MITK_TEST_CONDITION_REQUIRED(itksys::SystemTools::FileExists(mitk::Utf8Util::Local8BitToUtf8(filename).c_str()), "Testing if log file exists.");
     // TODO delete log file?
   }
 
   static void TestAddAndRemoveBackends()
   {
     mbilog::BackendCout myBackend = mbilog::BackendCout();
     mbilog::RegisterBackend(&myBackend);
     MITK_INFO << "Test logging";
     mbilog::UnregisterBackend(&myBackend);
 
     // if no error occured until now, everything is ok
     MITK_TEST_CONDITION_REQUIRED(true, "Test add/remove logging backend.");
   }
 
   static void TestDefaultBackend()
   {
     // not possible now, because we cannot unregister the mitk logging backend in the moment. If such a method is added
     // to mbilog utility one may add this test.
   }
 
   static void TestEnableDisableBackends()
   {
     TestBackendCout myCoutBackend = TestBackendCout();
     mbilog::RegisterBackend(&myCoutBackend);
 
     mbilog::DisableBackends(mbilog::Console);
     MITK_INFO << "There should be no output!";
     bool success = !myCoutBackend.WasCalled();
 
     mbilog::EnableBackends(mbilog::Console);
     MITK_INFO << "Now there should be an output.";
     success &= myCoutBackend.WasCalled();
 
     mbilog::UnregisterBackend(&myCoutBackend);
     MITK_TEST_CONDITION_REQUIRED(success, "Test disable / enable logging backends.")
   }
 };
 
 int mitkLogTest(int /* argc */, char * /*argv*/ [])
 {
   // always start with this!
   MITK_TEST_BEGIN("Log")
 
   MITK_TEST_OUTPUT(<< "TESTING ALL LOGGING OUTPUTS, ERROR MESSAGES ARE ALSO TESTED AND NOT MEANING AN ERROR OCCURED!")
 
   mitkLogTestClass::TestSimpleLog();
   mitkLogTestClass::TestObjectInfoLogging();
 
   mitkLogTestClass::TestLoggingToFile();
   mitkLogTestClass::TestAddAndRemoveBackends();
   mitkLogTestClass::TestThreadSaveLog(false); // false = to console
   mitkLogTestClass::TestThreadSaveLog(true);  // true = to file
   mitkLogTestClass::TestEnableDisableBackends();
   // TODO actually test file somehow?
 
   // always end with this!
   MITK_TEST_END()
 }
diff --git a/Modules/Core/test/mitkTinyXMLTest.cpp b/Modules/Core/test/mitkTinyXMLTest.cpp
index 392ab4384d..db0d7104d2 100644
--- a/Modules/Core/test/mitkTinyXMLTest.cpp
+++ b/Modules/Core/test/mitkTinyXMLTest.cpp
@@ -1,162 +1,163 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 // Testing
 #include "mitkTestFixture.h"
 #include <mitkTestingMacros.h>
 
 // std includes
 #include <cmath>
 #include <iomanip>
 #include <tinyxml2.h>
 
 // MITK includes
 #include "mitkStringProperty.h"
 #include <mitkNumericTypes.h>
+#include <mitkUtf8Util.h>
 
 // itksys
 #include <itksys/SystemTools.hxx>
 
 // VTK includes
 #include <vtkDebugLeaks.h>
 
 // vnl includes
 #include <vnl/vnl_vector_fixed.hxx>
 
 class mitkTinyXMLTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkTinyXMLTestSuite);
 
   MITK_TEST(TestingFunctionSetupWorks_Success);
   MITK_TEST(TestingReadValueFromSetupDocument_Success);
   MITK_TEST(TestingReadOutValueWorks_Success);
   MITK_TEST(TestDoubleValueWriteOut_Success);
   MITK_TEST(TestDoubleValueWriteOutManyDecimalPlaces_Success);
 
   CPPUNIT_TEST_SUITE_END();
 
 private:
-  const std::string m_Filename = itksys::SystemTools::GetCurrentWorkingDirectory() + "/TinyXMLTest.txt";
+  const std::string m_Filename = mitk::Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetCurrentWorkingDirectory()) + "/TinyXMLTest.txt";
   const std::string m_ElementToStoreAttributeName = "DoubleTest";
   const std::string m_AttributeToStoreName = "CommaValue";
 
   tinyxml2::XMLDocument m_Document;
   tinyxml2::XMLElement *m_DoubleTest;
 
   double calcPrecision(const unsigned int requiredDecimalPlaces)
   {
     return pow(10.0, -1.0 * ((double)requiredDecimalPlaces));
   }
 
   bool Setup(double valueToWrite)
   {
     m_Document.Clear();
     m_DoubleTest = nullptr;
 
     // 1. create simple document
     m_Document.InsertEndChild(m_Document.NewDeclaration());
 
     auto *version = m_Document.NewElement("Version");
     version->SetAttribute("Writer", __FILE__);
     version->SetAttribute("CVSRevision", "$Revision: 17055 $");
     version->SetAttribute("FileVersion", 1);
     m_Document.InsertEndChild(version);
 
     // 2. store one element containing a double value with potentially many after comma digits.
     auto *vElement = m_Document.NewElement(m_ElementToStoreAttributeName.c_str());
     vElement->SetAttribute(m_AttributeToStoreName.c_str(), valueToWrite);
     m_Document.InsertEndChild(vElement);
 
     // 3. store in file.
     auto err = m_Document.SaveFile(m_Filename.c_str());
     return tinyxml2::XML_SUCCESS == err;
   }
 
 public:
   void setUp() override {}
 
   void tearDown() override {}
 
   void TestingFunctionSetupWorks_Success()
   {
     CPPUNIT_ASSERT_MESSAGE("Test if Setup correctly writes data to file", Setup(1.0));
   }
 
   int readValueFromSetupDocument(double &readOutValue)
   {
     if (tinyxml2::XML_SUCCESS != m_Document.LoadFile(m_Filename.c_str()))
     {
       CPPUNIT_ASSERT_MESSAGE("Test Setup failed, could not open file", false);
       return tinyxml2::XML_NO_ATTRIBUTE;
     }
     else
     {
       m_DoubleTest = m_Document.FirstChildElement(m_ElementToStoreAttributeName.c_str());
       return m_DoubleTest->QueryDoubleAttribute(m_AttributeToStoreName.c_str(), &readOutValue);
     }
   }
 
   void TestingReadValueFromSetupDocument_Success()
   {
     if (tinyxml2::XML_SUCCESS != m_Document.LoadFile(m_Filename.c_str()))
     {
       CPPUNIT_ASSERT_MESSAGE("Test Setup failed, could not open file", tinyxml2::XML_SUCCESS != m_Document.LoadFile(m_Filename.c_str()));
     }
     else
     {
       m_DoubleTest = m_Document.FirstChildElement(m_ElementToStoreAttributeName.c_str());
       CPPUNIT_ASSERT_MESSAGE("Test Setup could open file", m_DoubleTest != nullptr);
     }
   }
 
   /**
    * this first test ensures we can correctly readout values from the
    * TinyXMLDocument.
    */
   void TestingReadOutValueWorks_Success()
   {
     double readValue;
 
     CPPUNIT_ASSERT_MESSAGE("checking if readout mechanism works.",
                            tinyxml2::XML_SUCCESS == readValueFromSetupDocument(readValue));
   }
 
   void TestDoubleValueWriteOut_Success()
   {
     const double valueToWrite = -1.123456;
     const int validDigitsAfterComma = 6; // indicates the number of valid digits after comma of valueToWrite
     const double neededPrecision = calcPrecision(validDigitsAfterComma + 1);
     double readValue;
 
     Setup(valueToWrite);
     readValueFromSetupDocument(readValue);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if value valueToWrite  equals  readValue which was retrieved from TinyXML document",
                            mitk::Equal(valueToWrite, readValue, neededPrecision));
   }
 
   void TestDoubleValueWriteOutManyDecimalPlaces_Success()
   {
     const double valueToWrite = -1.12345678910111;
     const int validDigitsAfterComma = 14; // indicates the number of valid digits after comma of valueToWrite
     const double neededPrecision = calcPrecision(validDigitsAfterComma + 1);
     double readValue;
 
     Setup(valueToWrite);
 
     readValueFromSetupDocument(readValue);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if value valueToWrite equals readValue which was retrieved from TinyXML document",
                            mitk::Equal(valueToWrite, readValue, neededPrecision));
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkTinyXML)