libmcdriver_scanlab_rtccontext.hpp

/*++

Copyright (C) 2020 Autodesk Inc.

All rights reserved.

Abstract: This is the class declaration of CRTCContext

*/


#ifndef __LIBMCDRIVER_SCANLAB_RTCCONTEXT
#define __LIBMCDRIVER_SCANLAB_RTCCONTEXT

#include "libmcdriver_scanlab_interfaces.hpp"
#include "libmcdriver_scanlab_sdk.hpp"
#include "libmcdriver_scanlab_rtcrecordinginstance.hpp"
#include "libmcdriver_scanlab_nlightafxprofileselector.hpp"
#include "libmcdriver_scanlab_gpiosequence.hpp"
#include "libmcdriver_scanlab_measurementtagmapinstance.hpp"

#define RTC_TIMINGDEFAULT_LASERPULSEHALFPERIOD 5.0
#define RTC_TIMINGDEFAULT_LASERPULSELENGTH 5.0
#define RTC_TIMINGDEFAULT_STANDBYPULSEHALFPERIOD 1.0
#define RTC_TIMINGDEFAULT_STANDBYPULSELENGTH 1.0

#define RTC6_MIN_DELTALASERPOWER 0.1
#define RTC6_MIN_MAXLASERPOWER 0.1
#define RTC6_MAX_MAXLASERPOWER 10000.0

// Parent classes
#include "libmcdriver_scanlab_base.hpp"
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4250)
#endif

// Include custom headers here.
#include <set>

namespace LibMCDriver_ScanLab {
namespace Impl {


/*************************************************************************************************************************
 Class declaration of CRTCContext 
**************************************************************************************************************************/

class CRTCPowerMapping {
private:
	struct sPowerMappingKnot { double x; double y; }; // generic point; interpret x/y per table

	// Invariants:
	// - m_wattsToPercent is sorted by x = watts, y = percent, spans [w0..w100] -> [0..100]
	// - m_percentToWatts is sorted by x = percent, y = watts, spans [0..100] -> [w0..w100]
	std::vector<sPowerMappingKnot> m_wattsToPercent;
	std::vector<sPowerMappingKnot> m_percentToWatts;

	double m_d0PercentLaserPowerInWatts;
	double m_d100PercentLaserPowerInWatts;

	double m_dEpsilon;

	bool nearlyEqual(double a, double b, double eps);
	void buildAndValidateMappings(const std::map<double, double>& userMap);
	bool interpolate(const std::vector<sPowerMappingKnot>& pts, double x, double& y);

public:

	CRTCPowerMapping();

	virtual ~CRTCPowerMapping();

	void setMaxLaserPowerNoPowerCorrection(double d100PercentLaserPowerInWatts);
	void setMaxLaserPowerLinearPowerCorrection(double d0PercentLaserPowerInWatts, double d100PercentLaserPowerInWatts);
	void setMaxLaserPowerNonlinearPowerCorrection(double d0PercentLaserPowerInWatts, double d100PercentLaserPowerInWatts, std::map<double, double> laserPowerMapping);

	double get0PercentLaserPowerInWatts();
	double get100PercentLaserPowerInWatts();
	bool mapLaserPowerFromWattsToPercent(double dLaserPowerInWatts, double& dPercent);
	bool mapLaserPowerFromPercentToWatts(double dLaserPowerInPercent, double& dWatts);
	std::vector<sPowerMappingKnot>& getPercentToWattTable();
	bool getLaserPowerCalibrationIsLinear();

};

typedef std::shared_ptr<CRTCPowerMapping> PRTCPowerMapping;


class CRTCContextOwnerData {
private:



	PScanLabSDK m_pScanlabSDK;
	std::string m_sAttributeFilterNameSpace;
	std::string m_sAttributeFilterName;
	int64_t m_nAttributeFilterValue;

	eOIERecordingMode m_OIERecordingMode;



public:
	CRTCContextOwnerData();
	virtual ~CRTCContextOwnerData();

