diff --git a/Modules/DiffusionImaging/MiniApps/CMakeLists.txt b/Modules/DiffusionImaging/MiniApps/CMakeLists.txt
index 5736f18a80..55564628ce 100755
--- a/Modules/DiffusionImaging/MiniApps/CMakeLists.txt
+++ b/Modules/DiffusionImaging/MiniApps/CMakeLists.txt
@@ -1,117 +1,118 @@
 option(BUILD_DiffusionMiniApps "Build commandline tools for diffusion" OFF)
 
 if(BUILD_DiffusionMiniApps OR MITK_BUILD_ALL_APPS)
 
   # needed include directories
   include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     )
 
     # list of diffusion miniapps
     # if an app requires additional dependencies
     # they are added after a "^^" and separated by "_"
     set( diffusionminiapps
     DwiDenoising^^
     ImageResampler^^
     NetworkCreation^^MitkFiberTracking_MitkConnectomics
     NetworkStatistics^^MitkConnectomics
     ExportShImage^^
+    ExtractImageStatistics^^
     Fiberfox^^MitkFiberTracking
     MultishellMethods^^MitkFiberTracking
     PeaksAngularError^^MitkFiberTracking
     PeakExtraction^^MitkFiberTracking
     FiberExtraction^^MitkFiberTracking
     FiberProcessing^^MitkFiberTracking
     FiberDirectionExtraction^^MitkFiberTracking
     LocalDirectionalFiberPlausibility^^MitkFiberTracking
     StreamlineTracking^^MitkFiberTracking
     GibbsTracking^^MitkFiberTracking
     CopyGeometry^^
     DiffusionIndices^^
     TractometerMetrics^^MitkFiberTracking
     QballReconstruction^^
     Registration^^
     FileFormatConverter^^MitkFiberTracking
     TensorReconstruction^^
     TensorDerivedMapsExtraction^^
     DiffusionDICOMLoader^^
     DFTraining^^MitkFiberTracking
     DFTracking^^MitkFiberTracking
     )
 
     foreach(diffusionminiapp ${diffusionminiapps})
       # extract mini app name and dependencies
       string(REPLACE "^^" "\\;" miniapp_info ${diffusionminiapp})
       set(miniapp_info_list ${miniapp_info})
       list(GET miniapp_info_list 0 appname)
       list(GET miniapp_info_list 1 raw_dependencies)
       string(REPLACE "_" "\\;" dependencies "${raw_dependencies}")
       set(dependencies_list ${dependencies})
 
       mitk_create_executable(${appname}
       DEPENDS MitkCore MitkDiffusionCore MitkCommandLine ${dependencies_list}
       PACKAGE_DEPENDS ITK
       CPP_FILES ${appname}.cpp
       )
 
       if(EXECUTABLE_IS_ENABLED)
 
         # On Linux, create a shell script to start a relocatable application
         if(UNIX AND NOT APPLE)
           install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME ${EXECUTABLE_TARGET}.sh)
         endif()
 
         get_target_property(_is_bundle ${EXECUTABLE_TARGET} MACOSX_BUNDLE)
 
         if(APPLE)
          if(_is_bundle)
            set(_target_locations ${EXECUTABLE_TARGET}.app)
            set(${_target_locations}_qt_plugins_install_dir ${EXECUTABLE_TARGET}.app/Contents/MacOS)
            set(_bundle_dest_dir ${EXECUTABLE_TARGET}.app/Contents/MacOS)
            set(_qt_plugins_for_current_bundle ${EXECUTABLE_TARGET}.app/Contents/MacOS)
            set(_qt_conf_install_dirs ${EXECUTABLE_TARGET}.app/Contents/Resources)
            install(TARGETS ${EXECUTABLE_TARGET} BUNDLE DESTINATION . )
          else()
            if(NOT MACOSX_BUNDLE_NAMES)
              set(_qt_conf_install_dirs bin)
              set(_target_locations bin/${EXECUTABLE_TARGET})
              set(${_target_locations}_qt_plugins_install_dir bin)
              install(TARGETS ${EXECUTABLE_TARGET} RUNTIME DESTINATION bin)
            else()
              foreach(bundle_name ${MACOSX_BUNDLE_NAMES})
                list(APPEND _qt_conf_install_dirs ${bundle_name}.app/Contents/Resources)
                set(_current_target_location ${bundle_name}.app/Contents/MacOS/${EXECUTABLE_TARGET})
                list(APPEND _target_locations ${_current_target_location})
                set(${_current_target_location}_qt_plugins_install_dir ${bundle_name}.app/Contents/MacOS)
                message( "  set(${_current_target_location}_qt_plugins_install_dir ${bundle_name}.app/Contents/MacOS) ")
 
                install(TARGETS ${EXECUTABLE_TARGET} RUNTIME DESTINATION ${bundle_name}.app/Contents/MacOS/)
              endforeach()
            endif()
          endif()
        else()
          set(_target_locations bin/${EXECUTABLE_TARGET}${CMAKE_EXECUTABLE_SUFFIX})
          set(${_target_locations}_qt_plugins_install_dir bin)
          set(_qt_conf_install_dirs bin)
          install(TARGETS ${EXECUTABLE_TARGET} RUNTIME DESTINATION bin)
        endif()
       endif()
     endforeach()
 
   # This mini app does not depend on mitkDiffusionImaging at all
   mitk_create_executable(Dicom2Nrrd
     DEPENDS MitkCore MitkCommandLine
     CPP_FILES Dicom2Nrrd.cpp
   )
 
         # On Linux, create a shell script to start a relocatable application
         if(UNIX AND NOT APPLE)
           install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME ${EXECUTABLE_TARGET}.sh)
         endif()
 
   if(EXECUTABLE_IS_ENABLED)
     MITK_INSTALL_TARGETS(EXECUTABLES ${EXECUTABLE_TARGET})
   endif()
 
 endif()
