diff --git a/Modules/OpenCL/mitkOclDataSet.cpp b/Modules/OpenCL/mitkOclDataSet.cpp
index 269a2d01d3..953c0d68b1 100644
--- a/Modules/OpenCL/mitkOclDataSet.cpp
+++ b/Modules/OpenCL/mitkOclDataSet.cpp
@@ -1,174 +1,176 @@
 /*===================================================================
 
 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 "mitkOclDataSet.h"
 #include "mitkCommon.h"
 #include "mitkLogMacros.h"
 
 #include "mitkOclUtils.h"
 
 #include <fstream>
 
+//#define SHOW_MEM_INFO
+
 mitk::OclDataSet::OclDataSet() : m_gpuBuffer(nullptr), m_context(nullptr), m_bufferSize(0), m_gpuModified(false), m_cpuModified(false),
   m_Data(nullptr), m_BpE(1)
 {
 }
 
 mitk::OclDataSet::~OclDataSet()
 {
   MITK_DEBUG << "OclDataSet Destructor";
 
   //release GMEM Image buffer
   if (m_gpuBuffer) clReleaseMemObject(m_gpuBuffer);
 }
 
 
 cl_mem mitk::OclDataSet::CreateGPUBuffer()
 {
   MITK_DEBUG << "InitializeGPUBuffer call with: BPE=" << m_BpE;
 
   us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
   m_context = resources->GetContext();
 
   int clErr;
   if (m_gpuBuffer) clReleaseMemObject(m_gpuBuffer);
 
   m_gpuBuffer = clCreateBuffer(m_context, CL_MEM_READ_WRITE, m_bufferSize * (size_t)m_BpE, nullptr, &clErr);
 
-  MITK_DEBUG << "Created GPU Buffer Object of size: " << (size_t)m_BpE * m_bufferSize << " Bytes";
+  #ifdef SHOW_MEM_INFO
+  MITK_INFO << "Created GPU Buffer Object of size: " << (size_t)m_BpE * m_bufferSize << " Bytes";
+  #endif
 
   CHECK_OCL_ERR(clErr);
 
   if (clErr != CL_SUCCESS)
     mitkThrow() << "openCL Error when creating Buffer";
 
   return m_gpuBuffer;
 }
 
 bool mitk::OclDataSet::IsModified(int _type)
 {
   if (_type) return m_cpuModified;
   else return m_gpuModified;
 }
 
 void mitk::OclDataSet::Modified(int _type)
 {
   // defines... GPU: 0, CPU: 1
   m_cpuModified = _type;
   m_gpuModified = !_type;
 }
 
 int mitk::OclDataSet::TransferDataToGPU(cl_command_queue gpuComQueue)
 {
   cl_int clErr = 0;
 
   // check whether an image present
   if (m_Data == nullptr){
     MITK_ERROR("ocl.DataSet") << "(mitk) No data present!\n";
     return -1;
   }
 
   // there is a need for copy only if RAM-Data newer then GMEM data
   if (m_cpuModified)
   {
     //check the buffer
     if(m_gpuBuffer == nullptr)
     {
       CreateGPUBuffer();
     }
 
     if (m_gpuBuffer != nullptr)
     {
       clErr = clEnqueueWriteBuffer(gpuComQueue, m_gpuBuffer, CL_TRUE, 0, m_bufferSize * (size_t)m_BpE, m_Data, 0, NULL, NULL);
       MITK_DEBUG << "Wrote Data to GPU Buffer Object.";
 
       CHECK_OCL_ERR(clErr);
       m_gpuModified = true;
 
       if (clErr != CL_SUCCESS)
         mitkThrow() << "openCL Error when writing Buffer";
     }
     else
     {
       MITK_ERROR << "No GPU buffer present!";
     }
   }
 
   return clErr;
 }
 
 cl_mem mitk::OclDataSet::GetGPUBuffer()
 {
-  // clGetMemObjectInfo()
-  cl_mem_object_type memInfo;
-
   // query image object info only if already initialized
   if( this->m_gpuBuffer )
   {
-    #ifdef MBILOG_ENABLE_DEBUG
+    #ifdef SHOW_MEM_INFO
     cl_int clErr = 0;
+    // clGetMemObjectInfo()
+    cl_mem_object_type memInfo;
     clErr = clGetMemObjectInfo(this->m_gpuBuffer, CL_MEM_TYPE, sizeof(cl_mem_object_type), &memInfo, nullptr );
     CHECK_OCL_ERR(clErr);
+    MITK_DEBUG << "Querying info for object, recieving: " << memInfo;
     #endif
   }
 
-  MITK_DEBUG << "Querying info for object, recieving: " << memInfo;
-
   return m_gpuBuffer;
 }
 
 void* mitk::OclDataSet::TransferDataToCPU(cl_command_queue gpuComQueue)
 {
   cl_int clErr = 0;
 
   // if image created on GPU, needs to create mitk::Image
   if( m_gpuBuffer == nullptr ){
     MITK_ERROR("ocl.DataSet") << "(mitk) No buffer present!\n";
     return nullptr;
   }
 
   // check buffersize
   char* data = new char[m_bufferSize * (size_t)m_BpE];
 
   // debug info
-  #ifdef MBILOG_ENABLE_DEBUG
+  #ifdef SHOW_MEM_INFO
   oclPrintMemObjectInfo( m_gpuBuffer );
   #endif
 
   clErr = clEnqueueReadBuffer( gpuComQueue, m_gpuBuffer, CL_TRUE, 0, m_bufferSize * (size_t)m_BpE, data ,0, nullptr, nullptr);
   CHECK_OCL_ERR(clErr);
 
   if(clErr != CL_SUCCESS)
     mitkThrow() << "openCL Error when reading Output Buffer";
 
   clFlush( gpuComQueue );
   // the cpu data is same as gpu
   this->m_gpuModified = false;
 
   return (void*) data;
 }
 
 void mitk::OclDataSet::SetBufferSize(size_t size)
 {
   m_bufferSize = size;
 }
 
 void mitk::OclDataSet::SetBpE(unsigned short BpE)
 {
   m_BpE = BpE;
 }
diff --git a/Modules/OpenCL/mitkOclFilter.cpp b/Modules/OpenCL/mitkOclFilter.cpp
index 181567e2ed..7965a24484 100644
--- a/Modules/OpenCL/mitkOclFilter.cpp
+++ b/Modules/OpenCL/mitkOclFilter.cpp
@@ -1,299 +1,347 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //Ocl
 #include "mitkOclFilter.h"
 #include "mitkOclUtils.h"
 #include "mitkOpenCLActivator.h"
 
 //Mitk
 #include <mitkLogMacros.h>
 #include <mitkConfig.h>
 
 //usService
 #include "usServiceReference.h"
 #include <usServiceRegistration.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 mitk::OclFilter::OclFilter()
   : m_ClCompilerFlags(""),
     m_ClProgram(nullptr),
     m_CommandQue(nullptr),
     m_FilterID("mitkOclFilter"),
     m_Preambel(" "),
     m_Initialized(false)
 {
 }
 
 mitk::OclFilter::OclFilter(const char* filename)
   : m_ClCompilerFlags(""),
     m_ClProgram(nullptr),
     m_CommandQue(nullptr),
     m_FilterID(filename),
     m_Preambel(" "),
     m_Initialized(false)
 {
   m_ClFiles.push_back(filename);
 }
 
 mitk::OclFilter::~OclFilter()
 {
   MITK_DEBUG << "OclFilter Destructor";
 
   // release program
   if (m_ClProgram)
   {
     us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
     OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
     // remove program from storage
     resources->RemoveProgram(m_FilterID);
   }
 }
 
 bool mitk::OclFilter::ExecuteKernel( cl_kernel kernel, unsigned int workSizeDim )
 {
   cl_int clErr = 0;
 
   clErr = clEnqueueNDRangeKernel( this->m_CommandQue, kernel, workSizeDim,
                                   nullptr, this->m_GlobalWorkSize, m_LocalWorkSize, 0, nullptr, nullptr);
 
   CHECK_OCL_ERR( clErr );
 
   return ( clErr == CL_SUCCESS );
 }
 
+#include <thread>
+
 bool mitk::OclFilter::ExecuteKernelChunks( cl_kernel kernel, unsigned int workSizeDim, size_t* chunksDim )
 {
   size_t offset[3] ={0, 0, 0};
   cl_int clErr = 0;
 
-  unsigned int currentChunk = 0;
-  cl_event* waitFor = new cl_event[16];
-
   if(workSizeDim == 2)
   {
     for(offset[0] = 0; offset[0] < m_GlobalWorkSize[0]; offset[0] += chunksDim[0])
     {
       for(offset[1] = 0; offset[1] < m_GlobalWorkSize[1]; offset[1] += chunksDim[1])
       {
-        if (currentChunk % 16 == 0 && currentChunk != 0)
+        clErr |= clEnqueueNDRangeKernel(this->m_CommandQue, kernel, workSizeDim,
+          offset, chunksDim, m_LocalWorkSize, 0, nullptr, nullptr);
+      }
+    }
+  }
+  else if(workSizeDim == 3)
+  {
+    for(offset[0] = 0; offset[0] < m_GlobalWorkSize[0]; offset[0] += chunksDim[0])
+    {
+      for(offset[1] = 0; offset[1] < m_GlobalWorkSize[1]; offset[1] += chunksDim[1])
+      {
+        for(offset[2] = 0; offset[2] < m_GlobalWorkSize[2]; offset[2] += chunksDim[2])
         {
-          clWaitForEvents(16, &waitFor[0]);
+          clErr |= clEnqueueNDRangeKernel( this->m_CommandQue, kernel, workSizeDim,
+                                          offset, chunksDim, m_LocalWorkSize, 0, nullptr, nullptr);
+        }
+      }
+    }
+  }
+
+  CHECK_OCL_ERR(clErr);
+
+  return ( clErr == CL_SUCCESS );
+}
+
+bool mitk::OclFilter::ExecuteKernelChunksInBatches(cl_kernel kernel, unsigned int workSizeDim, size_t* chunksDim, size_t batchSize, int waitTimems)
+{
+  size_t offset[3] = { 0, 0, 0 };
+  cl_int clErr = 0;
+
+  unsigned int currentChunk = 0;
+  cl_event* waitFor = new cl_event[batchSize];
+
+  if (workSizeDim == 2)
+  {
+    for (offset[0] = 0; offset[0] < m_GlobalWorkSize[0]; offset[0] += chunksDim[0])
+    {
+      for (offset[1] = 0; offset[1] < m_GlobalWorkSize[1]; offset[1] += chunksDim[1])
+      {
+        if (currentChunk % batchSize == 0 && currentChunk != 0)
+        {
+          clWaitForEvents(batchSize, &waitFor[0]);
+          std::this_thread::sleep_for(std::chrono::milliseconds(waitTimems));
           clErr |= clEnqueueNDRangeKernel(this->m_CommandQue, kernel, workSizeDim,
             offset, chunksDim, m_LocalWorkSize, 0, nullptr, &waitFor[0]);
         }
         else
         {
           clErr |= clEnqueueNDRangeKernel(this->m_CommandQue, kernel, workSizeDim,
-            offset, chunksDim, m_LocalWorkSize, 0, nullptr, &waitFor[currentChunk%16]);
+            offset, chunksDim, m_LocalWorkSize, 0, nullptr, &waitFor[currentChunk % batchSize]);
         }
         currentChunk++;
-        //clErr |= clEnqueueNDRangeKernel(this->m_CommandQue, kernel, workSizeDim,
-         // offset, chunksDim, m_LocalWorkSize, 0, nullptr, nullptr);
       }
     }
   }
-  else if(workSizeDim == 3)
+  else if (workSizeDim == 3)
   {
-    for(offset[0] = 0; offset[0] < m_GlobalWorkSize[0]; offset[0] += chunksDim[0])
+    for (offset[0] = 0; offset[0] < m_GlobalWorkSize[0]; offset[0] += chunksDim[0])
     {
-      for(offset[1] = 0; offset[1] < m_GlobalWorkSize[1]; offset[1] += chunksDim[1])
+      for (offset[1] = 0; offset[1] < m_GlobalWorkSize[1]; offset[1] += chunksDim[1])
       {
-        for(offset[2] = 0; offset[2] < m_GlobalWorkSize[2]; offset[2] += chunksDim[2])
+        for (offset[2] = 0; offset[2] < m_GlobalWorkSize[2]; offset[2] += chunksDim[2])
         {
-          clErr |= clEnqueueNDRangeKernel( this->m_CommandQue, kernel, workSizeDim,
-                                          offset, chunksDim, m_LocalWorkSize, 0, nullptr, nullptr);
+          if (currentChunk % batchSize == 0 && currentChunk != 0)
+          {
+            clWaitForEvents(batchSize, &waitFor[0]);
+            std::this_thread::sleep_for(std::chrono::milliseconds(waitTimems));
+            clErr |= clEnqueueNDRangeKernel(this->m_CommandQue, kernel, workSizeDim,
+              offset, chunksDim, m_LocalWorkSize, 0, nullptr, &waitFor[0]);
+          }
+          else
+          {
+            clErr |= clEnqueueNDRangeKernel(this->m_CommandQue, kernel, workSizeDim,
+              offset, chunksDim, m_LocalWorkSize, 0, nullptr, &waitFor[currentChunk % batchSize]);
+          }
+          currentChunk++;
         }
       }
     }
   }
 
   CHECK_OCL_ERR(clErr);
 
-  return ( clErr == CL_SUCCESS );
+  return (clErr == CL_SUCCESS);
 }
 
 
 bool mitk::OclFilter::Initialize()
 {
   us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
   m_CommandQue = resources->GetCommandQueue();
 
   cl_int clErr = 0;
   m_Initialized = CHECK_OCL_ERR(clErr);
 
   if ( m_ClFiles.empty())
   {
     MITK_ERROR<<"No OpenCL Source FILE specified";
     return false;
   }
 
   if (m_ClProgram == nullptr)
   {
     try
     {
       this->m_ClProgram = resources->GetProgram( this->m_FilterID );
     }
     catch(const mitk::Exception& e)
     {
       MITK_INFO << "Program not stored in resource manager, compiling. " << e;
       this->CompileSource();
     }
   }
 
   return m_Initialized;
 }
 
 void mitk::OclFilter::LoadSourceFiles(CStringList &sourceCode, ClSizeList &sourceCodeSize)
 {
   for( CStringList::iterator it = m_ClFiles.begin(); it != m_ClFiles.end(); ++it )
   {
     MITK_DEBUG << "Load file :" << *it;
     us::ModuleResource mdr = GetModule()->GetResource(*it);
 
     if( !mdr.IsValid() )
       MITK_WARN << "Could not load resource: " << mdr.GetName() << " is invalid!";
 
     us::ModuleResourceStream rss(mdr);
 
     // read resource file to a string
     std::istreambuf_iterator<char> eos;
     std::string source(std::istreambuf_iterator<char>(rss), eos);
 
     // add preambel and build up string to compile
     std::string src(m_Preambel);
     src.append("\n");
     src.append(source);
 
     // allocate new char buffer
     char* tmp = new char[src.size() + 1];
     strcpy(tmp,src.c_str());
 
     // add source to list
     sourceCode.push_back((const char*)tmp);
     sourceCodeSize.push_back(src.size());
   }
 }
 
 void mitk::OclFilter::CompileSource()
 {
   // helper variable
   int clErr = 0;
   CStringList sourceCode;
   ClSizeList sourceCodeSize;
 
   if (m_ClFiles.empty())
   {
     MITK_ERROR("ocl.filter") << "No shader source file was set";
     return;
   }
 
   //get a valid opencl context
   us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
   cl_context gpuContext = resources->GetContext();
   // load the program source from file
   LoadSourceFiles(sourceCode, sourceCodeSize);
 
   if ( !sourceCode.empty() )
   {
     // create program from all files in the file list
     m_ClProgram = clCreateProgramWithSource(gpuContext, sourceCode.size(), &sourceCode[0], &sourceCodeSize[0], &clErr);
     CHECK_OCL_ERR(clErr);
 
     // build the source code
     MITK_DEBUG << "Building Program Source";
     std::string compilerOptions = "";
     compilerOptions.append(m_ClCompilerFlags);
 
     MITK_DEBUG("ocl.filter") << "cl compiler flags: " << compilerOptions.c_str();
 
     clErr = clBuildProgram(m_ClProgram, 0, nullptr, compilerOptions.c_str(), nullptr, nullptr);
     CHECK_OCL_ERR(clErr);
 
     // if OpenCL Source build failed
     if (clErr != CL_SUCCESS)
     {
       MITK_ERROR("ocl.filter") << "Failed to build source";
       oclLogBuildInfo(m_ClProgram, resources->GetCurrentDevice() );
       oclLogBinary(m_ClProgram, resources->GetCurrentDevice() );
       m_Initialized = false;
     }
 
     // store the succesfully build program into the program storage provided by the resource service
     resources->InsertProgram(m_ClProgram, m_FilterID, true);
 
     // free the char buffers with the source code
     for( CStringList::iterator it = sourceCode.begin(); it != sourceCode.end(); ++it )
     {
       delete[] *it;
     }
   }
   else
   {
     MITK_ERROR("ocl.filter") << "Could not load from source";
     m_Initialized = false;
   }
 }
 
 void mitk::OclFilter::SetWorkingSize(unsigned int locx, unsigned int dimx, unsigned int locy, unsigned int dimy, unsigned int locz, unsigned int dimz)
 {
   // set the local work size
   this->m_LocalWorkSize[0] = locx;
   this->m_LocalWorkSize[1] = locy;
   this->m_LocalWorkSize[2] = locz;
 
   this->m_GlobalWorkSize[0] = dimx;
   this->m_GlobalWorkSize[1] = dimy;
   this->m_GlobalWorkSize[2] = dimz;
 
   // estimate the global work size
   this->m_GlobalWorkSize[0] = iDivUp( dimx, this->m_LocalWorkSize[0]) * this->m_LocalWorkSize[0];
 
   if ( dimy > 1)
     this->m_GlobalWorkSize[1] = iDivUp( dimy, this->m_LocalWorkSize[1]) * this->m_LocalWorkSize[1];
   if( dimz > 1 )
     this->m_GlobalWorkSize[2] = iDivUp( dimz, this->m_LocalWorkSize[2]) * this->m_LocalWorkSize[2];
 }
 
 void mitk::OclFilter::SetSourcePreambel(const char* preambel)
 {
   this->m_Preambel = preambel;
 }
 
 void mitk::OclFilter::AddSourceFile(const char* filename)
 {
   m_ClFiles.push_back(filename);
 }
 
 void mitk::OclFilter::SetCompilerFlags(const char* flags)
 {
   m_ClCompilerFlags = flags;
 }
 
 
 bool mitk::OclFilter::IsInitialized()
 {
   return m_Initialized;
 }
diff --git a/Modules/OpenCL/mitkOclFilter.h b/Modules/OpenCL/mitkOclFilter.h
index ba3705a466..41fcaa8b0f 100644
--- a/Modules/OpenCL/mitkOclFilter.h
+++ b/Modules/OpenCL/mitkOclFilter.h
@@ -1,153 +1,157 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #ifndef __mitkOclFilter_h
 #define __mitkOclFilter_h
 
 #include "mitkOclUtils.h"
 #include "mitkCommon.h"
 
 #include <vector>
 #include <usModule.h>
 
 #include <MitkOpenCLExports.h>
 
 namespace mitk
 {
 /**
    @class OclFilter
    @brief Superclass for all OpenCL based filter.
 
    This class takes care of loading and compiling the external GPU program code.
   */
 class MITKOPENCL_EXPORT OclFilter
 {
 public:
   /**
     * @brief Add a source file from the resource files to the
     *        OpenCL shader file list. Multiple files can be added to the list.
     *
     *  @param name of the file in the resource system
     */
     void AddSourceFile(const char* filename);
 
   /**
     * @brief Set specific compilerflags to compile the CL source. Default is set to nullptr;
     *        example: "-cl-fast-relaxed-math -cl-mad-enable -cl-strict-aliasing"
     *
     *  @param flags to the modulefolder that contains the gpuSource
     */
   void SetCompilerFlags(const char* flags);
 
   /**
     * @brief Returns true if the initialization was successfull
     */
   virtual bool IsInitialized();
 
   /** @brief Destructor */
   virtual ~OclFilter();
 
 protected:
 
   typedef std::vector<const char*> CStringList;
   typedef std::vector<size_t> ClSizeList;
 
   /** @brief Constructor */
   OclFilter();
 
   /** @brief Constructor ( overloaded ) */
   OclFilter(const char* filename);
 
   /** @brief String that contains the compiler flags */
   const char* m_ClCompilerFlags;
 
   /** @brief The compiled OpenCL program */
   cl_program m_ClProgram;
 
   /** @brief Command queue for the filter */
   cl_command_queue m_CommandQue;
 
   /** @brief Unique ID of the filter, needs to be specified in the constructor of the derived class */
   std::string m_FilterID;
 
   /*! @brief source preambel for e.g. #define commands to be inserted into the OpenCL source */
   const char* m_Preambel;
 
   /** @brief List of sourcefiles that will be compiled for this filter.*/
   CStringList m_ClFiles;
 
   /** @brief  status of the filter */
   bool m_Initialized;
 
   /** @brief The local work size fo the filter */
   size_t m_LocalWorkSize[3];
 
   /** @brief The global work size of the filter */
   size_t m_GlobalWorkSize[3];
 
   /** @brief Set the working size for the following OpenCL kernel call */
   void SetWorkingSize(unsigned int locx, unsigned int dimx,
                       unsigned int locy = 1, unsigned int dimy = 1,
                       unsigned int locz = 1, unsigned int dimz = 1);
 
   /** @brief Execute the given kernel on the OpenCL Index-Space defined by the local and global work sizes
       */
   bool ExecuteKernel( cl_kernel kernel, unsigned int workSizeDim );
 
   /** @brief Execute the given kernel on the OpenCL Index-Space defined by the local and global work sizes, but divide it into chunks of dimension chunksDim
       */
   bool ExecuteKernelChunks( cl_kernel kernel, unsigned int workSizeDim, size_t* chunksDim );
 
+  /** @brief Execute the given kernel on the OpenCL Index-Space defined by the local and global work sizes, but divide it into chunks of dimension chunksDim and wait between 
+    * batches of batchSize chunks a time of waitTimems milliseconds
+  */
+  bool ExecuteKernelChunksInBatches(cl_kernel kernel, unsigned int workSizeDim, size_t* chunksDim, size_t batchSize, int waitTimems);
   /**
       * \brief Initialize all necessary parts of the filter
       *
       * The Initialize() method creates the command queue and the m_clProgram.
       * The program is either compiled from the given source or taken from the
       * OclResourceManager if the program was compiled already.
       */
   bool Initialize();
 
   /**
     * @brief Compile the program source
     *
     * @param preambel e.g. defines for the shader code
     */
   void CompileSource();
 
   /**
       * @brief Add some source code on the beginning of the loaded source
       *
       * In this way, some preprocessor flags for the CL compiler can at the beginning of the filter
       * @param preambel Source preambel for e.g. #define commands to be inserted into the OpenCL source
       */
   void SetSourcePreambel(const char* preambel);
 
   /**
    * @brief Get the Module of the filter. Needs to be implemented by every subclass.
    *        The filter will load the OpenCL sourcefiles from this module context.
    */
   virtual us::Module* GetModule() = 0;
 
   /**
    * @brief Helper functions that load sourcefiles from the module context in the Initialize function.
    * @param SourceCodeList holds the sourcecode for every file as string, the SourceCodeSizeList holst the
    *        size of every file in bytes.
    */
   void LoadSourceFiles(CStringList &SourceCodeList, ClSizeList &SourceCodeSizeList);
 };
 }
 #endif // __mitkOclFilter_h
