ScanProcessor.h

Go to the documentation of this file.

 
#pragma once
 
#include <boost/signals2.hpp>
#include <boost/bind.hpp>
 
#include <vector>
#include <mutex>
#include <atomic>
 
#include "IWPOCTConverter.h"
#include "WPFFT.h"
#include "OCTTypeDefs.h"
 
// Forward class declarations.
struct IWPOCTConverter;
struct IWPOCTInOutData;
 
class GPUManager;
class Background;
class Dispersion;
class Resampler;
class Averager;
class MovingAverage;
 
class ScanProcessor
{
public:
    ScanProcessor();    
    ScanProcessor(IWPOCTConverter* scanConverter);
    ScanProcessor(IWPOCTConverter* scanConverter, int width, int height);
 
    virtual ~ScanProcessor();
 
    // Events
    boost::signals2::signal<void(int width, int height)>    SignalWidthHeightChanged;
 
    // Getters
    size_t      GetProcessedDataSizeBytes   ()          { return _outputDataSize; }
    size_t      GetProcessedDataSizeNative  ()          { return _outputDataSize / sizeof(float); }
 
    int     GetHeight           ()  { return _height; }
    int     GetWidth            ()  { return _width; }
    int     GetHalfHeight       ()  { return _halfHeight; }
    int     GetDepth            ()  { return _depth; }
 
    float   GetAutoScaleMin     ()  { return _autoScaleMin; }
    float   GetAutoScaleMax     ()  { return _autoScaleMax; }
    int     GetAScanAverage     ();
 
    static  size_t  GetPreFFTDataSize   ()  { return _preFFT1DataSize; }
 
    bool    IsConvertingImage               ()  const { return _convertingImage; }
    IWPOCTConverter::ErrorCode  GetLastError()  const { return _lastError; }
 
    static  bool    GetShiftUpLines     ()  { return _shiftUpLines; }
    static  int     GetTopLinesToIgnore ()  { return _topLinesToIgnore; }
    static  int     GetBotLinesToIgnore ()  { return _botLinesToIgnore; }
    static  bool    GetOutputLogValues  ()  { return _outputLogValues; }
    static  bool    GetUseAutoContrast  ()  { return _useAutoContrast; }
    static  bool    GetUseScaling       ()  { return _useScaling; }
    static  bool    GetUseApodization   ()  { return _useApodization; }
 
    static  float   GetAutoScaleUserMin ()  { return _userAutoScaleMin; }
    static  float   GetAutoScaleUserMax ()  { return _userAutoScaleMax; }
 
    static bool     GetUseMovingAverage         ();
    static int      GetMovingAverageWindowSize  ();
 
 
    bool    GetIsZeroPad                () const    { return _isZeroPad; }
 
    Dispersion* GetDispersion           ()  const   { return _dispersion; }
    std::vector<float>  GetDispersionCoefficients   ();
 
    void    AdjustForBackground (const U16* raw, SGL *&inputData);
 
    // Setters
    void    SetAutoScaleMin     (float value)   { _autoScaleMin = value; }
    void    SetAutoScaleMax     (float value)   { _autoScaleMax = value; }
    bool    SetAScanAverage     (int value);
 
    static  void    SetShiftUpLines     (bool value)    { _shiftUpLines = value; }
    static  bool    SetTopLinesToIgnore (int value)     
    { 
        if (value < 0)
            return false;
        _topLinesToIgnore = value; 
        return true;
    }
    static  bool    SetBotLinesToIgnore (int value)     
    { 
        if (value < 0)
            return false;
        _botLinesToIgnore = value; 
        return true;
    }
    static  bool    SetOutputLogValues  (bool value)    { _outputLogValues = value; return true; }
    static  bool    SetUseAutoContrast  (bool value)    
    { 
        if (_useScaling || !value)
        {
            _useAutoContrast = value;
            return true;
        }
        else
        {
            return false;
        }
    }
 
    static  bool    SetUseScaling       (bool value)    { _useScaling = value; return true; }
    static  bool    SetUseApodization   (bool value)    { _useApodization = value; return true; }
 
    static  void    SetAutoScaleUserMin (float value)   { _userAutoScaleMin = value; }
    static  void    SetAutoScaleUserMax (float value)   { _userAutoScaleMax = value; }
 
    // Setters for displaying a moving average.
    static  bool    SetUseMovingAverage         (bool value);
    static  bool    SetMovingAverageWindowSize  (int value);
    static  bool    ResetMovingAverage          ();
 
    void    SetIsZeroPad        (bool value)    { _isZeroPad = value; }
 
    bool    SetWidth            (int value)                         
    { 
        if (value <= 0)
            return false;
 
        if (_width != value)
        {
            _width = value;
            OnWidthHeightChanged(_width, _height);
        }
        return true;
    }
 
    bool    SetHeight           (int value)             
    { 
        if (value <= 0)
            return false;
 
        if (_height != value)
        {
            _height = value;
            _halfHeight = _height / 2;
            SetScaleStep();
            SetNoiseStep();
            OnWidthHeightChanged(_width, _height);
        }
        return true;
    }
 