	void getAttributeFilters(std::string& sAttributeFilterNameSpace, std::string& sAttributeFilterName, int64_t& nAttributeFilterValue);
	void setAttributeFilters(const std::string& sAttributeFilterNameSpace, const std::string& sAttributeFilterName, const int64_t sAttributeFilterValue);
	
	void setOIERecordingMode(eOIERecordingMode oieRecordingMode);
	eOIERecordingMode getOIERecordingMode();
	PScanLabSDK getScanLabSDK();
	void setScanLabSDK(PScanLabSDK pScanLabSDK);
};

typedef std::shared_ptr<CRTCContextOwnerData> PRTCContextOwnerData;



class CRTCContext : public virtual IRTCContext, public virtual CBase {

protected:
	PRTCContextOwnerData m_pOwnerData;

	PScanLabSDK m_pScanLabSDK;
	uint32_t m_CardNo;
	double m_dCorrectionFactor;
	double m_dZCorrectionFactor;
	double m_dDefocusFactor;

	eLaserPort m_LaserPort;
	bool m_bIsNetwork;
	std::vector<uint32_t> m_MCBSPSignalChannels;

	bool m_b2DMarkOnTheFlyEnabled;
	double m_dScaleXInBitsPerEncoderStep;
	double m_dScaleYInBitsPerEncoderStep;


	std::string m_sIPAddress;
	std::string m_sNetmask;
	uint32_t m_nLaserIndex;

	int32_t m_nCurrentScanPositionX;
	int32_t m_nCurrentScanPositionY;

	PRTCMeasurementTagMapInstance m_pMeasurementTagMap;
	sOIEMeasurementTagData m_CurrentMeasurementTagInfo;

	bool m_bEnableOIEPIDControl;
	uint32_t m_nCurrentFreeVariable0;
	bool m_bMeasurementTagging;

	double m_dLaserOriginX;
	double m_dLaserOriginY;
	double m_dLaserFieldMinX;
	double m_dLaserFieldMinY;
	double m_dLaserFieldMaxX;
	double m_dLaserFieldMaxY;
	bool m_bHasLaserField;

	SpatialPowerModulationCallback m_pModulationCallback;
	void* m_pModulationCallbackUserData;
	bool m_bEnableLineSubdivision;
	double m_dLineSubdivisionThreshold;
	double m_dLaserPulseHalfPeriodInMS;
	double m_dLaserPulseLengthInMS;
	double m_dStandbyPulseHalfPeriodInMS;
	double m_dStandbyPulseLengthInMS;

	LibMCEnv::PDriverEnvironment m_pDriverEnvironment;

	LibMCDriver_ScanLab::eOIEOperationMode m_OIEOperationMode;

	std::mutex m_RecordingsMutex;
	std::map<std::string, PRTCRecordingInstance> m_Recordings;

	std::map<std::string, PGPIOSequenceInstance> m_GPIOSequences;

	PNLightAFXProfileSelectorInstance m_pNLightAFXSelectorInstance;

	PRTCPowerMapping m_pPowerMapping;
	
	void writeJumpSpeed (float jumpSpeed);

	void writeMarkSpeed(float markSpeed);

	void writePower(double dPowerInPercent, bool bOIEPIDControlFlag);

	void writeSpeeds(const LibMCDriver_ScanLab_single fMarkSpeed, const LibMCDriver_ScanLab_single fJumpSpeed, const LibMCDriver_ScanLab_single fPower, bool bOIEPIDControlFlag);

	uint32_t getCurrentFreeVariable0 ();

	void sendFreeVariable0 (uint32_t nValue);

	void sendOIEMeasurementTag (uint32_t nCurrentVectorID);

	void addGPIOSequenceToList (const std::string & sSequenceName);

	void addLayerToListEx(LibMCEnv::PToolpathLayer pLayer, eOIERecordingMode oieRecordingMode, uint32_t nAttributeFilterID, int64_t nAttributeFilterValue, bool bFailIfNonAssignedDataExists);

