mlITKFilterSupport.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
// Include dll-specific settings.
#include "mlInitSystemITKSupport.h"
 
#include "mlITKSupportToolFunctions.h"
 
ML_START_NAMESPACE
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
inline void testFunc_processDataWithITKFilterAndFillOutSubImg() {}
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <typename FILTER_TYPE, typename OIMAGE_TYPE>
bool processDataWithITKFilterAndFillOutSubImg(typename FILTER_TYPE::Pointer &filterPointer, 
                                              int                           outIndex, 
                                              MLint                         usedFilteringDim, 
                                              const ImageVector             &shift,
                                              const SubImageBox             &outImgBox,
                                              SubImage                      &outSubImg, 
                                              Module                        &module)
{
  // Test and debug function call.
  testFunc_processDataWithITKFilterAndFillOutSubImg();
 
  bool okay=true;
  if ((outIndex <0) || (usedFilteringDim < 0)){
    okay = false;
  }
  else{
    try {
  
      // Get filter output.
      typename OIMAGE_TYPE::Pointer filterOutput = filterPointer->GetOutput(static_cast<unsigned int>(outIndex));
  
      // Be sure that extent of output page does not reach outside the output image 
      // to avoid that undefined regions are requested. In contrast to the ML ITK 
      // does not permit that.
      SubImageBox outBox(outSubImg.getBox().intersect(outImgBox));
  
      // Shift the valid image region which is to be calculated to ITK coordinates.
      outBox.translate(shift);
  
      // Set region to be calculated.
      typename OIMAGE_TYPE::RegionType itkOutBox = ITKRegionFromMLSubImgBox<OIMAGE_TYPE>(outBox);
      filterOutput->SetRequestedRegion(itkOutBox);
  
      // Process requested output region image buffer.
      filterPointer->Update();
  
      // Get output image of the filter and pointer to its data.
      typename OIMAGE_TYPE::PixelType* dataPtr = filterOutput->GetBufferPointer();
  
      // Get region of output image and build an ML SubImageBox from it.
      SubImageBox outSubImgBox = MLSubImgBoxFromITKRegion<OIMAGE_TYPE>(filterOutput->GetBufferedRegion());
  
      // Shift processed ITK output region to ML coordinates.
      outSubImgBox.translate(-shift);
  
      // Here we need to correct the position of the outSubimgBox in the case that 
      // we have images which are higher dimensional than the dimension of the 
      // compiled ITK filter. We need to place the box at the original high dimensional
      // position to be able to copy it back to the output subimage box.
      for (MLint d=usedFilteringDim; d<6; ++d){
        // Cast down to avoid huge amounts of warnings in derived codes.
        const size_t sizeTDimIdx = static_cast<size_t>(d);
        
        // Copy higher dimensional components of both corners from outBox.
        // This will probably not work if filters project to lower dimensions,
        // which, however, is not supported in other code fragments either.
        outSubImgBox.v1[sizeTDimIdx] = outBox.v1[sizeTDimIdx];
        outSubImgBox.v2[sizeTDimIdx] = outBox.v2[sizeTDimIdx];
      }
 
      // Convert and copy the ITK buffer to the ML subimage.
      copyITKDataBufferToMLSubImg(dataPtr, sizeof(ITKML_TYPENAME OIMAGE_TYPE::PixelType), outSubImgBox, outSubImg);
    }
    catch( itk::ExceptionObject & e ){
      // Handle error.
      postITKException(e, &module, ML_ERROR, "Leaving output subimage unprocessed.");
      okay=false;
    }
  }
  return okay;
}
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
inline void testFunc_determineImageFilterInRegionTN() {}
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <typename FILTER_TYPE, typename IN_IMAGE_TYPE>
SubImageBox determineImageFilterInRegionTN(typename FILTER_TYPE::Pointer &filterPointer,
                                           Module                        &module, 
                                           MLint                          inIndex, 
                                           const SubImageBox             &outBox, 
                                           MLint                          outIndex,
                                           MLint                          numActiveInputs)
{      
  // Test and debug function call.
  testFunc_determineImageFilterInRegionTN();
 
  // Check for active input - on inactive inputs we simply return an empty box,
  // because there data requests do not make sense.
  if ((outIndex < 0) || (inIndex < 0) || (inIndex >= numActiveInputs)){
    return SubImageBox();
  }
 
  if(!filterPointer){
    MLPrintAndNotify(ML_ERROR, "ML_","", "ITK Filter is NULL.",
                     "", "Returning empty box",                                               
                     __FILE__, __LINE__, ML_UNKNOWN_EXCEPTION);  
    return SubImageBox();    
  }
 
  // For each input get input image region as box. All other are left empty.
  // Get outBox as ITK region object.
  typename IN_IMAGE_TYPE::RegionType region =
    ITKRegionFromMLSubImgBox<IN_IMAGE_TYPE>(outBox);
 
  // Convert boxes to ITK boxes and pass them to the filter.
  for (MLint inps=0; inps < numActiveInputs; ++inps){
    // Get input image extents as ITK region object.
    typename IN_IMAGE_TYPE::RegionType largestPossibleRegion = 
      ITKRegionFromMLSubImgBox<IN_IMAGE_TYPE>(module.getInputImage(inps)->getBoxFromImageExtent());    
 
    // Create a filter object, set input image extents.
    typename IN_IMAGE_TYPE::Pointer m_Image = IN_IMAGE_TYPE::New();  
    m_Image->SetRegions(largestPossibleRegion); 
    filterPointer->SetInput(static_cast<unsigned int>(inps), m_Image);
  }
 
  // Set requested region at output, and ask for the input 
  // region which is needed by the filter.
  try{
    const unsigned int uOutIdx = static_cast<unsigned int>(outIndex); 
    filterPointer->GetOutput(uOutIdx)->SetRequestedRegion(region); 
    filterPointer->GetOutput(uOutIdx)->UpdateOutputInformation();  
    filterPointer->GetOutput(uOutIdx)->PropagateRequestedRegion(); 
    typename IN_IMAGE_TYPE::RegionType inReg = 
        filterPointer->GetInput(static_cast<unsigned int>(inIndex))->GetRequestedRegion();  
    SubImageBox retRegion = MLSubImgBoxFromITKRegion<IN_IMAGE_TYPE>(inReg);
    return retRegion;
  }       
  catch( itk::ExceptionObject & e )          
   {
     postITKException(e, &module, ML_ERROR);
     return SubImageBox(); /* Return empty box in case of error. */  
   }        
}         
 
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
inline void testFunc_determineImageFilterOutImageRegionT0() {}
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <typename FILTER_TYPE, typename OUT_IMAGE_TYPE>
SubImageBox determineImageFilterOutImageRegionT0(typename FILTER_TYPE::Pointer &filterPointer,
                                                 Module &module)
{   
  // Test and debug function call.
  testFunc_determineImageFilterOutImageRegionT0();
 
  if (!filterPointer){ return SubImageBox(); } 
    
  /* Define a dummy region of one voxel. */                                   
  typename OUT_IMAGE_TYPE::RegionType region =                                  
    ITKRegionFromMLSubImgBox<OUT_IMAGE_TYPE>(SubImageBox(ImageVector(0), ImageVector(0)));  
    
  try{ 
    /* Propagate a dummy region through filter to update output infos */      
    /* correctly. It seems not to work for all filters without setting */     
    /* and propagating such a dummy region. */                                
    filterPointer->GetOutput()->SetRequestedRegion(region);     
    filterPointer->GetOutput()->UpdateOutputInformation();      
    filterPointer->GetOutput()->PropagateRequestedRegion();     
    
    /* Now filter regions are updated, get the largest possible region. */    
    typename OUT_IMAGE_TYPE::RegionType outRegion =                             
      filterPointer->GetOutput()->GetLargestPossibleRegion();   
    
    /* Return output image extent defined by largest possible region. */      
    SubImageBox retRegion = MLSubImgBoxFromITKRegion<OUT_IMAGE_TYPE>(outRegion);
    return retRegion;
  }
  catch( itk::ExceptionObject & e )                                           
  { 
    postITKException(e, &module, ML_ERROR, "Setting empty output image region"); 
    return SubImageBox(); /* Return empty box in case of error. */              
  }
}  
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
inline void testFunc_determineImageFilterOutImageRegionTN() {}
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <typename FILTER_TYPE, typename OUT_IMAGE_TYPE, typename IN_IMAGE_TYPE>
SubImageBox determineImageFilterOutImageRegionTN(typename FILTER_TYPE::Pointer &filterPointer,
                                                 Module &module,
                                                 int numImageInputs)                             
{   
  // Test and debug function call.
  testFunc_determineImageFilterOutImageRegionTN();
 
  if (!filterPointer){ return SubImageBox(); } 
 
  /* Define a dummy region of one voxel. */                                   
  typename OUT_IMAGE_TYPE::RegionType region =                                  
    ITKRegionFromMLSubImgBox<OUT_IMAGE_TYPE>(SubImageBox(ImageVector(0), ImageVector(0)));  
    
  /* Create and set a dummy ITK input images. */                              
  for (int inps=0; inps < numImageInputs; ++inps){
 
    /* Get input image extents as ITK region object. */                       
    SubImageBox inSubImgBox(module.getInputImage(inps)->getImageExtent());  
    typename IN_IMAGE_TYPE::RegionType largestPossibleRegion =                  
      ITKRegionFromMLSubImgBox<IN_IMAGE_TYPE>(inSubImgBox);
 
    /* Set a dummy ITK image with extents of input image as input. */         
    typename IN_IMAGE_TYPE::Pointer m_Image = IN_IMAGE_TYPE::New();    
    try{   
      m_Image->SetRegions(largestPossibleRegion); 
      filterPointer->SetInput(static_cast<unsigned int>(inps), m_Image);    
    }
    catch( itk::ExceptionObject & e )                                         
    {  
      postITKException(e, &module, ML_ERROR, "Setting empty output image region");\
      return SubImageBox(); /* Return empty box in case of error. */            
    }
  }
 
  try{ 
    /* Propagate a dummy region through filter to update output infos */      
    /* correctly. It seems not to work for all filters without setting */     
    /* and propagating such a dummy region. */                                
    filterPointer->GetOutput()->SetRequestedRegion(region);     
    filterPointer->GetOutput()->UpdateOutputInformation();      
    filterPointer->GetOutput()->PropagateRequestedRegion();     
    
    /* Now filter regions are updated, get the largest possible region. */    
    typename OUT_IMAGE_TYPE::RegionType outRegion =                             
      filterPointer->GetOutput()->GetLargestPossibleRegion();   
    
    /* Return output image extent defined by largest possible region. */
    SubImageBox retRegion = MLSubImgBoxFromITKRegion<OUT_IMAGE_TYPE>(outRegion);
    return retRegion;
  }
  catch( itk::ExceptionObject & e )                                           
  { 
    postITKException(e, &module, ML_ERROR, "Setting empty output image region"); 
    return SubImageBox(); /* Return empty box in case of error. */              
  }
}  
 
ML_END_NAMESPACE