    bool    SetWidthAndHeight   (int width, int height) 
    { 
        if (width <= 0 || height <= 0)
            return false;
 
        if (_width != width || _height != height)
        {
            // Don't call SetHeight and SetWidth to avoid calling OnWidthHeightChanged twice.
            _width = width;
            _height = height;
            _halfHeight = _height / 2;
            SetScaleStep();
            SetNoiseStep();
            OnWidthHeightChanged(width, height);
        }
        return true;
    }
 
    void    SetDepth                        (int value)     { _depth = value; }
 
    int     ComputeForDispersion            (const unsigned short* inData, float* interim, float*& outData);
    bool    CalcDispersionCoefficients      (const unsigned short* inData, int width, int height,
                                                float* coefficients);
    bool    SetDispersionOptimizationParameters(int numCoefficients, int maxIterations, 
                                                    float* initialGuesses, int startLine, 
                                                    int stopLine, int offset);
 
    virtual GPUManager* GetGPUManager       ()  { return nullptr; }
 
    virtual bool    ComputeIntensity        (IWPOCTInOutData* inOutData);
    virtual bool    ComputeIntensity        (const unsigned short* inData, float* outIntensity);
 
    virtual bool    ComputePhaseIntensity   (IWPOCTInOutData* inOutData, bool outputPhase);
    virtual bool    ComputePhaseIntensity   (const unsigned short* inData, float* outIntensity, 
                                                float* outPhase, bool outputPhase);
 
    virtual int     GetFFTLength            () const                { return 0; }
    virtual void    SetScaleType            (int sMethod)           { }
    virtual bool    SetDispersionCoefficients(const float* dispersionCoeffients, int length);
 
    bool    UpdateBackgroundImage   ();
    bool    GetBackgroundImage      (float* buffer, int size);
    bool    SetBackgroundImage      (float* buffer, int size);
 
protected:
    IWPOCTConverter* _scanConverter;
 
    int     _width;
    int     _height;
    int     _halfHeight;
    int     _depth;
 
    static  int     _scaleType;
    static  int     _refCount;
 
    float   _minNoise, _maxNoise, _noiseStep;
    float   _minScale, _maxScale, _scaleStep;
    bool    _isZeroPad;
    IWPOCTConverter::ErrorCode  _lastError;
 
    static  std::atomic<int>    _topLinesToIgnore;
    static  std::atomic<int>    _botLinesToIgnore;
    static  std::atomic<bool>   _outputLogValues;
    static  std::atomic<bool>   _useAutoContrast;
    static  std::atomic<bool>   _useScaling;
    static  std::atomic<bool>   _useApodization;
    static  std::atomic<bool>   _shiftUpLines;
 
    bool    _memAllocated; 
    bool    _initialized; 
 
    bool    _testCPU;
    bool    _filenameSet;
    bool    _padInit;
    float   _autoScaleMin, _autoScaleMax;
    std::atomic<bool>   _convertingImage;
 
    //static    std::mutex          _mutexAnalyticPhase;
    //static    std::mutex          _mutexZeroPad;
    //static    std::mutex          _mutexAssembleIntensity;
    //static    std::mutex          _mutexAssembleIntensityNoiseScale;
    //static    std::mutex          _mutexContrastScale;
 
    static  std::atomic<float>  _userAutoScaleMax, _userAutoScaleMin;
    static  MovingAverage*      _movingAverage;
 
    float*          _dummyFloat;
 
    Background*     _background;
    Dispersion*     _dispersion;
    Resampler*      _resampler;
    Averager*       _averager;
    WPFFT*          _fft;
 
    //Buffer sizes
    size_t          _outputDataSize;
    static  size_t  _preFFT1DataSize;
    
    void        Init();
 
    void        SetScale                (float minScale, float maxScale);
    void        SetNoiseStep            ();
    void        SetScaleStep            ();
    void        SetZeroPadRunFFT        ();
 
    void        RunAssembly             (bool withPhase);
 
    virtual void    CalcMemoryNeeded        ()                      { }
    virtual void    ComputeFFT              (WPFFT::FFTType type)   { }
    virtual void    CorrectDispersion       ()                      { }
    virtual int     PerformAveraging        ()                      { return -1; }
    virtual int     ApplyHanningAndFringe   ()                      { return 0; }
 
    virtual int     InitStorage             ();
    virtual void    ReleaseStorage          ();
 
    virtual void    InitInOutArrays         ();
    virtual void    ReleaseInOutArrays      () { }
 
    virtual void    InitHelpers             ();
    virtual void    ReleaseHelpers          ();
 
    virtual int     CreateAnalyticPhase         () { return 0; }
    virtual int     AssembleIntensity           (bool withPhase)    { return 0; }
    virtual int     AssembleIntensityNoiseScale () { return 0; }
 
    virtual int     ZeroPad                     () { return 0; }
 
    virtual int     ContrastScale               () { return 0; }
 
    virtual int     TransferOutputAndPhase      (float* outData, float* phaseData, bool outputPhase ) { return 0; }
    virtual int     TransferOutputAndInterim    (float*& outData, float* interim)   { return -1; }
 
    virtual void    OnWidthHeightChanged        (int width, int height);
 
private:
    void    SetupMovingAverage();
 
};