	void updateLaserField(double dMinXInMM, double dMaxXInMM, double dMinYInMM, double dMaxYInMM);
	
	void clearLaserField();

	double adjustLaserPowerCalibration(double dLaserPowerInPercent, double dPowerOffsetInPercent, double ddPowerOutputScaling);

	// Performs a marking with the settings given by modulation and subdivision
	void jumpAbsoluteEx (double dTargetXInMM, double dTargetYInMM);
	void markAbsoluteEx (double dStartXInMM, double dStartYInMM, double dTargetXInMM, double dTargetYInMM, double dLaserPowerInPercent, bool bOIEControlFlag);

	// Calls the SetTriggerX Call that is necessary for the specific OIE board
	void callSetTriggerOIE(uint32_t nPeriod);

	// Converts a delay in seconds to RTC ticks
	int32_t ConvertDelaySecondsToTicks(double delay);

public:

	CRTCContext(PRTCContextOwnerData pOwnerData, uint32_t nCardNo, bool bIsNetwork, LibMCEnv::PDriverEnvironment pDriverEnvironment);

	~CRTCContext();

	static void loadFirmwareEx(PScanLabSDK pSDK, uint32_t nCardID, const LibMCDriver_ScanLab_uint64 nFirmwareDataBufferSize, const LibMCDriver_ScanLab_uint8* pFirmwareDataBuffer, const LibMCDriver_ScanLab_uint64 nFPGADataBufferSize, const LibMCDriver_ScanLab_uint8* pFPGADataBuffer, const LibMCDriver_ScanLab_uint64 nAuxiliaryDataBufferSize, const LibMCDriver_ScanLab_uint8* pAuxiliaryDataBuffer, bool bIsNetwork, LibMCEnv::PDriverEnvironment pDriverEnvironment);

	static void setCommunicationTimeoutsEx(PScanLabSDK pSDK, uint32_t nCardID, const LibMCDriver_ScanLab_double dInitialTimeout, const LibMCDriver_ScanLab_double dMaxTimeout, const LibMCDriver_ScanLab_double dMultiplier);

	std::string GetIPAddress();

	std::string GetNetmask();

	void setIPAddress(const std::string & sIPAddress, const std::string & sNetmask);

	// setLaserIndex should not be exposed via API from the Context.
	// Laser Index Management should be implemented in the Driver.
	void setLaserIndex (const uint32_t nLaserIndex);

	void LoadFirmware(const LibMCDriver_ScanLab_uint64 nFirmwareDataBufferSize, const LibMCDriver_ScanLab_uint8* pFirmwareDataBuffer, const LibMCDriver_ScanLab_uint64 nFPGADataBufferSize, const LibMCDriver_ScanLab_uint8* pFPGADataBuffer, const LibMCDriver_ScanLab_uint64 nAuxiliaryDataBufferSize, const LibMCDriver_ScanLab_uint8* pAuxiliaryDataBuffer);


	void LoadCorrectionFile(const LibMCDriver_ScanLab_uint64 nCorrectionFileBufferSize, const LibMCDriver_ScanLab_uint8* pCorrectionFileBuffer, const LibMCDriver_ScanLab_uint32 nTableNumber, const LibMCDriver_ScanLab_uint32 nDimension);

	void SelectCorrectionTable(const LibMCDriver_ScanLab_uint32 nTableNumberHeadA, const LibMCDriver_ScanLab_uint32 nTableNumberHeadB) override;

	void SetCorrectionFactors(const LibMCDriver_ScanLab_double dCorrectionFactorXY, const LibMCDriver_ScanLab_double dCorrectionFactorZ) override;

	void ConfigureLists(const LibMCDriver_ScanLab_uint32 nSizeListA, const LibMCDriver_ScanLab_uint32 nSizeListB) override;

	void SetLaserMode(const LibMCDriver_ScanLab::eLaserMode eLaserMode, const LibMCDriver_ScanLab::eLaserPort eLaserPort) override;

