WPScanConverter.h

Go to the documentation of this file.

 
#pragma once
 
#include <boost/signals2.hpp>
#include <boost/bind.hpp>
 
#include <string>
#include <vector>
#include <mutex>
#include <atomic>
#include <iostream>
#include <fstream>
 
#include "OCTTypeDefs.h"
#include "IWPOCTConverter.h"
#include "ConversionInOutData.h"
#include "ScanProcessor.h"
 
using namespace std;
 
class WPScanConverter : public IWPOCTConverter
{
public:
    const int InitialNumScanProcessors = 1;
    const int MaxAScanSize = 8192;
    const int MaxAScansPerBScan = 65000;
    const int MaxNumScanProcessors = 8;
 
    // Constructor
    WPScanConverter();
 
    // Destructor
    virtual ~WPScanConverter();
 
    // Events
    boost::signals2::signal<void(const char* )>  SignalCalibrationFileChanged;
 
    // Getters
 
    const char* GetQualifiedInputFileName() const override { return _qualifiedInputFileName.c_str(); }
 
    const char* GetOutputIntensityName   () const override { return _outputIntensityName.c_str(); }
 
    const char* GetOutputPhaseName       () const override { return _outputPhaseName.c_str(); }
 
    const char* GetOutputDirectory       () const override { return _outputDirectory.c_str(); }
 
    const char* GetCalibrationFringeFile () const override { return _calibrationFringeFile.c_str(); }
 
    bool        GetOutputIntensity       () const override { return _outputIntensity; }
 
    bool        GetOutputPhase           () const override { return _outputPhase; }
 
    // Get the flag that determines if GPU is used in calculations.
    //bool      GetUseGPU                () const override { return _useGPU; }
 
    bool        GetDeleteInputFileAfterConversion   () const override { return _deleteInputFile; }
 
    bool        GetOutputTiffFormat      () const override { return _outputTiffFormat; }
 
    bool        GetOutputLogOfData      () const override { return ScanProcessor::GetOutputLogValues(); }
 
    bool        GetUseContrast          () const override { return ScanProcessor::GetUseAutoContrast(); }
 
    bool        GetUseScaling           () const override { return ScanProcessor::GetUseScaling(); }
 
    // Get the flag that determines if apodization is used.
    //bool      GetUseApodization       () const override { return ScanProcessor::GetUseApodization(); }
 
    int         GetAScansPerBScan       () const override { return _scanProcessors[0]->GetWidth(); }
    int         GetAScanSize            () const override { return _scanProcessors[0]->GetHeight(); }
    bool        GetScanDimensions       (int* width, int* height) const override;
 
    bool        GetDispersionCoefficients(float* coefficients, int length) const override;
 
    bool        GetNumberOfLinesToIgnore(int* top, int* bottom) const override;
 
    bool        GetMinMaxScaling        (float* min, float* max) const override;
 
    int         GetNumScanProcessors    () const override { return (int)_scanProcessors.size(); }
 
    int         GetAScanAverage         () const override { return _scanProcessors[0]->GetAScanAverage(); }
 
    virtual bool GetUseMovingAverage        () const override { return ScanProcessor::GetUseMovingAverage(); }
    virtual int  GetMovingAverageWindowSize () const override { return ScanProcessor::GetMovingAverageWindowSize(); }
 
    // Setters
 
    bool    SetQualifiedInputFileName(const char* name) override;
 
    bool    SetOutputIntensityName  (const char* name) override;
 
    bool    SetOutputPhaseName      (const char* name) override;
 
    bool    SetOutputDirectory      (const char* name) override;
 
    bool    SetCalibrationFringeFile(const char* name) override;
 
    bool    SetOutputIntensity      (bool value) override { _outputIntensity = value; return true; }
 
    bool    SetOutputPhase          (bool value) override { _outputPhase = value; return true; }
 
    // Set the flag that determines if GPU is used in calculations.
    //bool  SetUseGPU               (bool value) override { _useGPU = value; return true; }
 
    bool    SetDeleteInputFileAfterConversion   (bool value) override { _deleteInputFile = value; return true; }
 
    bool    SetOutputTiffFormat     (bool value) override { _outputTiffFormat = value; return true; }
 