diff --git a/Modules/DiffusionImaging/MiniApps/ExtractImageStatistics.cpp b/Modules/DiffusionImaging/MiniApps/ExtractImageStatistics.cpp
index e30bbfa158..e4532dda99 100644
--- a/Modules/DiffusionImaging/MiniApps/ExtractImageStatistics.cpp
+++ b/Modules/DiffusionImaging/MiniApps/ExtractImageStatistics.cpp
@@ -1,127 +1,127 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
-#include "MiniAppManager.h"
+//#include "MiniAppManager.h"
 
 #include "ctkCommandLineParser.h"
 #include "mitkImage.h"
 #include "mitkImageStatisticsCalculator.h"
 #include "mitkIOUtil.h"
 #include <iostream>
 #include <usAny.h>
 #include <fstream>
 
 int ExtractImageStatistics(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Extract Image Statistics");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("help", "h", mitkCommandLineParser::String, "Help:", "Show this help text");
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input image", us::Any(),false);
   parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "mask image / roi image denotin area on which statistics are calculated", us::Any(),false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output", "output file (default: filenameOfRoi.nrrd_statistics.txt)", us::Any());
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0 || parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << "\n\n MiniApp Description: \nCalculates statistics on the supplied image using given mask." << endl;
     std::cout << "Output is written to the designated output file in this order:" << endl;
     std::cout << "Mean, Standard Deviation, RMS, Max, Min, Number of Voxels, Volume [mm3]" << endl;
     std::cout << "\n\n Parameters:"<< endl;
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   // Parameters:
   bool ignoreZeroValues = false;
   unsigned int timeStep = 0;
 
   std::string inputImageFile = us::any_cast<string>(parsedArgs["input"]);
   std::string maskImageFile = us::any_cast<string>(parsedArgs["mask"]);
 
   std::string outFile;
   if (parsedArgs.count("out") || parsedArgs.count("o") )
     outFile = us::any_cast<string>(parsedArgs["out"]);
   else
     outFile = inputImageFile + "_statistics.txt";
 
   // Load image and mask
   mitk::Image::Pointer maskImage = mitk::IOUtil::LoadImage(maskImageFile);
   mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(inputImageFile);
 
   // Calculate statistics
   mitk::ImageStatisticsCalculator::Statistics statisticsStruct;
   mitk::ImageStatisticsCalculator::Pointer calculator = mitk::ImageStatisticsCalculator::New();
   try
   {
     calculator->SetImage(inputImage);
     calculator->SetImageMask(maskImage);
     calculator->SetMaskingModeToImage();
   }
   catch( const itk::ExceptionObject& e)
   {
     MITK_ERROR << "Statistic Calculation Failed - ITK Exception:" << e.what();
     return -1;
   }
 
 
   calculator->SetDoIgnorePixelValue(ignoreZeroValues);
   calculator->SetIgnorePixelValue(0);
   try
   {
     calculator->ComputeStatistics(timeStep);
   }
   catch ( mitk::Exception& e)
   {
     MITK_ERROR<< "MITK Exception: " << e.what();
     return -1;
   }
 
 
   statisticsStruct = calculator->GetStatistics(timeStep);
 
 
   // Calculate Volume
   double volume = 0;
   const mitk::BaseGeometry *geometry = inputImage->GetGeometry();
   if ( geometry != NULL )
   {
     const mitk::Vector3D &spacing = inputImage->GetGeometry()->GetSpacing();
     volume = spacing[0] * spacing[1] * spacing[2] * (double) statisticsStruct.GetN();
   }
 
   // Write Results to file
   std::ofstream output;
   output.open(outFile.c_str());
   output << statisticsStruct.GetMean() << " , ";
   output << statisticsStruct.GetSigma() << " , ";
   output << statisticsStruct.GetRMS() << " , ";
   output << statisticsStruct.GetMax() << " , ";
   output << statisticsStruct.GetMin() << " , ";
   output << statisticsStruct.GetN() << " , ";
   output << volume << "\n";
 
   output.flush();
   output.close();
   return 0;
 }
 
 RegisterDiffusionMiniApp(ExtractImageStatistics);