	void DisableAutoLaserControl() override;

	void SetLaserControlParameters(const bool DisableLaser, const bool bFinishLaserPulseAfterOn, const bool bPhaseShiftOfLaserSignal, const bool bLaserOnSignalLowActive, const bool bLaserHalfSignalsLowActive, const bool bSetDigitalInOneHighActive, const bool bOutputSynchronizationActive) override;

	void SetLaserPulsesInBits(const LibMCDriver_ScanLab_uint32 nHalfPeriod, const LibMCDriver_ScanLab_uint32 nPulseLength) override;

	void SetLaserPulsesInMicroSeconds(const LibMCDriver_ScanLab_double dHalfPeriod, const LibMCDriver_ScanLab_double dPulseLength) override;

	void SetStandbyInBits(const LibMCDriver_ScanLab_uint32 nHalfPeriod, const LibMCDriver_ScanLab_uint32 nPulseLength) override;

	void SetStandbyInMicroSeconds(const LibMCDriver_ScanLab_double dHalfPeriod, const LibMCDriver_ScanLab_double dPulseLength) override;

	void GetLaserPulsesInBits(LibMCDriver_ScanLab_uint32& nHalfPeriod, LibMCDriver_ScanLab_uint32& nPulseLength) override;

	void GetLaserPulsesInMicroSeconds(LibMCDriver_ScanLab_double& dHalfPeriod, LibMCDriver_ScanLab_double& dPulseLength) override;

	void GetStandbyInBits(LibMCDriver_ScanLab_uint32& nHalfPeriod, LibMCDriver_ScanLab_uint32& nPulseLength) override;
	
	void GetStandbyInMicroSeconds(LibMCDriver_ScanLab_double& dHalfPeriod, LibMCDriver_ScanLab_double& dPulseLength) override;

	void writeLaserTimingsToCard();

	LibMCDriver_ScanLab_uint32 GetSerialNumber() override;

	LibMCDriver_ScanLab_uint32 GetLaserIndex() override;


	void SetStartList(const LibMCDriver_ScanLab_uint32 nListIndex, const LibMCDriver_ScanLab_uint32 nPosition) override;

	void SetEndOfList() override;

	void ExecuteList(const LibMCDriver_ScanLab_uint32 nListIndex, const LibMCDriver_ScanLab_uint32 nPosition) override;

	void SetAutoChangePos(const LibMCDriver_ScanLab_uint32 nPosition) override;

	void SetDefocusFactor(const LibMCDriver_ScanLab_double dValue) override;

	LibMCDriver_ScanLab_double GetDefocusFactor() override;

	void SetDelays(const LibMCDriver_ScanLab_uint32 nMarkDelay, const LibMCDriver_ScanLab_uint32 nJumpDelay, const LibMCDriver_ScanLab_uint32 nPolygonDelay) override;

	void SetLaserDelaysInMicroseconds(const LibMCDriver_ScanLab_double dLaserOnDelay, const LibMCDriver_ScanLab_double dLaserOffDelay) override;

	void SetLaserDelaysInBits(const LibMCDriver_ScanLab_int32 nLaserOnDelay, const LibMCDriver_ScanLab_int32 nLaserOffDelay) override;

	void DrawPolyline(const LibMCDriver_ScanLab_uint64 nPointsBufferSize, const LibMCDriver_ScanLab::sPoint2D * pPointsBuffer, const LibMCDriver_ScanLab_single fMarkSpeed, const LibMCDriver_ScanLab_single fJumpSpeed, const LibMCDriver_ScanLab_single fPower, const LibMCDriver_ScanLab_single fZValue) override;

	void DrawPolylineOIE(const LibMCDriver_ScanLab_uint64 nPointsBufferSize, const LibMCDriver_ScanLab::sPoint2D* pPointsBuffer, const LibMCDriver_ScanLab_single fMarkSpeed, const LibMCDriver_ScanLab_single fJumpSpeed, const LibMCDriver_ScanLab_single fPower, const LibMCDriver_ScanLab_single fZValue, const uint32_t nOIEControlIndex) override;