    bool    SetOutputLogOfData      (bool value) override { ScanProcessor::SetOutputLogValues(value); return true; }
 
    bool    SetUseScaling           (bool value) override 
    { 
        if (!value)
        {
            ScanProcessor::SetUseAutoContrast(false);
        }
        return ScanProcessor::SetUseScaling(value); 
    }
 
    bool    SetUseContrast          (bool value) override { return ScanProcessor::SetUseAutoContrast(value); }
 
    // Set the flag that determines if apodization is used.
    //bool  SetUseApodization       (bool value) override { ScanProcessor::SetUseApodization(value); }
 
    bool    SetDispersionCoefficients   (const float* dispersionCoeffients, int length) override;
 
    bool    SetDispersionOptimizationParameters(int numCoefficients, int maxIterations, 
                                                float* initialGuesses, int startLine, 
                                                int stopLine, int offset) override;
    bool    CalcDispersionCoefficients(const unsigned short* inData, int width, int height,
                                        float* coefficients) override;
 
    bool    SetNumberOfLinesToIgnore    (int top, int bottom) override;
 
    bool    SetMinMaxScaling    (float min, float max) override
    {
        if (min > max || min < 0 || max > 1)
        {
            _lastError = InvalidArgumentValue;
            return false;
        }
 
        ScanProcessor::SetAutoScaleUserMin(min);
        ScanProcessor::SetAutoScaleUserMax(max);
        _lastError = NoError;
        return true;
    }
 
    bool    SetAScansPerBScan   (int value) override
    {
        if (value <= 0 || value > MaxAScansPerBScan)
        {
            _lastError = InvalidArgumentValue;
            return false;
        }
 
        _scanWidth = value;
        _resizeDataContainers = true;
        for (size_t i = 0; i < _scanProcessors.size(); i++)
        {
            _scanProcessors[i]->SetWidth(value);
        }
        _lastError = NoError;
        return true;
    }
 
    bool    SetAScanSize        (int value) override 
    { 
        if (value <= 0 || value > MaxAScanSize)
        {
            _lastError = InvalidArgumentValue;
            return false;
        }
 
        _scanHeight = value; 
        _resizeDataContainers = true;
        // Set height of all the scan processors.
        for (size_t i = 0; i < _scanProcessors.size(); i++)
        {
            _scanProcessors[i]->SetHeight(value);
        }
        _lastError = NoError;
        return true;
    }
 
    bool    SetScanDimensions   (int aScansPerBScan, int aScanSize) override
    {
        if (aScansPerBScan <= 0 || aScansPerBScan > MaxAScansPerBScan ||
            aScanSize <= 0 || aScanSize > MaxAScanSize)
        {
            _lastError = InvalidArgumentValue;
            return false;
        }
 
        if (_scanWidth != aScansPerBScan || _scanHeight != aScanSize)
        {
            _scanWidth = aScansPerBScan;
            _scanHeight = aScanSize;
            _resizeDataContainers = true;
            // Set height of all the scan processors.
            for (size_t i = 0; i < _scanProcessors.size(); i++)
            {
                _scanProcessors[i]->SetWidthAndHeight(aScansPerBScan, aScanSize);
            }
        }
        _lastError = NoError;
        return true;
    }
 
    bool    SetAScanAverage             (int value) override 
                { return _scanProcessors[0]->SetAScanAverage(value); }
 
    bool    SetNumScanProcessors(int value) override;
 
    bool    SetUseMovingAverage         (bool value) override 
                { return ScanProcessor::SetUseMovingAverage(value); }
    bool    SetMovingAverageWindowSize  (int value)  override 
                { return ScanProcessor::SetMovingAverageWindowSize(value); }
    bool    ResetMovingAverage          ()           override 
                { return ScanProcessor::ResetMovingAverage(); }
 
    bool    UpdateBackgroundImage       () override;
    bool    GetBackgroundImage          (float* buffer, int size) override;
    bool    SetBackgroundImage          (float* buffer, int size) override;
 
    // Conversion routines
 
    // Convert raw spectral data to intensity array.  Returns true if successful.
    bool    ConvertSpectralDataToIntensity  (IWPOCTInOutData* inOutData) override;
    bool    ConvertSpectralDataToIntensity  (const unsigned short* inData, float* outIntensity) override;
 
