Background.h

Go to the documentation of this file.

 
#pragma once
 
#include "OCTTypeDefs.h"
#include <boost/signals2.hpp>
#include <boost/bind.hpp>
#include <vector>
#include <mutex>
#include "ScanProcessor.h"
 
// Forward class declarations.
 
class Background
{
public:
    Background(ScanProcessor* scanProcessor);
    virtual ~Background();
 
    // Getters
 
    bool GetUseBackgroundSubtract   () const    { return _useBackgroundSubtract; }
    bool GetUseAverageBG            ()  const   { return _useAverageBG; }
    bool GetUseAutoDC               ()  const   { return _useAutoDC; }
    bool GetAutoSaveBG              ()  const   { return _autoSaveBG; }
 
    // Setters
 
    void SetUseBackgroundSubtract   (bool value)    { _useBackgroundSubtract = value; }
    void SetUseAverageBG            (bool value)    { _useAverageBG = value; }
    void SetUseAutoDC               (bool value)    { _useAutoDC = value; }
    void SetAutoSaveBG              (bool value)    { _autoSaveBG = value; }
 
    bool GetBackgroundImage         (float* buffer, int size);
    bool UpdateImage                (float* buffer = nullptr, int size = 0);
 
    void AdjustForBackground        (const U16* raw, SGL *&inputData);
 
    template <typename T, typename F>
    void BackgroundAverageAutoDCMethod(const T* raw, F *&inputData)
    {
        int j;
        int width = _scanProcessor->GetWidth();
        int height = _scanProcessor->GetHeight();
 
        for (int i = 0; i < width; i++)
        {
            //- for each a-scan, sum all the pixels
            float aSum = 0;
            float dcComp = 0;
            for (j = 0; j < height; j++)
            {
                aSum += static_cast<F>(*(raw + j + i * height)) / height;
            }
 
            dcComp = aSum - _averageSum;
            if (_scanProcessor->GetUseApodization())
            {
                //not tested
                for (j = 0; j < height; j++)
                {
                    *(inputData + i * height + j) = _maxIntensity *
                        (static_cast<F>(*(raw + i * height + j)) - dcComp - _avgBgLine[j]) /
                        (dcComp - _avgBgLine[j]);
                }
            }
            else
            {
                for (j = 0; j < height; j++)
                {
                    *(inputData + i * height + j) = static_cast<F>(*(raw + i * height + j)) -
                        dcComp - _avgBgLine[j];
                }
            }
        }
    }
 
    template <typename T, typename F>
    void BackgroundAverageMethod(const T* raw, F *&inputData)
    {
        long imageSize = _scanProcessor->GetWidth() *_scanProcessor->GetHeight();
        if (_avgBgImage.size() != imageSize)
        {
            ComputeAveragedBackground();
        }
 
        //Apodization
        if (_scanProcessor->GetUseApodization())
        {
            //smessage("using apodization cpu");
            for (int i = 0; i < imageSize; i++)
            {
                *(inputData + i) = _maxIntensity * (static_cast<F>(*(raw + i)) -
                    _avgBgImage[i]) / _avgBgImage[i];
            }
        }
        else
        {
            // use regular bg subtract
            for (int i = 0; i < imageSize; i++)
            {
                *(inputData + i) = static_cast<F>(*(raw + i)) - _avgBgImage[i];
            }
        }
    }
 
    template <typename T, typename F>
    void BackgroundImageMethod(const T* raw, F *&inputData)
    {
        long  imageSize = _scanProcessor->GetWidth() *_scanProcessor->GetHeight();
        for (int i = 0; i < imageSize; i++)
        {
            *(inputData + i) = static_cast<F>(*(raw + i)) - _bgImage[i];
        }
    }
 
    template <typename T, typename F>
    void NoImageMethod(const T* raw, F *&inputData)
    {
        long  imageSize = _scanProcessor->GetWidth() *_scanProcessor->GetHeight();
 
        for (int i = 0; i < imageSize; i++)
        {
            *(inputData + i) = static_cast<F>(*(raw + i));
        }
    }
 
    virtual void    InitGPUMethods          (int programIndex) { }
    virtual void    OnWidthHeightChanged    (int width, int height) { }
 
    virtual int     Subtract                (const unsigned short *raw);
 
 
protected:
    bool                _initialized;
    bool                _updateImage;
    bool                _useAveragedImage;
 
    static  std::vector<SGL>    _bgImage;
    static  std::vector<SGL>    _avgBgImage;
    static  std::vector<SGL>    _avgBgLine;
 
    static int                  _numObjects;
 
    ScanProcessor*          _scanProcessor;
 
    static  float           _maxIntensity;
    static  float           _averageSum;
    static  float           _maxBG;
 
    static  bool            _useBackgroundSubtract;
    static  bool            _useAverageBG;
    static  bool            _useAutoDC;
    static  bool            _autoSaveBG;
 
    static  std::mutex      _mutexSubtract;
 
    void    ComputeAveragedBackground   ();
    void    SetBackgroundImagePtr       (const U16 *sourceptr);
 
    virtual void        InitStorage             ();
    virtual void        ReleaseStorage          () { }
    virtual void        UpdateBackgroundArray   (float *Background, float maxgb) { }
 
private:
    boost::signals2::connection _widthHeightConnection;
 
    void Init();
};