	void DrawHatches(const LibMCDriver_ScanLab_uint64 nHatchesBufferSize, const LibMCDriver_ScanLab::sHatch2D * pHatchesBuffer, const LibMCDriver_ScanLab_single fMarkSpeed, const LibMCDriver_ScanLab_single fJumpSpeed, const LibMCDriver_ScanLab_single fPower, const LibMCDriver_ScanLab_single fZValue) override;
	
	void DrawHatchesOIE(const LibMCDriver_ScanLab_uint64 nHatchesBufferSize, const LibMCDriver_ScanLab::sHatch2D* pHatchesBuffer, const LibMCDriver_ScanLab_single fMarkSpeed, const LibMCDriver_ScanLab_single fJumpSpeed, const LibMCDriver_ScanLab_single fPower, const LibMCDriver_ScanLab_single fZValue, const uint32_t nOIEControlIndex) override;

	void AddLayerToList(LibMCEnv::PToolpathLayer pLayer, bool bFailIfNonAssignedDataExists) override;

	void WaitForEncoderX(const LibMCDriver_ScanLab_double dPosition, const bool bInPositiveHalfPlane) override;

	void WaitForEncoderY(const LibMCDriver_ScanLab_double dPosition, const bool bInPositiveHalfPlane) override;

	void WaitForEncoderXSteps(const LibMCDriver_ScanLab_int32 nPositionInSteps, const bool bInPositiveHalfPlane) override;

	void WaitForEncoderYSteps(const LibMCDriver_ScanLab_int32 nPositionInSteps, const bool bInPositiveHalfPlane) override;

	void AddCustomDelay(const LibMCDriver_ScanLab_uint32 nDelay) override;

	LibMCDriver_ScanLab_double GetCorrectionFactor() override;

	void GetStatus(bool & bBusy, LibMCDriver_ScanLab_uint32 & nPosition) override;

	void GetHeadStatus(const LibMCDriver_ScanLab_uint32 nHeadNo, bool& bPositionXisOK, bool& bPositionYisOK, bool& bTemperatureisOK, bool& bPowerisOK) override;

	LibMCDriver_ScanLab_uint32 GetInputPointer() override;

	void GetRTCVersion(LibMCDriver_ScanLab_uint32& nRTCVersion, LibMCDriver_ScanLab_uint32& nRTCType, LibMCDriver_ScanLab_uint32& nDLLVersion, LibMCDriver_ScanLab_uint32& nHEXVersion, LibMCDriver_ScanLab_uint32& nBIOSVersion) override;

	void GetStateValues(bool& bLaserIsOn, LibMCDriver_ScanLab_int32& nPositionX, LibMCDriver_ScanLab_int32& nPositionY, LibMCDriver_ScanLab_int32& nPositionZ, LibMCDriver_ScanLab_int32& nCorrectedPositionX, LibMCDriver_ScanLab_int32& nCorrectedPositionY, LibMCDriver_ScanLab_int32& nCorrectedPositionZ, LibMCDriver_ScanLab_int32& nFocusShift, LibMCDriver_ScanLab_int32& nMarkSpeed) override;

	void SetCommunicationTimeouts(const LibMCDriver_ScanLab_double dInitialTimeout, const LibMCDriver_ScanLab_double dMaxTimeout, const LibMCDriver_ScanLab_double dMultiplier) override;

	void GetCommunicationTimeouts(LibMCDriver_ScanLab_double& dInitialTimeout, LibMCDriver_ScanLab_double& dMaxTimeout, LibMCDriver_ScanLab_double& dMultiplier) override;

	void InitializeForOIE(const LibMCDriver_ScanLab_uint64 nSignalChannelsBufferSize, const LibMCDriver_ScanLab_uint32* pSignalChannelsBuffer, const LibMCDriver_ScanLab::eOIEOperationMode eOperationMode) override;

