WPCamera.h

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <string>
#include <vector>
#include <fstream>
#include <ctime>
#include <mutex>
 
#include "IWPOCTCamera.h"
 
using namespace std;
 
class WPCamera : public IWPOCTCamera
{
public:
    WPCamera();
 
    virtual ~WPCamera();
 
    // Events
 
    // Getters
    bool        IsInitialized   () const override;
    bool        IsOpened        () const override;
    bool        IsAcquiring     () const override;
    bool        AreParametersSet() const override;
 
    IWPOCTCamera::ErrorCode     GetLastError() const override;
    IWPOCTCamera::CurrentStates     GetCurrentState() const override;
 
    int         GetScanWidth            () const override { return _scanWidth; }
 
    int         GetScanHeight           () const override { return _scanHeight; }
 
    bool        GetScanWidthAndHeight   (int* width, int* height) const override 
    {
        bool result = true;
        try
        {
            if (width)
            {
                *width = (int)_scanWidth;
            }
            else
            {
                result = false;
            }
            if (height)
            {
                *height = (int)_scanHeight;
            }
            else
            {
                result = false;
            }
        }
        catch (exception&)
        {
            result = false;
        }
        return result;
    }
 
    int     GetNumBuffers       ()  const override { return _numBuffers; }
 
    int     GetLinesLost        ()  const override { return _linesLost; }
 
    int     GetTriggersMissed   ()  const override { return _triggersMissed; }
 
    long long       GetImageSize        ()  const { return (size_t)_scanHeight * (int)_scanWidth; }
 
    int     GetCameraType       ()  const override { return _cameraType; }
 
    int     GetAcquisitionTimeout() const override { return _acquisitionTimeout; }
 
    int     GetResourceIndex    ()  const override { return _resourceIndex; }
 
    const char*     GetCameraFileName() const override { return _cameraFileName.c_str(); }
 
    // Setters
 
    bool    SetScanHeight           (int value) override 
    { 
        _scanHeight = value; 
        return true;
    }
 
    bool    SetNumBuffers           (int value)         override { _numBuffers = value; return true; }
 
    bool    SetCameraFileName       (const char* name)  override { _cameraFileName = name; return true; }
 
    bool    SetAcquisitionTimeout   (int value)         override { _acquisitionTimeout = (value <= 0 ? -1 : value); return true; }
 
    bool    SetResourceIndex        (int value)         override { _resourceIndex = value; return true; }
 
    // Write consecutive image acquisitions to disk.
    //bool  WriteFramesToDiskAdjustBuffers(const char* baseFilePath, int numFrames, bool keepMemoryAllocated);
 
    bool    AcquireFramesWriteToDisk    (const char* baseFilePath, int numFrames, bool keepMemoryAllocated) override;
 
    bool    AcquireWriteFramesToMemory  (unsigned short** data, int numFrames) override;
 
    bool    AcquireWriteFramesToMemory  (unsigned short* data, int numFrames) override;
 
protected:
 
    int             _id;
 
    unsigned int    _scanWidth;
 
    unsigned int    _scanHeight;
 
    std::atomic<ErrorCode>      _lastError;
    std::atomic<CurrentStates>  _currentState;
 
    int                     _numBuffers;
    std::atomic<int>        _linesLost;
    std::atomic<int>        _triggersMissed;
    std::atomic<int>        _acquisitionTimeout;
    std::atomic<bool>       _acquiringSeries;
    std::atomic<bool>       _abortAcquisition;
 
    std::atomic<long>       _dongleVal;
 
    int                     _resourceIndex;
    CameraType              _cameraType;
    vector<unsigned short>  _acquisitionData;
 
    std::string             _cameraFileName;
    std::string             _seriesBaseFileName;
 
    virtual bool DeleteResources() { return true; }
 
    void OutputDebugMsg(const wchar_t* str) const
    {
#ifdef _DEBUG
        // Only call OutputDebugString when in debug as this call has some overhead.
        OutputDebugString( str );
#endif
    }
 
    void OutputDebugMsg(const char* str) const
    {
#ifdef _DEBUG
        // Only call OutputDebugString when in debug as this call has some overhead.
        OutputDebugStringA( str );
#endif
    }
 
    string  FormSeriesBaseFileName  (const char* baseFilePath);
    string  FormSeriesFinalFileName (size_t index, const char* extension);
    string  GetFilledDigits         (int number, int totalDigits);
 
    template <typename T>
    static bool SaveMemoryToBinFile(const char* fname, long long size, const T* data)
    {
        bool result = false;
        ofstream fout;
 
        try
        {
            fout.open(fname, ios::out | ios::binary);
            if (fout.good())
            {
                fout.write((char*)data, size * sizeof(T));
                if (fout.good())
                {
                    result = true;
                }
                fout.close();
            }
        }
        catch (exception& )
        {
            result = false;
        }
        return result;
    }
 
private:
    std::mutex  _mutexTimeCheck;
 
    static  std::atomic<bool>       _id0Taken;
    static  std::atomic<double>     _timeCheckInterval;
    static  std::atomic<clock_t>    _startTime;
 
    void Init();
};