mitkToFCompositeFilter.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
#ifndef mitkToFCompositeFilter_h
#define mitkToFCompositeFilter_h
 
#include <mitkImage.h>
#include "mitkImageToImageFilter.h"
#include <MitkToFProcessingExports.h>
#include <itkBilateralImageFilter.h>
#include <opencv2/core/types_c.h>
 
typedef itk::Image<float, 2> ItkImageType2D;
typedef itk::Image<float, 3> ItkImageType3D;
typedef itk::BilateralImageFilter<ItkImageType2D,ItkImageType2D> BilateralFilterType;
 
namespace mitk
{
  class MITKTOFPROCESSING_EXPORT ToFCompositeFilter : public ImageToImageFilter
  {
  public:
 
    mitkClassMacro( ToFCompositeFilter , ImageToImageFilter );
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
    itkSetMacro(SegmentationMask,mitk::Image::Pointer);
    itkSetMacro(ApplyTemporalMedianFilter,bool);
    itkGetConstMacro(ApplyTemporalMedianFilter,bool);
    itkSetMacro(ApplyAverageFilter,bool);
    itkGetConstMacro(ApplyAverageFilter,bool);
    itkSetMacro(ApplyMedianFilter,bool);
    itkGetConstMacro(ApplyMedianFilter,bool);
    itkSetMacro(ApplyThresholdFilter,bool);
    itkGetConstMacro(ApplyThresholdFilter,bool);
    itkSetMacro(ApplyMaskSegmentation,bool);
    itkGetConstMacro(ApplyMaskSegmentation,bool);
    itkSetMacro(ApplyBilateralFilter,bool);
    itkGetConstMacro(ApplyBilateralFilter,bool);
 
    using itk::ProcessObject::SetInput;
 
    void SetInput( const InputImageType* distanceImage) override;
 
    void SetInput(unsigned int idx,  const InputImageType* distanceImage) override;
 
    Image* GetInput();
 
    Image* GetInput(unsigned int idx);
    void SetTemporalMedianFilterParameter(int tmporalMedianFilterNumOfFrames);
    void SetThresholdFilterParameter(int min, int max);
    void SetBilateralFilterParameter(double domainSigma, double rangeSigma, int kernelRadius);
 
  protected:
    ToFCompositeFilter();
    ~ToFCompositeFilter() override;
    void GenerateOutputInformation() override;
    void GenerateData() override;
    void CreateOutputsForAllInputs();
    void ProcessSegmentation(IplImage* inputIplImage);
    ItkImageType2D::Pointer ProcessItkBilateralFilter(ItkImageType2D::Pointer inputItkImage);
    void ProcessCVBilateralFilter(IplImage* inputIplImage, IplImage* outputIplImage);
    void ProcessCVMedianFilter(IplImage* inputIplImage, IplImage* outputIplImage, int radius = 3);
    void ProcessStreamedQuickSelectMedianImageFilter(IplImage* inputIplImage);
    float quick_select(float arr[], int n);
    void CreateItkImage(ItkImageType2D::Pointer &itkInputImage);
 
    mitk::Image::Pointer m_SegmentationMask; 
 
    int m_ImageWidth; 
    int m_ImageHeight; 
    int m_ImageSize; 
 
    IplImage* m_IplDistanceImage; 
    IplImage* m_IplOutputImage; 
 
    ItkImageType2D::Pointer m_ItkInputImage; 
 
    bool m_ApplyTemporalMedianFilter; 
    bool m_ApplyAverageFilter; 
    bool m_ApplyMedianFilter; 
    bool m_ApplyThresholdFilter; 
    bool m_ApplyMaskSegmentation; 
    bool m_ApplyBilateralFilter; 
 
    float** m_DataBuffer; 
    int m_DataBufferCurrentIndex; 
    int m_DataBufferMaxSize; 
 
    int m_TemporalMedianFilterNumOfFrames; 
    int m_ThresholdFilterMin; 
    int m_ThresholdFilterMax; 
    double m_BilateralFilterDomainSigma; 
    double m_BilateralFilterRangeSigma; 
    int m_BilateralFilterKernelRadius; 
 
  };
} //END mitk namespace
#endif