diff --git a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
index 86f638f4fc..3f741ec1c4 100644
--- a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
@@ -1,259 +1,259 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #if defined(PHOTOACOUSTICS_USE_GPU) || DOXYGEN
 
 #include "./OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.h"
 #include "usServiceReference.h"
 
 mitk::PhotoacousticOCLBeamformingFilter::PhotoacousticOCLBeamformingFilter()
 : m_PixelCalculation( NULL ), m_InputImage(mitk::Image::New()), m_ApodizationBuffer(nullptr), m_MemoryLocationsBuffer(nullptr), m_DelaysBuffer(nullptr), m_UsedLinesBuffer(nullptr)
 {
   this->AddSourceFile("DAS.cl");
   this->AddSourceFile("DMAS.cl");
   this->m_FilterID = "OpenCLBeamformingFilter";
 
   this->Initialize();
 
   unsigned int dim[] = { 128, 2048, 2 };
 
   mitk::Vector3D spacing;
   spacing[0] = 1;
   spacing[1] = 1;
   spacing[2] = 1;
 
   m_InputImage->Initialize(mitk::MakeScalarPixelType<float>(), 3, dim);
   m_InputImage->SetSpacing(spacing);
 
   m_ChunkSize[0] = 128;
   m_ChunkSize[1] = 128;
   m_ChunkSize[2] = 8;
 
   m_UsedLinesCalculation = mitk::OCLUsedLinesCalculation::New();
   m_DelayCalculation = mitk::OCLDelayCalculation::New();
 }
 
 mitk::PhotoacousticOCLBeamformingFilter::~PhotoacousticOCLBeamformingFilter()
 {
   if ( this->m_PixelCalculation )
   {
     clReleaseKernel( m_PixelCalculation );
   }
 
   if (m_ApodizationBuffer) clReleaseMemObject(m_ApodizationBuffer);
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::Update()
 {
   //Check if context & program available
   if (!this->Initialize())
   {
     us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
     OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
     // clean-up also the resources
     resources->InvalidateStorage();
     mitkThrow() <<"Filter is not initialized. Cannot update.";
   }
   else{
     // Execute
     this->Execute();
   }
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::UpdateDataBuffers()
 {
   /*us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
   cl_ulong globalMemSize = oclGetGlobalMemSize(resources->GetCurrentDevice());*/
   //Initialize the Output
 
   try
   {
     MITK_DEBUG << "Updating Workgroup size for new dimensions";
     size_t outputSize = (size_t)m_Conf.ReconstructionLines * (size_t)m_Conf.SamplesPerLine * (size_t)m_Conf.inputDim[2];
     m_OutputDim[0] = m_Conf.ReconstructionLines;
     m_OutputDim[1] = m_Conf.SamplesPerLine;
     m_OutputDim[2] = m_Conf.inputDim[2];
     this->InitExec(this->m_PixelCalculation, m_OutputDim, outputSize, sizeof(float));
   }
   catch (const mitk::Exception& e)
   {
     MITK_ERROR << "Caught exception while initializing filter: " << e.what();
     return;
   }
 
   if (BeamformingSettings::SettingsChangedOpenCL(m_Conf, m_ConfOld))
   {
     cl_int clErr = 0;
     MITK_DEBUG << "Updating GPU Buffers for new configuration";
 
     // create the apodisation buffer
 
     if (m_Apodisation == nullptr)
     {
       MITK_INFO << "No apodisation function set; Beamforming will be done without any apodisation.";
       m_Apodisation = new float[1];
       m_Apodisation[0] = 1;
       m_ApodArraySize = 1;
     }
 
     us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
     OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
     cl_context gpuContext = resources->GetContext();
 
     if (m_ApodizationBuffer) clReleaseMemObject(m_ApodizationBuffer);
 
     this->m_ApodizationBuffer = clCreateBuffer(gpuContext, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * m_ApodArraySize, m_Apodisation, &clErr);
     CHECK_OCL_ERR(clErr);
 
     // calculate used lines
 
     m_UsedLinesCalculation->SetConfig(m_Conf);
     m_UsedLinesCalculation->Update();
     m_UsedLinesBuffer = m_UsedLinesCalculation->GetGPUOutput()->GetGPUBuffer();
 
     // calculate the Delays
 
     m_DelayCalculation->SetConfig(m_Conf);
     m_DelayCalculation->SetInputs(m_UsedLinesBuffer);
     m_DelayCalculation->Update();
 
     m_DelaysBuffer = m_DelayCalculation->GetGPUOutput()->GetGPUBuffer();
 
     m_ConfOld = m_Conf;
   }
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::Execute()
 {
   cl_int clErr = 0;
   UpdateDataBuffers();
 
   clErr = clSetKernelArg(this->m_PixelCalculation, 2, sizeof(cl_mem), &(this->m_UsedLinesBuffer));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 3, sizeof(cl_mem), &(this->m_DelaysBuffer));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 4, sizeof(cl_mem), &(this->m_ApodizationBuffer));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 5, sizeof(cl_ushort), &(this->m_ApodArraySize));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 6, sizeof(cl_uint), &(this->m_Conf.inputDim[0]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 7, sizeof(cl_uint), &(this->m_Conf.inputDim[1]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 8, sizeof(cl_uint), &(this->m_Conf.inputDim[2]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 9, sizeof(cl_uint), &(this->m_Conf.ReconstructionLines));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 10, sizeof(cl_uint), &(this->m_Conf.SamplesPerLine));
 
   // execute the filter on a 3D NDRange
   if (m_OutputDim[2] == 1 || m_ChunkSize[2] == 1)
   {
-    if(!this->ExecuteKernelChunks(m_PixelCalculation, 2, m_ChunkSize))
+    if(!this->ExecuteKernelChunksInBatches(m_PixelCalculation, 2, m_ChunkSize, 16, 50))
       mitkThrow() << "openCL Error when executing Kernel";
   }
   else
   {
-    if(!this->ExecuteKernelChunks(m_PixelCalculation, 3, m_ChunkSize))
+    if(!this->ExecuteKernelChunksInBatches(m_PixelCalculation, 3, m_ChunkSize, 16, 50))
       mitkThrow() << "openCL Error when executing Kernel";
   }
 
   // signalize the GPU-side data changed
   m_Output->Modified( GPU_DATA );
 }
 
 us::Module *mitk::PhotoacousticOCLBeamformingFilter::GetModule()
 {
   return us::GetModuleContext()->GetModule();
 }
 
 bool mitk::PhotoacousticOCLBeamformingFilter::Initialize()
 {
   bool buildErr = true;
   cl_int clErr = 0;
 
   if ( OclFilter::Initialize() )
   {
     switch (m_Conf.Algorithm)
     {
       case BeamformingSettings::BeamformingAlgorithm::DAS:
       {
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDAS", &clErr);
         break;
       }
       case BeamformingSettings::BeamformingAlgorithm::DMAS:
       {
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDMAS", &clErr);
         break;
       }
       default:
       {
         MITK_INFO << "No beamforming algorithm specified, setting to DAS";
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDAS", &clErr);
         break;
       }
     }
     buildErr |= CHECK_OCL_ERR( clErr );
   }
 
   CHECK_OCL_ERR(clErr);
 
   return (OclFilter::IsInitialized() && buildErr );
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::SetInput(mitk::Image::Pointer image)
 {
   OclDataSetToDataSetFilter::SetInput(image);
 
   m_InputImage = image;
   m_Conf.inputDim[0] = m_InputImage->GetDimension(0);
   m_Conf.inputDim[1] = m_InputImage->GetDimension(1);
   m_Conf.inputDim[2] = m_InputImage->GetDimension(2);
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::SetInput(void* data, unsigned int* dimensions, unsigned int BpE)
 {
   OclDataSetToDataSetFilter::SetInput(data, dimensions[0] * dimensions[1] * dimensions[2], BpE);
 
   m_Conf.inputDim[0] = dimensions[0];
   m_Conf.inputDim[1] = dimensions[1];
   m_Conf.inputDim[2] = dimensions[2];
 }
 
 mitk::Image::Pointer mitk::PhotoacousticOCLBeamformingFilter::GetOutputAsImage()
 {
   mitk::Image::Pointer outputImage = mitk::Image::New();
 
   if (m_Output->IsModified(GPU_DATA))
   {
     void* pData = m_Output->TransferDataToCPU(m_CommandQue);
 
     const unsigned int dimension = 3;
     unsigned int dimensions[3] = { (unsigned int)m_OutputDim[0], (unsigned int)m_OutputDim[1], (unsigned int)m_OutputDim[2] };
 
     const mitk::SlicedGeometry3D::Pointer p_slg = m_InputImage->GetSlicedGeometry();
 
     MITK_DEBUG << "Creating new MITK Image.";
 
     outputImage->Initialize(this->GetOutputType(), dimension, dimensions);
     outputImage->SetSpacing(p_slg->GetSpacing());
     outputImage->SetImportVolume(pData, 0, 0, mitk::Image::ImportMemoryManagementType::ManageMemory);
   }
 
   MITK_DEBUG << "Image Initialized.";
 
   return outputImage;
 }
 
 void* mitk::PhotoacousticOCLBeamformingFilter::GetOutput()
 {
   return OclDataSetToDataSetFilter::GetOutput();
 }
 #endif
diff --git a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLDelayCalculation.cpp b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLDelayCalculation.cpp
index fa1ef004bd..53019b8b57 100644
--- a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLDelayCalculation.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLDelayCalculation.cpp
@@ -1,124 +1,124 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define _USE_MATH_DEFINES
 
 #include <cmath>
 #include "./OpenCLFilter/mitkPhotoacousticOCLDelayCalculation.h"
 #include "usServiceReference.h"
 #include "mitkImageReadAccessor.h"
 
 mitk::OCLDelayCalculation::OCLDelayCalculation()
   : m_PixelCalculation(NULL)
 {
   this->AddSourceFile("DelayCalculation.cl");
   this->m_FilterID = "DelayCalculation";
 
   m_ChunkSize[0] = 128;
   m_ChunkSize[1] = 128;
   m_ChunkSize[2] = 8;
 
   this->Initialize();
 }
 
 mitk::OCLDelayCalculation::~OCLDelayCalculation()
 {
   if (this->m_PixelCalculation)
   {
     clReleaseKernel(m_PixelCalculation);
   }
 }
 
 void mitk::OCLDelayCalculation::Update()
 {
   //Check if context & program available
   if (!this->Initialize())
   {
     us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
     OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
     // clean-up also the resources
     resources->InvalidateStorage();
     mitkThrow() << "Filter is not initialized. Cannot update.";
   }
   else {
     // Execute
     this->Execute();
   }
 }
 
 void mitk::OCLDelayCalculation::Execute()
 {
   cl_int clErr = 0;
   
   unsigned int gridDim[3] = { m_Conf.ReconstructionLines / 2, m_Conf.SamplesPerLine, 1 };
   m_BufferSize = gridDim[0] * gridDim[1] * 1;
 
   try
   {
     this->InitExecNoInput(this->m_PixelCalculation, gridDim, m_BufferSize, sizeof(unsigned short));
   }
   catch (const mitk::Exception& e)
   {
     MITK_ERROR << "Caught exception while initializing filter: " << e.what();
     return;
   }
 
   if (m_Conf.DelayCalculationMethod == BeamformingSettings::DelayCalc::QuadApprox)
     m_DelayMultiplicatorRaw = pow(1 / (m_Conf.TimeSpacing*m_Conf.SpeedOfSound) * m_Conf.Pitch * (float)m_Conf.TransducerElements / (float)m_Conf.inputDim[0], 2) / 2;
   else if (m_Conf.DelayCalculationMethod == BeamformingSettings::DelayCalc::Spherical)
     m_DelayMultiplicatorRaw = 1 / (m_Conf.TimeSpacing*m_Conf.SpeedOfSound) * (m_Conf.Pitch*(float)m_Conf.TransducerElements);
 
   m_IsPAImage = m_Conf.isPhotoacousticImage;
   
   clErr = clSetKernelArg(this->m_PixelCalculation, 1, sizeof(cl_mem), &(this->m_UsedLines));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 2, sizeof(cl_uint), &(this->m_Conf.inputDim[0]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 3, sizeof(cl_uint), &(this->m_Conf.inputDim[1]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 4, sizeof(cl_uint), &(this->m_Conf.ReconstructionLines));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 5, sizeof(cl_uint), &(this->m_Conf.SamplesPerLine));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 6, sizeof(cl_char), &(this->m_IsPAImage));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 7, sizeof(cl_float), &(this->m_DelayMultiplicatorRaw));
   
   CHECK_OCL_ERR(clErr);
 
   // execute the filter on a 3D NDRange
-  if (!this->ExecuteKernelChunks(m_PixelCalculation, 2, m_ChunkSize))
+  if (!this->ExecuteKernelChunksInBatches(m_PixelCalculation, 2, m_ChunkSize, 16, 50))
     mitkThrow() << "openCL Error when executing Kernel";
 
   // signalize the GPU-side data changed
   m_Output->Modified(GPU_DATA);
 }
 
 us::Module *mitk::OCLDelayCalculation::GetModule()
 {
   return us::GetModuleContext()->GetModule();
 }
 
 bool mitk::OCLDelayCalculation::Initialize()
 {
   bool buildErr = true;
   cl_int clErr = 0;
 
   if (OclFilter::Initialize())
   {
     if(m_Conf.DelayCalculationMethod == BeamformingSettings::DelayCalc::QuadApprox)
       this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDelayCalculationQuad", &clErr);
     if (m_Conf.DelayCalculationMethod == BeamformingSettings::DelayCalc::Spherical)
       this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDelayCalculationSphe", &clErr);
     buildErr |= CHECK_OCL_ERR(clErr);
   }
   return (OclFilter::IsInitialized() && buildErr);
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLUsedLinesCalculation.cpp b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLUsedLinesCalculation.cpp
index 7a03d85a10..44b26beda3 100644
--- a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLUsedLinesCalculation.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLUsedLinesCalculation.cpp
@@ -1,115 +1,123 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 #if defined(PHOTOACOUSTICS_USE_GPU) || DOXYGEN
 #define _USE_MATH_DEFINES
 
 #include <cmath>
 #include "./OpenCLFilter/mitkPhotoacousticOCLUsedLinesCalculation.h"
 #include "usServiceReference.h"
 #include "mitkImageReadAccessor.h"
 
 mitk::OCLUsedLinesCalculation::OCLUsedLinesCalculation()
   : m_PixelCalculation(NULL)
 {
   this->AddSourceFile("UsedLinesCalculation.cl");
   this->m_FilterID = "UsedLinesCalculation";
 
   m_ChunkSize[0] = 128;
   m_ChunkSize[1] = 128;
   m_ChunkSize[2] = 8;
 
   this->Initialize();
 }
 
 mitk::OCLUsedLinesCalculation::~OCLUsedLinesCalculation()
 {
   if (this->m_PixelCalculation)
   {
     clReleaseKernel(m_PixelCalculation);
   }
 }
 
 void mitk::OCLUsedLinesCalculation::Update()
 {
   //Check if context & program available
   if (!this->Initialize())
   {
     us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
     OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
     // clean-up also the resources
     resources->InvalidateStorage();
     mitkThrow() << "Filter is not initialized. Cannot update.";
   }
   else {
     // Execute
     this->Execute();
   }
 }
 
 void mitk::OCLUsedLinesCalculation::Execute()
 {
   cl_int clErr = 0;
 
   unsigned int gridDim[3] = { m_Conf.ReconstructionLines, m_Conf.SamplesPerLine, 1 };
   size_t outputSize = gridDim[0] * gridDim[1] * 3;
 
   try
   {
     this->InitExecNoInput(this->m_PixelCalculation, gridDim, outputSize, sizeof(unsigned short));
   }
   catch (const mitk::Exception& e)
   {
     MITK_ERROR << "Caught exception while initializing filter: " << e.what();
     return;
   }
 
   m_part = (tan(m_Conf.Angle / 360 * 2 * M_PI) * ((m_Conf.SpeedOfSound * m_Conf.TimeSpacing)) / (m_Conf.Pitch * m_Conf.TransducerElements)) * m_Conf.inputDim[0];
   
   clErr = clSetKernelArg(this->m_PixelCalculation, 1, sizeof(cl_float), &(this->m_part));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 2, sizeof(cl_uint), &(this->m_Conf.inputDim[0]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 3, sizeof(cl_uint), &(this->m_Conf.inputDim[1]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 4, sizeof(cl_uint), &(this->m_Conf.ReconstructionLines));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 5, sizeof(cl_uint), &(this->m_Conf.SamplesPerLine));
 
   CHECK_OCL_ERR(clErr);
 
   // execute the filter on a 2D NDRange
-  if (!this->ExecuteKernelChunks(m_PixelCalculation, 2, m_ChunkSize))
-    mitkThrow() << "openCL Error when executing Kernel";
+  if (m_Conf.inputDim[2] > 2)
+  {
+    if (!this->ExecuteKernelChunksInBatches(m_PixelCalculation, 2, m_ChunkSize, 16, 50))
+      mitkThrow() << "openCL Error when executing Kernel";
+  }
+  else
+  {
+    if (!this->ExecuteKernelChunks(m_PixelCalculation, 2, m_ChunkSize))
+      mitkThrow() << "openCL Error when executing Kernel";
+  }
 
   // signalize the GPU-side data changed
   m_Output->Modified(GPU_DATA);
 }
 
 us::Module *mitk::OCLUsedLinesCalculation::GetModule()
 {
   return us::GetModuleContext()->GetModule();
 }
 
 bool mitk::OCLUsedLinesCalculation::Initialize()
 {
   bool buildErr = true;
   cl_int clErr = 0;
 
   if (OclFilter::Initialize())
   {
     this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckUsedLines", &clErr);
     buildErr |= CHECK_OCL_ERR(clErr);
   }
   return (OclFilter::IsInitialized() && buildErr);
 }
 #endif