mitkToFCompositeFilter.h

Go to the documentation of this file.

/*===================================================================

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 __mitkToFCompositeFilter_h
#define __mitkToFCompositeFilter_h

#include <mitkImage.h>
#include "mitkImageToImageFilter.h"
#include <MitkToFProcessingExports.h>
#include <cv.h>
#include <itkBilateralImageFilter.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);

    virtual void SetInput( Image* distanceImage);

    virtual void SetInput(unsigned int idx,  Image* distanceImage);

    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();
    virtual void GenerateOutputInformation() override;
    virtual 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