diff --git a/Modules/BasicImageProcessing/MiniApps/MaskRangeBasedFiltering.cpp b/Modules/BasicImageProcessing/MiniApps/MaskRangeBasedFiltering.cpp
index d9f6b8257c..c555f6e37e 100644
--- a/Modules/BasicImageProcessing/MiniApps/MaskRangeBasedFiltering.cpp
+++ b/Modules/BasicImageProcessing/MiniApps/MaskRangeBasedFiltering.cpp
@@ -1,114 +1,114 @@
 /*===================================================================
 
 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 "mitkProperties.h"
 
 #include "mitkCommandLineParser.h"
 #include "mitkIOUtil.h"
 
 #include <mitkMaskCleaningOperation.h>
 
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Mask  Outlier filtering");
   parser.setCategory("Basic Image Processing");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--", "-");
   // Add command line argument names
   parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help:", "Show this help text");
   parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image:", "Input Image", us::Any(), false);
   parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Input mask:", "Input Mask", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output file:", "Output Mask", us::Any(), false);
 
   parser.addArgument("lower-limit", "lL", mitkCommandLineParser::Float, "Lower Limit", "Lower Limit", us::Any(), true);
   parser.addArgument("upper-limit", "ul", mitkCommandLineParser::Float, "Upper Limit", "Upper Limit", us::Any(), true);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size() == 0)
     return EXIT_FAILURE;
 
   // Show a help message
   if (parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   std::string inputFilename = us::any_cast<std::string>(parsedArgs["image"]);
   std::string maskFilename = us::any_cast<std::string>(parsedArgs["mask"]);
   std::string outputFilename = us::any_cast<std::string>(parsedArgs["output"]);
 
   auto nodes = mitk::IOUtil::Load(inputFilename);
   if (nodes.size() == 0)
   {
     MITK_INFO << "No Image Loaded";
     return 0;
   }
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(nodes[0].GetPointer());
 
   if (image.IsNull())
   {
     MITK_INFO << "Loaded data (image) is not of type image";
     return 0;
   }
 
 
   auto maskNodes = mitk::IOUtil::Load(maskFilename);
   if (maskNodes.size() == 0)
   {
     MITK_INFO << "No Mask Loaded";
     return 0;
   }
   mitk::Image::Pointer mask = dynamic_cast<mitk::Image*>(maskNodes[0].GetPointer());
 
   if (image.IsNull())
   {
     MITK_INFO << "Loaded data (mask) is not of type image";
     return 0;
   }
 
   bool useUpperLimit = false;
   bool useLowerLimit = false;
   double lowerLimit = 0;
   double upperLimit = 1;
 
   if (parsedArgs.count("lower-limit"))
   {
     useLowerLimit = true;
-    double lowerLimit = us::any_cast<float>(parsedArgs["lower-limit"]);
+    lowerLimit = us::any_cast<float>(parsedArgs["lower-limit"]);
   }
   if (parsedArgs.count("upper-limit"))
   {
     useUpperLimit = true;
-    double upperLimit = us::any_cast<float>(parsedArgs["upper-limit"]);
+    upperLimit = us::any_cast<float>(parsedArgs["upper-limit"]);
   }
 
   if (useLowerLimit || useUpperLimit)
   {
     mitk::Image::Pointer tmpImage = mitk::MaskCleaningOperation::RangeBasedMasking(image, mask, useLowerLimit, lowerLimit, useUpperLimit, upperLimit);
     mitk::IOUtil::Save(tmpImage, outputFilename);
   } else
   {
     MITK_INFO << "No limit specified. Specify either lower or upper limit";
   }
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/BasicImageProcessing/MiniApps/ResampleMask.cpp b/Modules/BasicImageProcessing/MiniApps/ResampleMask.cpp
index b344c613d0..94deb35c4e 100644
--- a/Modules/BasicImageProcessing/MiniApps/ResampleMask.cpp
+++ b/Modules/BasicImageProcessing/MiniApps/ResampleMask.cpp
@@ -1,157 +1,142 @@
 /*===================================================================
 
 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 "mitkProperties.h"
 
 #include "mitkCommandLineParser.h"
 #include "mitkIOUtil.h"
 
 #include <mitkTransformationOperation.h>
 
-static bool ConvertToBool(std::map<std::string, us::Any> &data, std::string name)
-{
-  if (!data.count(name))
-  {
-    return false;
-  }
-  try {
-    return us::any_cast<bool>(data[name]);
-  }
-  catch (us::BadAnyCastException &)
-  {
-    return false;
-  }
-}
-
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Mask  Outlier filtering");
   parser.setCategory("Basic Image Processing");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--", "-");
   // Add command line argument names
   parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help:", "Show this help text");
   parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image:", "Input Image", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output file:", "Output Mask", us::Any(), false);
 
   parser.addArgument("spacing-x", "x", mitkCommandLineParser::Float, "Spacing in x direction", "Spacing in x direction", us::Any(), false);
   parser.addArgument("spacing-y", "y", mitkCommandLineParser::Float, "Spacing in y direction", "Spacing in y direction", us::Any(), false);
   parser.addArgument("spacing-z", "z", mitkCommandLineParser::Float, "Spacing in z direction", "Spacing in z direction", us::Any(), false);
 
   parser.addArgument("mapping-type", "mapping", mitkCommandLineParser::Int, "0: Origin aligned, 1: Center aligned, 3: Same size", "0: Origin aligned, 1: Center aligned, 3: Same size", us::Any(), true);
   parser.addArgument("interpolator-type", "interpolator", mitkCommandLineParser::Int, "0: Linear, 1: BSpline 3, 2: Nearest Neighbour, 3: WSinc Hamming, 4: WSinc Welch", "0: Linear, 1: BSpline 3, 2: Nearest Neighbour, 3: WSinc Hamming, 4: WSinc Welch", us::Any(), true);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size() == 0)
     return EXIT_FAILURE;
 
   // Show a help message
   if (parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   std::string inputFilename = us::any_cast<std::string>(parsedArgs["image"]);
   std::string outputFilename = us::any_cast<std::string>(parsedArgs["output"]);
 
   auto nodes = mitk::IOUtil::Load(inputFilename);
   if (nodes.size() == 0)
   {
     MITK_INFO << "No Image Loaded";
     return 0;
   }
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(nodes[0].GetPointer());
 
   if (image.IsNull())
   {
     MITK_INFO << "Loaded data (image) is not of type image";
     return 0;
   }
 
   mitk::Vector3D spacing;
   spacing[0] = us::any_cast<float>(parsedArgs["spacing-x"]);
   spacing[1] = us::any_cast<float>(parsedArgs["spacing-y"]);
   spacing[2] = us::any_cast<float>(parsedArgs["spacing-z"]);
 
   int interpolator = 0;
   if (parsedArgs.count("interpolator-type"))
   {
     interpolator =  us::any_cast<int>(parsedArgs["interpolator-type"]);
   }
 
   mitk::ImageMappingInterpolator::Type interpolatorType;
   switch (interpolator)
   {
   case 0:
     interpolatorType = mitk::ImageMappingInterpolator::Linear;
     break;
 
   case 1:
     interpolatorType = mitk::ImageMappingInterpolator::BSpline_3;
     break;
 
   case 2:
     interpolatorType = mitk::ImageMappingInterpolator::NearestNeighbor;
     break;
 
   case 3:
     interpolatorType = mitk::ImageMappingInterpolator::WSinc_Hamming;
     break;
 
   case 4:
     interpolatorType = mitk::ImageMappingInterpolator::WSinc_Welch;
     break;
 
   default:
     interpolatorType = mitk::ImageMappingInterpolator::Linear;
   }
 
   int position = 0;
   if (parsedArgs.count("mapping-type"))
   {
     position = us::any_cast<int>(parsedArgs["mapping-type"]);
   }
 
   mitk::GridInterpolationPositionType gridPosition;
   switch (position)
   {
   case 0:
     gridPosition = mitk::GridInterpolationPositionType::OriginAligned;
     break;
 
   case 1:
     gridPosition = mitk::GridInterpolationPositionType::CenterAligned;
     break;
 
   case 2:
     gridPosition = mitk::GridInterpolationPositionType::SameSize;
     break;
 
   default:
     gridPosition = mitk::GridInterpolationPositionType::OriginAligned;
   }
 
   mitk::Image::Pointer tmpImage = mitk::TransformationOperation::ResampleMask(image, spacing, interpolatorType, gridPosition);
   mitk::IOUtil::Save(tmpImage, outputFilename);
 
 
   return EXIT_SUCCESS;
 }