    // Convert raw spectral data to phase and intensity arrays.  Returns true if successful.
    bool    ConvertSpectralDataToPhaseIntensity (IWPOCTInOutData* inOutData) override;
    bool    ConvertSpectralDataToPhaseIntensity (const unsigned short* inData, float* outIntensity, 
                                                    float* outPhase) override;
 
    bool    ConvertSpectralFileToPhaseIntensity () override;
 
    bool    ConvertSpectralFileToPhaseIntensity (const char* qualifiedFileName) override;
 
    bool    ConvertSpectralDirToPhaseIntensity  () override;
 
    bool    ConvertFloatToUnsignedChar          (const float* inData, unsigned char* outData, 
                                                    int size) const override;
 
    bool    ConvertFloatToUnsignedShort         (const float* inData, unsigned short* outData, 
                                                    int size) const override;
 
    bool TransposeArray (const float* src, float* dst, int inWidth, int inHeight) const override;
    bool TransposeArray (const unsigned short* src, unsigned short* dst, int inWidth, int inHeight) const override;
    bool TransposeArray (const unsigned char* src, unsigned char* dst, int inWidth, int inHeight) const override;
 
    bool FlipVertical   (unsigned short* data, int width, int height) const override;
    bool FlipHorizontal (unsigned short* data, int width, int height) const override;
    bool RotateImage    (const unsigned short* inData, unsigned short* outData, int width, int height, 
                            unsigned int cw90Multiplier) const override;
 
    virtual IWPOCTConverter::ErrorCode  GetLastError() const override;
 
protected:
    void    SignalProgress      ();
    // File routines
    bool    ReadBinFileToMemory (const char* qualifiedFileName, unsigned short* outData);
    bool    WriteMemoryToFile   (const char* qualifiedFileName, const U16* inData);
    bool    WriteMemoryToFile   (const char* qualifiedFileName, const float* inData);
    string  GetFileName         (const string& fullName);
 
 
private:
    std::mutex  _mutex;
 
    int     _scanWidth;
    int     _scanHeight;
    int     _currScanProcessor;
 
    string      _qualifiedInputFileName;
 
    string      _outputPhaseName;
    string      _outputPhaseIndexedName;
 
    string      _outputIntensityName;
    string      _outputIntensityIndexedName;
 
    string      _outputDirectory;
 
    string      _calibrationFringeFile;
 
    clock_t                 _startTime;
 
    std::atomic<bool>       _outputIntensity;
 
    std::atomic<bool>       _outputPhase;
 
    std::atomic<bool>       _useGPU;
 
    std::atomic<bool>       _deleteInputFile;
 
    std::atomic<bool>       _outputTiffFormat;
 
    std::atomic<long>       _dongleVal;
    std::atomic<ErrorCode>      _lastError;
 
    std::vector<ScanProcessor*>     _scanProcessors;
 
    IWPOCTInOutData*            _inOutData;
 
    std::vector<U16>            _shortData;
 
    bool                        _resizeDataContainers;
 
    std::vector<std::string>    _filesInDir;
 
    void    Init();
 
    void    OnCalibrationFileChanged(const char* name);
 
    // Resize containers.
    void    ResizeContainers        ();
    void    ResizeShortData         (int size);
    template <typename T>
    void    ResizeData              (std::vector<T>& vec, int size);
 
    std::vector<std::string> GetFilesInDir  (std::string& myDir);
 
    string  FormOutputName      (string& path, bool intensity);
    string  FormOutputName      (string& path, string& name);
    string  GetBaseFileName     (string& inName, bool& numsAtEnd);
    string  GetIndexFromFile    (string& currFile, bool numsAtEnd);
 
    ScanProcessor* GetNextScanProcessor();
 
    void    GenerateOutputIntensityIndexedName  (string& index, bool numsAtEnd);
    void    GenerateOutputPhaseIndexedName      (string& index, bool numsAtEnd);
 
    bool    ConvertSpectralFileToPhaseIntensity (std::string& qualifiedFileName);
};
 
// Implementation
template <typename T>
void WPScanConverter::ResizeData(std::vector<T>& vec, int size)
{
    if (vec.size() != size)
    {
        vec.clear();
        vec.resize(size);
    }
}