	void DisableOnTheFlyForOIE();

	void SetLaserPinOut(const bool bLaserOut1, const bool bLaserOut2) override;

	void GetLaserPinIn(bool & bLaserOut1, bool & bLaserOut2) override;

	void AddLaserPinOutToList(const bool bLaserOut1, const bool bLaserOut2) override;

	void AddWriteDigitalIOList(const LibMCDriver_ScanLab_uint32 nDigitalOutput) override;

	void AddWriteMaskedDigitalIOList(const LibMCDriver_ScanLab_uint32 nDigitalOutput, const LibMCDriver_ScanLab_uint32 nOutputMask) override;

	void EnableOIE() override;

	void DisableOIE() override;

	INLightAFXProfileSelector* CreateNLightAFXBeamProfileSelector() override;

	IGPIOSequence* AddGPIOSequence(const std::string& sIdentifier) override;

	IGPIOSequence* FindGPIOSequence(const std::string& sIdentifier, const bool bMustExist) override;

	void DeleteGPIOSequence(const std::string& sIdentifier) override;

	void WriteGPIOSequenceToList(const std::string& sIdentifier) override;

	void StartOIEMeasurement() override;

	void StartOIEMeasurementEx(bool bTriggerOnFlag);

	void StopOIEMeasurement() override;

	void SetOIEPIDMode(const LibMCDriver_ScanLab_uint32 nOIEPIDIndex) override;

	void ClearOIEMeasurementTags() override;

	IOIEMeasurementTagMap* RetrieveOIEMeasurementTags() override;

	LibMCDriver_ScanLab_uint32 GetOIEMaxMeasurementTag() override;

	void EnableOIEMeasurementTagging() override;

	void DisableOIEMeasurementTagging() override;

	void MapOIEMeasurementTag(const LibMCDriver_ScanLab_uint32 nMeasurementTag, LibMCDriver_ScanLab_uint32& nPartID, LibMCDriver_ScanLab_uint32& nProfileID, LibMCDriver_ScanLab_uint32& nSegmentID, LibMCDriver_ScanLab_uint32& nVectorID) override;

	void EnableOIEPIDControl() override;

	void DisableOIEPIDControl() override;

	void DisableSkyWriting() override;

	void EnableSkyWritingMode1(const LibMCDriver_ScanLab_double dTimelag, const LibMCDriver_ScanLab_int64 nLaserOnShift, const LibMCDriver_ScanLab_int64 nNPrev, const LibMCDriver_ScanLab_int64 nNPost) override;

	void EnableSkyWritingMode2(const LibMCDriver_ScanLab_double dTimelag, const LibMCDriver_ScanLab_int64 nLaserOnShift, const LibMCDriver_ScanLab_int64 nNPrev, const LibMCDriver_ScanLab_int64 nNPost) override;

	void EnableSkyWritingMode3(const LibMCDriver_ScanLab_double dTimelag, const LibMCDriver_ScanLab_int64 nLaserOnShift, const LibMCDriver_ScanLab_int64 nNPrev, const LibMCDriver_ScanLab_int64 nNPost, const LibMCDriver_ScanLab_double dLimit) override;

	void EnableSkyWritingMode4(const LibMCDriver_ScanLab_double dTimelag, const LibMCDriver_ScanLab_int64 nLaserOnShift, const LibMCDriver_ScanLab_int64 nNPrev, const LibMCDriver_ScanLab_int64 nNPost, const LibMCDriver_ScanLab_double dLimit) override;

	void SetTransformationAngle(const LibMCDriver_ScanLab_double dAngleInDegrees) override;

	void SetTransformationScale(const LibMCDriver_ScanLab_double dScaleFactor) override;

	void SetTransformationOffset(const LibMCDriver_ScanLab_int32 nOffsetX, const LibMCDriver_ScanLab_int32 nOffsetY) override;
	
