Resampler.h

Go to the documentation of this file.

 
#pragma once
 
#include "OCTTypeDefs.h"
#include <mutex>
 
#include <boost/signals2.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/filesystem/operations.hpp>
 
// Forward class declarations.
class WPScanConverter;
class ScanProcessor;
 
class Resampler
{
public:
    Resampler(WPScanConverter* converter, ScanProcessor* scanProcessor);
    virtual ~Resampler();
 
    // Getters
    int     GetWindowingType    ()  const       { return _windowingType; } 
    bool    GetPerformResample  ()  const       { return _performResample; }
 
    // Setters
    void    SetPerformResample  (bool value)    { _performResample = value; }
 
    virtual void    InitGPUMethods          (int programIndex)          { }
    virtual void    OnWidthHeightChanged    (int width, int height);
    virtual void    OnCalibrationFileChanged(const char* fileName);
    virtual int     NoResample              ()              { return 0; }
    virtual int     Process                 ()                  { return 0; }
    virtual int     ApplyHanningAndFringe   (const float* inData, size_t dataSize) { return -1; }
 
protected:
    ScanProcessor*          _scanProcessor;
    WPScanConverter*        _scanConverter;
    bool                    _initialized;
    bool                    _performResample;
    int                     _windowingType; 
    int                     _height;
    int                     _id;
 
 
    // Calibration arrays.
    std::vector<int>        _li_fringe;
    std::vector<SGL>        _hann_win_fringe;
    std::vector<SGL>        _p_fringe;
    std::vector<SGL>        _calFringeArray;
    std::map<SGL, int>      _fringe_map;
 
    static  std::mutex      _mutexResample;
    static  string          _calibrationFileName;
    static  int             _numResamplerObjects;
 
    void    SetCalibration              ();
    bool    InitFringeCalibration       (int win, int winPow);
    void    SetCalibrationFringeFile    (const std::string &fname);
 
    void    InitCalibration             (int height);
    void    ReleaseCalibration          ();
 
    virtual void    InitStorage         ();
    virtual void    ReleaseStorage      ();
 
    virtual void    SetHanningArray     (float *hanning)    { }
    virtual void    SetPFringeArray     (float *pFringe)    { }
    virtual void    SetLIFringeArray    (int *liFringe)     { }
 
private:
    bool            _calibrationInitialized;
    double          _gaussianSigma;
 
    boost::signals2::connection _widthHeightConnection;
    boost::signals2::connection _calibrationFileConnection;
 
    // Methods
    void    Init                ();
 
    template<typename T>
    static bool LoadFileToVector(int len, const char* fname, std::vector<T> *data_out, int &nItem)
    {
        if (FileUtils::FileExists(fname))
        {
            ifstream ifile(fname);
            //ifile.exceptions ( ifstream::failbit | ifstream::badbit );
            char charline[256];
            string strline = "";
            float dbl = 0;
 
            nItem = 0;
            try
            {
                while (!ifile.getline(charline, 256).eof() && nItem < len)
                {
                    strline.assign(charline);
                    boost::algorithm::trim(strline);
 
                    vector<string> words;
                    boost::algorithm::split(words, strline, boost::is_any_of("\t ,"));
 
                    // allow for comment or blank line
                    if (words[0].compare(0, 1, "#") == 0 || words.size() < 1) { continue; }
 
                    for (size_t y = 0; y < words.size(); y++)
                    {
                        boost::algorithm::trim(words[y]);
                        if (words[y].size() == 0) { continue; }
 
                        if (!FromString<float>(dbl, words[y], std::dec))
                        {
                            continue;
                        }
                        (*data_out)[nItem] = dbl;
                        nItem++;
                    }
                }
                ifile.close();
                return true;
            }
            catch (ifstream::failure e)
            {
                //alert(" Problem with format of files");
                //alert(e.what());
                ifile.close();
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};