animaNumberedThreadImageToImageFilter.h

Go to the documentation of this file.

#pragma once

#include <itkImageToImageFilter.h>
#include <mutex>
#include <itkVariableLengthVector.h>

namespace anima
{

template <typename TInputImage, typename TOutputImage>
class NumberedThreadImageToImageFilter :
        public itk::ImageToImageFilter < TInputImage, TOutputImage >
{
public:
    typedef NumberedThreadImageToImageFilter Self;
    typedef itk::ImageToImageFilter <TInputImage, TOutputImage> Superclass;
    typedef itk::SmartPointer<Self> Pointer;
    typedef itk::SmartPointer<const Self>  ConstPointer;
    typedef typename itk::ImageSource<TOutputImage>::ThreadStruct ThreadStruct;

    static constexpr unsigned int OutputImageDimension = TOutputImage::ImageDimension;
    typedef typename Superclass::OutputImageRegionType OutputImageRegionType;

    itkNewMacro(Self)

    
    itkTypeMacro(NumberedThreadImageToImageFilter, itk::ImageToImageFilter)

    itkSetMacro(NumberOfPointsToProcess, unsigned int)

    itkSetMacro(ComputationRegion, OutputImageRegionType)
    itkGetMacro(ComputationRegion, OutputImageRegionType)

protected:
    NumberedThreadImageToImageFilter()
    {
        m_NumberOfProcessedPoints = 0;
        m_ComputationRegion.SetSize(0,0);
        m_HighestProcessedSlice = 0;
        m_ProcessedDimension = 0;
    }

    virtual ~NumberedThreadImageToImageFilter() {}

    virtual void GenerateData() ITK_OVERRIDE;
    virtual void BeforeThreadedGenerateData() ITK_OVERRIDE;

    static ITK_THREAD_RETURN_FUNCTION_CALL_CONVENTION ThreaderMultiSplitCallback(void *arg);
    virtual void ThreadProcessSlices();

    unsigned int GetSafeThreadId();
    void SafeReleaseThreadId(unsigned int threadId);

    void IncrementNumberOfProcessedPoints();


    template <typename ScalarRealType>
    void
    InitializeZeroPixel(TOutputImage *image, itk::VariableLengthVector <ScalarRealType> &zeroPixel)
    {
        unsigned int vectorSize = image->GetVectorLength();
        zeroPixel = itk::VariableLengthVector <ScalarRealType> (vectorSize);
        zeroPixel.Fill(0.0);
    }

    template <typename PixelType>
    void
    InitializeZeroPixel(TOutputImage *itkNotUsed(image), PixelType &zeroPixel)
    {
        zeroPixel = itk::NumericTraits <PixelType>::ZeroValue();
    }

private:
    ITK_DISALLOW_COPY_AND_ASSIGN(NumberedThreadImageToImageFilter);

    std::mutex m_LockThreadIdNumber;
    std::vector <unsigned int> m_ThreadIdsVector;

    std::mutex m_LockProcessedPoints;
    unsigned int m_NumberOfProcessedPoints;
    unsigned int m_NumberOfPointsToProcess;

    std::mutex m_LockHighestProcessedSlice;
    int m_HighestProcessedSlice;
    unsigned int m_ProcessedDimension;

    // Optimization of multithread code, compute only on region defined from mask... Uninitialized in constructor.
    OutputImageRegionType m_ComputationRegion;
};

} //end namespace anima

#include "animaNumberedThreadImageToImageFilter.hxx"