	void SetTransformationMatrix(const LibMCDriver_ScanLab_double dM11, const LibMCDriver_ScanLab_double dM12, const LibMCDriver_ScanLab_double dM21, const LibMCDriver_ScanLab_double dM22) override;

	bool CheckScanheadConnection() override;

	IRTCRecording* PrepareRecording(const bool bKeepInMemory, const bool bEnableScanheadFeedback, const bool bEnableBacktransformation) override;

	bool HasRecording(const std::string& sUUID) override;

	IRTCRecording* FindRecording(const std::string& sUUID) override;

	bool ClearRecording(const std::string& sUUID) override;

	void ClearAllRecordings() override;

	void EnableTimelagCompensation(const LibMCDriver_ScanLab_uint32 nTimeLagXYInMicroseconds, const LibMCDriver_ScanLab_uint32 nTimeLagZInMicroseconds) override;

	void DisableTimelagCompensation() override;

	void EnableMarkOnTheFly2D(const LibMCDriver_ScanLab_double dScaleXInMMperEncoderSteps, const LibMCDriver_ScanLab_double dScaleYInMMperEncoderSteps) override;

	void DisableMarkOnTheFly2D() override;
	
	bool MarkOnTheFly2DIsEnabled() override; 	

	void Get2DMarkOnTheFlyPosition(LibMCDriver_ScanLab_int32& nPositionX, LibMCDriver_ScanLab_int32& nPositionY) override;

	LibMCDriver_ScanLab_uint32 CheckOnTheFlyError(const bool bFailIfError) override;

	void SetLaserOrigin(const LibMCDriver_ScanLab_double dOriginX, const LibMCDriver_ScanLab_double dOriginY) override;

	void GetLaserOrigin(LibMCDriver_ScanLab_double& dOriginX, LibMCDriver_ScanLab_double& dOriginY) override;

	void SetLaserField(const LibMCDriver_ScanLab_double dMinX, const LibMCDriver_ScanLab_double dMinY, const LibMCDriver_ScanLab_double dMaxX, const LibMCDriver_ScanLab_double dMaxY) override;

	bool GetLaserField(LibMCDriver_ScanLab_double& dMinX, LibMCDriver_ScanLab_double& dMinY, LibMCDriver_ScanLab_double& dMaxX, LibMCDriver_ScanLab_double& dMaxY) override;

	void ResetLaserField() override;

	void EnableRangeChecking() override;

	void DisableRangeChecking() override;

	void AddJumpMovement(const LibMCDriver_ScanLab_double dTargetX, const LibMCDriver_ScanLab_double dTargetY) override;

	void AddMarkMovement(const LibMCDriver_ScanLab_double dTargetX, const LibMCDriver_ScanLab_double dTargetY) override;

	void AddFreeVariable(const LibMCDriver_ScanLab_uint32 nVariableNo, const LibMCDriver_ScanLab_uint32 nValue) override;

	void AddSetPower(const LibMCDriver_ScanLab_single fPower) override;

	void AddSetAnalogOut(const LibMCDriver_ScanLab::eLaserPort eLaserPort, const LibMCDriver_ScanLab_single fOutputValue) override;

	void AddSetDigitalOut(const LibMCDriver_ScanLab::eLaserPort eLaserPort, const LibMCDriver_ScanLab_single fOutputValue) override;

	void AddSetPowerForPIDControl(const LibMCDriver_ScanLab_single fPowerInPercent) override;

	void AddSetJumpSpeed(const LibMCDriver_ScanLab_single fJumpSpeed) override;

	void AddSetMarkSpeed(const LibMCDriver_ScanLab_single fMarkSpeed) override;

	void AddTimedMarkMovement(const LibMCDriver_ScanLab_double dTargetX, const LibMCDriver_ScanLab_double dTargetY, const LibMCDriver_ScanLab_double dDuration) override;

	LibMCDriver_ScanLab_uint32 GetCurrentFreeVariable(const LibMCDriver_ScanLab_uint32 nVariableNo) override;

