diff --git a/Plugins/org.mitk.gui.qt.exampleplugin/src/internal/ExampleView.cpp b/Plugins/org.mitk.gui.qt.exampleplugin/src/internal/ExampleView.cpp
index 4c68dd17a9..f17eafaffb 100644
--- a/Plugins/org.mitk.gui.qt.exampleplugin/src/internal/ExampleView.cpp
+++ b/Plugins/org.mitk.gui.qt.exampleplugin/src/internal/ExampleView.cpp
@@ -1,235 +1,236 @@
 /*===================================================================
 
 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 <usModuleRegistry.h> <-research
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "ExampleView.h"
 
 // Qt
 #include <QMessageBox>
 #include <QInputDialog>
 #include <QLineEdit>
 
 
 // mitk image
 #include <mitkImage.h>
 #include <mitkProperties.h>
 #include <mitkDataNodeObject.h>
 #include <mitkDataNodeSelection.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkImageStatisticsCalculator.h>
 #include <mitkDataStorage.h>
 #include <mitkNodePredicateDataType.h>
+#include <mitkNodePredicateDimension.h>
+#include <mitkNodePredicateAnd.h>
 
 #include <mitkImagePixelWriteAccessor.h>
 #include <mitkImagePixelReadAccessor.h>
 
 
 const std::string ExampleView::VIEW_ID = "org.mitk.views.exampleview";
 
 void ExampleView::SetFocus()
 {
   m_Controls.buttonPerformImageProcessing->setFocus();
 }
 
 void ExampleView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
+  mitk::NodePredicateDimension::Pointer is3D = mitk::NodePredicateDimension::New(3);
   m_Controls.comboBoxImageSelection->SetDataStorage(GetDataStorage());
-  m_Controls.comboBoxImageSelection->SetPredicate(isImage);
+  mitk::NodePredicateAnd::Pointer isAvailable = mitk::NodePredicateAnd::New();
+  isAvailable->AddPredicate(isImage);
+  isAvailable->AddPredicate(is3D);
+  m_Controls.comboBoxImageSelection->SetPredicate(isAvailable);
   connect(m_Controls.buttonPerformImageProcessing, &QPushButton::clicked, this, &ExampleView::DoImageStatistics);
   connect(m_Controls.buttonGenerate, &QPushButton::clicked, this, &ExampleView::DoPixelMasking);
   connect(m_Controls.comboBoxImageSelection, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnComboBoxImageSelectionChanged(const mitk::DataNode*)));
 }
 
 void ExampleView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
                                                 const QList<mitk::DataNode::Pointer> &nodes)
 {
 }
 
 void ExampleView::OnComboBoxImageSelectionChanged(const mitk::DataNode *node)
 {
 	if (node == nullptr)
 	{
 		m_Controls.labelWarning->setVisible(true);
 		m_Controls.buttonPerformImageProcessing->setEnabled(false);
 		m_Controls.buttonGenerate->setEnabled(false);
 		m_Controls.spinboxThreshold->setEnabled(false);
 		return;
 	}
 	m_Controls.labelWarning->setVisible(false);
 	m_Controls.buttonPerformImageProcessing->setEnabled(true);
 	m_Controls.buttonGenerate->setEnabled(true);
 	m_Controls.spinboxThreshold->setEnabled(true);
     m_Controls.tableWidgetStatistics->clearContents();
 }
 
 void ExampleView::DoImageStatistics()
 {
 	auto node = m_Controls.comboBoxImageSelection->GetSelectedNode();
 	if (node == nullptr) {
 		MITK_WARN << "no node selected";
 
 	}
 
   if (node == nullptr)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
     return;
   }
 
   // here we have a valid mitk::DataNode
 
   // a node itself is not very useful, we need its data item (the image)
   mitk::BaseData *data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image *image = dynamic_cast<mitk::Image *>(data);
     if (image)
     {
 	   mitk::ImageStatisticsCalculator::Pointer imgStatisticsCalc= mitk::ImageStatisticsCalculator::New();
 	   imgStatisticsCalc->SetInputImage(image);
 
 	   auto imgStatisticsContained = imgStatisticsCalc->GetStatistics()->GetStatisticsForTimeStep(0);
 
 	   auto stringMedian = mitk::ImageStatisticsConstants::MEDIAN();
 	   auto medianPixelValue = imgStatisticsContained.GetValueConverted<double>(stringMedian);
 
 	   auto stringUniformity = mitk::ImageStatisticsConstants::UNIFORMITY();
        auto uniformityPixelValue = imgStatisticsContained.GetValueConverted<double>(stringUniformity);
 
 	   auto stringMax = mitk::ImageStatisticsConstants::MAXIMUM();
        auto maxPixelValue = imgStatisticsContained.GetValueConverted<double>(stringMax);
 
 	   auto stringMin = mitk::ImageStatisticsConstants::MINIMUM();
        auto minPixelValue = imgStatisticsContained.GetValueConverted<double>(stringMin);
 	   //Output max
 	   QString maxPixelValueString = QString::number(maxPixelValue);
 	   QTableWidgetItem *max = new QTableWidgetItem(maxPixelValueString);
 	   m_Controls.tableWidgetStatistics->setItem(0, 0, max);
 
 	   //Output min
 	   QString minPixelValueString = QString::number(minPixelValue);
 	   QTableWidgetItem *min = new QTableWidgetItem(minPixelValueString);
 	   m_Controls.tableWidgetStatistics->setItem(1, 0, min);
 
 	   //Output avg
 	   QString avgPixelValueString = QString::number(medianPixelValue);
 	   QTableWidgetItem *avg = new QTableWidgetItem(avgPixelValueString);
 	   m_Controls.tableWidgetStatistics->setItem(2, 0, avg);
 
 	   //Output dev
 	   QString devPixelValueString = QString::number(uniformityPixelValue);
 	   QTableWidgetItem *dev = new QTableWidgetItem(devPixelValueString);
 	   m_Controls.tableWidgetStatistics->setItem(3, 0, dev);
     }
   }
 }
 
 
 
 void ExampleView::DoPixelMasking()
 {
 	int pixelValueMask = m_Controls.spinboxThreshold->value();
 	this->ProcessImage(pixelValueMask);
 }
 
 void ExampleView::ProcessImage(int pixelValueMask)
 {
 	// check for valid node selected
 	auto node = m_Controls.comboBoxImageSelection->GetSelectedNode();
 
 	if (node == nullptr)
 	{
 		// Nothing selected. Inform the user and return
 		QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
 		return;
 	}
 
 	mitk::BaseData* data = node->GetData(); //get data from node
 	if (data != nullptr)
 	{
 		//Ask for the name of the mask
 		bool ok = false;
 		QString name = QInputDialog::getText(QApplication::activeWindow()
 			, tr("Add masked image..."), tr("Enter name for the new masked image"), QLineEdit::Normal, tr("maskedImage"), &ok);
 		if (!ok || name.isEmpty())
 			return;
 
 		//Create cloned image
 		mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(data);
 		if (!image)
 		{
 			QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
 			return;
 		}
 		mitk::Image::Pointer maskedImage = image->Clone();
-		//Get Dimensions, first only 3d
-		if (image->GetDimension() != 3)
-		{
-			QMessageBox::information(nullptr, "Warning", "Please select a 3D image.");
-			return;
-		}
+
 		//Get pixel value
 
 		mitk::ImagePixelWriteAccessor<short, 3> maskedImagePixelAccessor(maskedImage);
 		mitk::ImagePixelReadAccessor<short, 3> imagePixelAccessor(image);
 		int imageXLength = image->GetDimension(0);
 		int imageYLength = image->GetDimension(1);
 		int imageZLength = image->GetDimension(2);
 		itk::Index<3> index;
 
 		for (int x = 0; x < imageXLength; x++)
 		{
 			for (int y = 0; y < imageYLength; y++)
 			{
 				for (int z = 0; z < imageZLength; z++)
 				{
 					index[0] = x;
 					index[1] = y;
 					index[2] = z;
 					if (imagePixelAccessor.GetPixelByIndex(index) >= pixelValueMask)
 					{
 						maskedImagePixelAccessor.SetPixelByIndex(index, 0);
 					}
 				}
 			}
 		}
 
 		// Create a new data tree node
 		//
 		mitk::DataNode::Pointer maskedImageNode = mitk::DataNode::New();
 		//
 		// fill the data tree node with the appropriate information
 		//
 		maskedImageNode->SetData(maskedImage);
 		maskedImageNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
 		maskedImageNode->SetProperty("opacity", mitk::FloatProperty::New(1));
 		//
 		// add the node to the ds
 		//
 		this->GetDataStorage()->Add(maskedImageNode);
 	}
 
 }
\ No newline at end of file