Dispersion.h

Go to the documentation of this file.

 
#pragma once
 
#include "OCTTypeDefs.h"
#include <boost/signals2.hpp>
#include <boost/bind.hpp>
#include <mutex>
#include "ScanProcessor.h"
 
// Forward class declarations.
class ScanProcessor;
 
class Dispersion
{
public:
    Dispersion          (ScanProcessor* scanProcessor);
 
    virtual ~Dispersion ();
 
    bool                CalcCoefficients        (const unsigned short* inData, int inWidth, 
                                                 int inHeight, float* coefficients);
    bool                SetOptimizationParameters   (int numCoefficients, int maxIterations, 
                                                     float* initialGuesses, int startLine, 
                                                     int stopLine, int offset);
    bool                ComputeDispersionArray  ();
 
    std::vector<float>  GetCoefficients         () { return _coefficients; }
 
    void                GetCoefficients         (float* coefficients);
    bool                SetCoefficients         (const float *source, int len);
    void                ProcessChunk            (int start, int stop, bool localPad, const SGL* inData, 
                                                 SGL*& intensity, SGL*& interimData);
 
    virtual void        InitGPUMethods          (int programIndex)          { }
    virtual void        OnWidthHeightChanged    (int width, int height)     { }
    virtual bool        SetDispersionArrays     (float *dispersionPhi) { return false; }
 
    template<typename T>
    void FringeMethodHilbert(const T* inData, T*& outData, T*& interimData)
    {
        int width = _scanProcessor->GetWidth();
        // try splitting this computation up -  need speed!
        int c = 0;
        int cSize = width / _numChunks;
        bool isZeroPad = _scanProcessor->GetIsZeroPad();
        //smessage("len "+i2S(_numChunks)+" cSize "+i2S(cSize));
 
        boost::thread_group threadGroup;
        for (c = 0; c < _numChunks - 1; c++)
        {
            int cStart = c*cSize;
            threadGroup.create_thread(boost::bind(&Dispersion::ProcessChunk, this, cStart, 
                                        cStart + cSize, isZeroPad, c, inData, outData, interimData));
        }
        int cStart = (_numChunks - 1)*cSize;
        threadGroup.create_thread(boost::bind(&Dispersion::ProcessChunk, this, cStart, width, 
                                                isZeroPad, c, inData, outData, interimData));
        threadGroup.join_all();
    }
 
protected:
 
    ScanProcessor*      _scanProcessor;
    bool                _initialized;
 
    static  std::mutex      _mutexCorrect;
 
    virtual void    InitStorage         ();
    virtual void    ReleaseStorage      () { }
 
    template<typename T>
    void SumCorrectedPhase(T &corrPhase, int i)
    {
        if (_coefficients.size() == 0)
        {
            return;
        }
 
        for (int order = 0; order < (int)_coefficients.size(); order++)
        {
            corrPhase += _coefficients[order] * ShiftedLegendrePolynomial<T>(order, i);
        }
    }
 
private:
    boost::signals2::connection _widthHeightConnection;
 
    // Dispersion vectors.
    std::vector<float>  _coefficients;
    std::vector<float>  _coefficientsBackup;
 
    std::vector<SGL>    _dispersionArrayReal;
    std::vector<SGL>    _dispersionArrayImag;
    std::vector<SGL>    _dispersionArrayPhi;
    std::vector<SGL>    _interimData;
    std::vector<float>  _initialGuesses;
 
 
    bool    _findingDispCoeff;
    int     _numChunks;         // size of threadpool for one frame
    int     _offset; 
    int     _maxIterations; 
    int     _numPolynomials;
    UINT    _startLine, _stopLine;
 
 
    // Methods
    void    Init                    ();
    void    ReleaseDispersionArrays ();
    int     Compute                 (const unsigned short *raw, float *&interim, float *&outData);
    void    WriteDebugMessages      (int numLines);
    void    BackupCoefficients      ();
    bool    FindBestDispersion      (const unsigned short* inData, int length, int numLines, 
                                        int width, int height, float* coefficients);
    void    CheckCandidates         (float startingGuess, float increment, int ai, 
                                        std::vector<float>& coeffOfVariance, 
                                        const unsigned short* inData, SGL*& intensity, 
                                        int length, int numLines, int height, 
                                        std::vector<float>& sumOfVariance);
    template<typename T>
    T ShiftedLegendrePolynomial(int order, int x)
    {
        int height = _scanProcessor->GetHeight();
        // use range [0,imageHeight - 1];
        T y = (2 * x - (height - 1)) / (T)(height - 1);
        T ans = 0;
 
        if (false)
        {
            return pow(y, order + 2);
        }
        else
        {
            switch (order)
            {
            case 0: //really 2
                ans = (T)(0.5 * (3 * y * y - 1));
                break;
            case 1: // really 3
                ans = (T)(0.5 * (5 * y * y * y - 3 * y));
                break;
            case 2: // 4
                ans = (T)(0.125 *(35 * y * y * y * y - 30 * y * y + 3));
                break;
            case 3: // 5
                ans = (T)(0.125 *(63 * y * y * y * y * y - 70 * y * y * y + 15 * y));
                break;
            case 4: //6
                ans = (T)((1 / 16.0)*(231 * y * y * y * y * y * y - 315 * y * y * y * y + 105 * y * y - 5));
                break;
            default: //7
                ans = (T)((1 / 16.0)*(429 * y * y * y * y * y * y * y - 693 * y * y * y * y * y + 315 * 
                        y * y * y - 35 * y));
                break;
            }
        }
 
        return ans;
    }
};