IScanner.h

Go to the documentation of this file.

/********************************************************************
*
*   Project     Artec 3D Scanning SDK
*
*   Purpose:    Universal interface for capture from any scanner
*
*   Copyright:  Artec Group
*
********************************************************************/
#ifndef _ISCANNER_H_
#define _ISCANNER_H_

#include <artec/sdk/base/Errors.h>
#include <artec/sdk/base/IRef.h>
#include <artec/sdk/base/Matrix.h>
#include <artec/sdk/capturing/CaptureSdkDefines.h>
#include <artec/sdk/capturing/ScannerInfo.h>

namespace artec { namespace sdk { namespace base
{

class  IImage;
class  IFrameMesh;
class  IArrayString;

} } };

namespace artec { namespace sdk { namespace capturing
{
using namespace artec::sdk::base::errors;

using  artec::sdk::base::IImage;
using  artec::sdk::base::IFrameMesh;
using  artec::sdk::base::IArrayString;

struct FrameProcessorDesc;

class  IScanner;
class  IScannerObserver;
class  IFrame;
class  IFrameProcessor;
class  IArrayScannerId;
class  IScannerSynchronization;

extern "C"
{
ErrorCode ACAPTURESDK_LINK_SPEC
    enumerateCameras(IArrayString **camerasList, int deviceTypeMask = -1);

ErrorCode ACAPTURESDK_LINK_SPEC 
    forceIpForGigECameras();

ErrorCode ACAPTURESDK_LINK_SPEC
    enumerateScanners(IArrayScannerId **scannersList, int deviceTypeMask = -1, const wchar_t* pathToConfig = NULL);

ErrorCode ACAPTURESDK_LINK_SPEC
    createScanner(IScanner **scanner, const ScannerId *id, int scannerIndex = 0);
}


/// real-time decoding and triangulation settings
struct FrameProcessorDesc
{
    /// decoder settings
    int    minimumObjectSize;       ///< Parameter for filtering triangles by patch size
    /// triangulation settings
    int    trianglesStep;           ///< Points density of a frame mesh
    double edgeLengthThreshold;     ///< Threshold for filtering triangles by edge length (in mm)
    bool   interpolate;             ///< Switch interpolation on/off
    double maxInterpolatedLength;   ///< Maximum size of holes to be interpolated (in mm)
    double maxAngle;                ///< Maximal angle between plane of polygon and camera direction(in degrees)
};

class IScanner : public artec::sdk::base::IRef
{
public:
    /// create IFrameProcessor processor
    /// if desc == NULL, use default settings
    virtual ErrorCode createFrameProcessor( IFrameProcessor** processor, FrameProcessorDesc* desc = NULL ) = 0;

    /// fill desc with default processing parameters
    virtual ErrorCode initFrameProcessorDesc( FrameProcessorDesc* desc ) = 0;

    /// get current frame number
    virtual int getFrameNumber() const = 0;

    /// make capture action
    /// safe multi-thread function
    virtual ErrorCode capture( IFrame** frame, bool captureTexture ) = 0;

    /// capture texture only 
    /// safe multi-thread function
    virtual ErrorCode captureTexture( IImage** texture, int* frameNumber ) = 0;

    /// get scanner ID
    virtual const ScannerId* getId() const = 0;

    /// get scanner information
    virtual const ScannerInfo* getInfo() const = 0;

    /// get scanner event handler
    virtual IScannerObserver* getObserver() const = 0;

    /// set scanner event handler
    virtual ErrorCode setObserver(IScannerObserver* handler) = 0;

    /// gain settings
    virtual float getGain() const = 0;
    virtual float getTextureGain() const = 0;
    virtual void  setTextureGain( float gain ) = 0;

    /// get texture gain range
    virtual float getTextureGainMin() const = 0;
    virtual float getTextureGainMax() const = 0;

    /// Returns currently requested scanner FPS
    virtual float getFPS() const = 0;
    /// Sets required scanner FPS
    virtual void setFPS(float fps) = 0;
    /// Returns maximum possible FPS for this scanner type
    virtual float getMaximumFPS() const = 0;

    /// get matrix for texture mapping
    /// pass it in data-processor mapTexture() function 
    virtual const artec::sdk::base::Matrix3x4D& getTextureMappingMatrix() const = 0;

    /// get parameters that is needed for a texture brightness normalization
    /// texture flash power coefficient on a 1000mm distance (~ white plain intensity)
    virtual float getTextureIllumination() const = 0;

    /// convert RAW buffer to RGB (use standard capturer conversion)
    /// perform de-mosaicking, correct vignetting and distortion 
    virtual ErrorCode convertTextureFull( IImage** fullTexture, const IImage* rawTexture ) const = 0;
    
    /// convert RAW texture buffer from device to half-resolution RGB (fast)
    /// perform de-mosaicking, correct vignetting and distortion 
    virtual ErrorCode convertTextureHalf( IImage** halfTexture , const IImage* rawTexture ) const = 0;

    /// enable/disable flash for geometry camera
    virtual void enableFlash(bool enable) = 0;
    virtual bool isFlashEnabled() const = 0;

    /// flash delay in milliseconds
    virtual void  setFlashDelay( float vl ) = 0;
    virtual float getFlashDelay() const = 0;

    /// flash duration for geometry camera only
    virtual float getFlashDuration() const = 0;

    /// enable/disable flash for texture capturing
    virtual void enableTextureFlash(bool enable) = 0;
    virtual bool isTextureFlashEnabled() const = 0;

    /// set/get external synchronization trigger delay in milliseconds
    virtual void  setTriggerDelay(float delay) = 0;
    virtual float getTriggerDelay() const = 0;

    /// enable/disable scanner trigger for external synchronization
    virtual void setUseHwTrigger( bool vl ) = 0;
    virtual bool getUseHwTrigger() const = 0;

    /// enable/disable texture camera trigger to synchronize texture and depth
    virtual void setTextureUseHwTrigger( bool vl ) = 0;
    virtual bool getTextureUseHwTrigger() const = 0;

    /// set/get external synchronization trigger delay for texture camera in milliseconds
    virtual void  setTextureTriggerDelay(float delay) = 0;
    virtual float getTextureTriggerDelay() const = 0;

    /// set/get texture camera shutter speed (exposure time) in milliseconds
    virtual void  setTextureShutterSpeed( float vl ) = 0;
    virtual float getTextureShutterSpeed() const = 0;

    /// set auto exposure 
    virtual void enableAutoExposure(bool enable) = 0;
    virtual bool isAutoExposureEnabled() const = 0;
    
    /// set auto white balance
    virtual void enableAutoWhiteBalance(bool enable) = 0;
    virtual bool isAutoWhiteBalanceEnabled() const = 0;

    /// synchronization scanners in bundle
    virtual ErrorCode setScannerSynchronization(IScannerSynchronization* sync) = 0;
    virtual IScannerSynchronization* getScannerSynchronization() const = 0;

    /// fire trigger. not a thread-safe function
    virtual ErrorCode fireTrigger(bool captureTexture) = 0;

    /// retrieve captured frame. not a thread-safe function
    virtual ErrorCode retrieveFrame(IFrame** frame, bool captureTexture) = 0;

    /// get scanner index in bundle. 0 - when no bundle used
    virtual int getScannerIndex() const = 0;
    virtual void setScannerIndex(int newIndex) = 0;
};

} } } // namespace artec::sdk::capturing

#endif // _ISCANNER_H_