	LibMCDriver_ScanLab_uint32 GetTimeStamp() override;

	void StopExecution() override;

	bool LaserPowerCalibrationIsLinear() override;

	void GetLaserPowerCalibration(LibMCDriver_ScanLab_double& dLaserPowerAt0Percent, LibMCDriver_ScanLab_double& dLaserPowerAt100Percent, LibMCDriver_ScanLab_uint64 nCalibrationPointsBufferSize, LibMCDriver_ScanLab_uint64* pCalibrationPointsNeededCount, LibMCDriver_ScanLab::sLaserCalibrationPoint* pCalibrationPointsBuffer) override;

	void SetLinearLaserPowerCalibration(const LibMCDriver_ScanLab_double dLaserPowerAt0Percent, const LibMCDriver_ScanLab_double dLaserPowerAt100Percent) override;

	void SetPiecewiseLinearLaserPowerCalibration(const LibMCDriver_ScanLab_double dLaserPowerAt0Percent, const LibMCDriver_ScanLab_double dLaserPowerAt100Percent, const LibMCDriver_ScanLab_uint64 nCalibrationPointsBufferSize, const LibMCDriver_ScanLab::sLaserCalibrationPoint* pCalibrationPointsBuffer) override;

	LibMCDriver_ScanLab_double MapPowerPercentageToWatts(const LibMCDriver_ScanLab_double dLaserPowerInPercent) override;

	LibMCDriver_ScanLab_double MapPowerWattsToPercent(const LibMCDriver_ScanLab_double dLaserPowerInWatts) override;

	void EnableSpatialLaserPowerModulation(const LibMCDriver_ScanLab::SpatialPowerModulationCallback pModulationCallback, const LibMCDriver_ScanLab_pvoid pUserData) override;

	void DisablePowerModulation() override;

	void EnableLineSubdivision(const LibMCDriver_ScanLab_double dLengthThreshold) override;

	void DisableLineSubdivision() override;

	LibMCDriver_ScanLab_int32 ReadMultiMCBSP(const LibMCDriver_ScanLab_uint32 nRegisterNo) override;

	IUARTConnection* CreateUARTConnection(const LibMCDriver_ScanLab_uint32 nDesiredBaudRate) override;

	void EnableScanAhead(const LibMCDriver_ScanLab_uint32 nHeadNo, const LibMCDriver_ScanLab_uint32 nTableNo) override;

	void DisableScanAhead() override;

	void ActivateScanAheadAutoDelays() override;

	void DeactivateScanAheadAutoDelays() override;

	bool ScanAheadAutoDelaysAreActivated() override;

	void SetScanAheadLaserShiftsInMicroseconds(const LibMCDriver_ScanLab_double dLaserOnShiftInMicroSeconds, const LibMCDriver_ScanLab_double dLaserOffShiftInMicroSeconds) override;

	void SetScanAheadLaserShiftsInUnits(const LibMCDriver_ScanLab_int32 nLaserOnShift, const LibMCDriver_ScanLab_int32 nLaserOffShift) override;

	void SetScanAheadLineParameters(const LibMCDriver_ScanLab_uint32 nCornerScale, const LibMCDriver_ScanLab_uint32 nEndScale, const LibMCDriver_ScanLab_uint32 nAccelerationScale) override;

	LibMCDriver_ScanLab_int32 GetRTCChannel(const LibMCDriver_ScanLab::eRTCChannelType eChannelType) override;

	LibMCDriver_ScanLab_int32 GetRTCInternalValue(const LibMCDriver_ScanLab_uint32 nInternalSignalID) override;

	void AddMicrovectorMovement(const LibMCDriver_ScanLab_uint64 nMicrovectorArrayBufferSize, const LibMCDriver_ScanLab::sMicroVector* pMicrovectorArrayBuffer) override;

};


} // namespace Impl
} // namespace LibMCDriver_ScanLab

#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif // __LIBMCDRIVER_SCANLAB_RTCCONTEXT