FMEwork/ITK/Sources/ITK/MLITK/ITKSupport/mlITKFilterSupport.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
#ifndef __mlITKFilterSupport_H
#define __mlITKFilterSupport_H

// Include dll-specific settings.
#include "mlInitSystemITKSupport.h"

#ifndef __mlITKSupportToolFunctions_H
#include "mlITKSupportToolFunctions.h"
#endif

ML_START_NAMESPACE

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
inline void testFunc_processDataWithITKFilterAndFillOutSubImg() {}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <typename FILTER_TYPE, typename OIMAGE_TYPE>
bool processDataWithITKFilterAndFillOutSubImg(typename FILTER_TYPE::Pointer &filterPointer, 
                                              int                           outIndex, 
                                              int                           usedFilteringDim, 
                                              const ImageVector             &shift,
                                              const SubImageBox             &outImgBox,
                                              SubImage                      &outSubImg, 
                                              Module                        &module)
{
  ML_TRACE_IN("template processDataWithITKFilterAndFillOutSubImg()");

  // Test and debug function call.
  testFunc_processDataWithITKFilterAndFillOutSubImg();

  bool okay=true;
  try {

    // Get filter output.
    typename OIMAGE_TYPE::Pointer filterOutput = filterPointer->GetOutput(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){
      // 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[d] = outBox.v1[d];
      outSubImgBox.v2[d] = outBox.v2[d];
    }

    // 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)
{      
  ML_TRACE_IN("template determineImageFilterInRegionTN(6 args)");                 

  // Test and debug function call.
  testFunc_determineImageFilterInRegionTN();

  // Check for active input - on inactve inputs we simply return an empty box,
  // because there data requests do not make sense.
  if (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(inps, m_Image);
  }

  // Set requested region at output, and ask for the input 
  // region which is needed by the filter.
  try       
    {
    filterPointer->GetOutput(outIndex)->SetRequestedRegion(region); 
    filterPointer->GetOutput(outIndex)->UpdateOutputInformation();  
    filterPointer->GetOutput(outIndex)->PropagateRequestedRegion(); 
    typename IN_IMAGE_TYPE::RegionType inReg = filterPointer->GetInput(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)
{   
  ML_TRACE_IN("template determineImageFilterOutImageRegionT0()");

  // 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)                             
{   
  ML_TRACE_IN("template determineImageFilterOutImageRegionTN()");

  // 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 (MLint 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(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

#endif