GrpcPrint/PrintS/ScannerCtrl/Scanner.h

#pragma once
#include "../stdafx.h"
#include "../job/BPBinary.h"
#include "../job/MetaData.h"
#include "BaseCtrl.h"
#include "IntelliScanState.h"
#include <vector>
#include <bitset>
#include <unordered_set>

struct polygon {
	float xval, yval;
};

typedef struct DataBlockInfo
{
	BPBinary::BinDataBlock* bdb;
	MetaData::Part* part;
	MetaData::ParameterSet* ps;
	int order;
	int delayTime;
	bool isFinished;
	DataBlockInfo(BPBinary::BinDataBlock* _bdb, MetaData::Part* _part, MetaData::ParameterSet* _ps, int _order, int _delayTime)
		:bdb(_bdb)
		, part(_part)
		, ps(_ps)
		, order(_order)
		, delayTime(_delayTime)
		, isFinished(false)
	{}
} DataBlockInfo;

class OrderMap {

public:
	int m_Order;
	queue<DataBlockInfo*> m_DBS;
};

class Scanner : public BaseCtrl
{
public:
	enum DebugShape
	{
		Cross = 0,
		Square,
		PointLaser,
		DefocusLenth,
		HLine,
		VLine,
		MulPoints,
		MulJumpPoints,
		Vector
	};

public:
	Scanner(ScannerControlCfg* cfg);
	~Scanner();
	virtual void GetInfo(vector<string>& ins) {}

	void AddDataBlock(BPBinary::BinDataBlock* bdb, MetaData::Part* part, MetaData::ParameterSet* ps,int _order,int _delayTime);
	//virtual int GetSerialNum() { return m_LaserCfg->m_Cno; }

	virtual void SetXyOffset(float x, float y) = 0;
	virtual void SetAngle(double angle) = 0;
	virtual void UpdateSetting() = 0;
	virtual void UpdateSkyWriting(bool islist) {}
	virtual void SetSkyWritingEnable(bool benable, bool islist) {}


	virtual void SetXYCorrect(double x, double y)
	{
		m_xfactor = m_kfactor*x;
		m_yfactor = m_kfactor*y;
	}
	
	virtual void SetK(double k){}
	double GetK() { return m_kfactor; }

	ScannerControlCfg* GetConfig() { return m_ScannerControlCfg; }

	bool IsDebugEnable();
	void StartDebugTest();
	void StopDebugTest();

	virtual bool BeginWork();
	virtual bool PauseWork() { return true; }
	virtual void WaitFinish();

	virtual void Clean();

	void StartHeatingScannerTest();
	void StopHeatingScannerTest();
	bool IsHeatingScannerTest();

	void WaitHeatingScanner();

	void StartGetScanInfo();
	void StopGetScanInfo();
	void SetAutoUpdateScanInfo(bool isauto);
	void GetXYScanState(ScanStateXYSCT* scanstate, time_t &t);  //咋办
	virtual void UpdateScannerInfo() {}

	//bool IsUpScanner();

	void static ResetScaningLimit() {
		EnterCriticalSection(&m_SeqCS);
		m_ScaningBit.reset();
		m_SeqDataUnFinishBit.reset();
		m_SupportSeqDataUnFinishBit.reset();
		LeaveCriticalSection(&m_SeqCS);
	}
	virtual void ResetDefocus() = 0;
	void SetPairScan(Scanner* sc) { m_PairScan = sc; }

	virtual void UpdateScanParamByCfg(ScanParamCfg* cfg) = 0;

	ScanStateXY& GetScanStateXY() { return m_ScanState; }

protected:
	static DWORD WINAPI DebugProc(Scanner* _this);
	virtual void ScanDebug() {}
	static DWORD WINAPI ScanProc(Scanner* _this);
	virtual void Scan();
	virtual void ScanSeqV2();
	virtual unsigned int GetMemorySize() = 0;

	virtual void LoadList(unsigned int listid, bool iswait) = 0;
	virtual void EndList() = 0;
	virtual void ListExecute(unsigned int listid, bool iswait) = 0;
	virtual void AutoChangeList() = 0;
	virtual void WaitListFree() = 0;

	virtual void SetScanSpeed(double value) = 0;
	virtual void SetPower(double watt) = 0;
	virtual void SetDefocus(float value) = 0;

	virtual void AddVector(double startx, double starty, double endx, double endy) = 0;
	virtual void ListNop() = 0;
	virtual void JumpAbs(double x, double y) = 0;
	virtual void MarkAbs(double x, double y) = 0;

	virtual void HeatingScannerRun() {}
	virtual void ScannerInfoRun() {}
	static uint64_t GetLimitCodeV2(int ivalue);
	void ScanDataBlock(DataBlockInfo* Printdbi);
	map<int, int>* GetOrderDataCountMap() { return &m_OrderDataCountMap; }
private:
	static DWORD WINAPI ScannerInfoProc(Scanner* _this);
	static DWORD WINAPI HeatingScannerProc(Scanner* _this);
public:
	uint64_t m_JobStartTime;
	bool m_IsOrderSeqV2;
	static map<int, unsigned int> m_CurrentSerio;
protected:
	vector<DataBlockInfo*> m_ScanData;
	vector<DataBlockInfo*> m_SupportSeq;
	queue<DataBlockInfo*> m_ZeroSeq;

	//LaserCfg* m_LaserCfg;
	ScannerControlCfg* m_ScannerControlCfg;
	RunCfg* m_RunCfg;
	ExtCfg* m_ExtCfg;
	HANDLE m_DebugThread;
	bool m_DebugFlag;

	TimePowerCompensateCfg* m_TimePowerCompensateCfg;
	PowerCompensateCfg* m_PowerCompensateCfg;
	CorrectParamCfg* m_CorrectParamCfg;
	SkyWritingCfg* m_SkyWritingCfg;
	ScanParamCfg* m_ScanParamCfg;
	ScanTestCfg* m_ScanTestCfg;
	MachineCfg* m_MachineCfg;
	AlarmCfgWrapper* m_AlarmCfgWrapper;
	IOCfg* m_ScannerIO;

	HANDLE m_Thread;

	HANDLE m_HeatingScannerThread;
	bool m_HeatingScannerRunFlag;

	unsigned int m_list_memory;
	unsigned int m_laser_control;
	double m_output_vfactor;

	double m_kfactor;
	double m_xfactor;
	double m_yfactor;
	double m_zfactor;
	double m_workingdis;
	double m_Angle;
	double m_Radians;

	HANDLE m_InfoThread;
	bool m_InfoRunFlag;
	bool m_IsAutoInfo;
	CRITICAL_SECTION m_ScannerInfoCS;

	time_t m_ScanStateUpdateTime;
	ScanStateXY m_ScanState;

	double m_XOffsetAssist;
	double m_YOffsetAssist;

	//bitset<32> m_SeqBit;
	map<int, int> m_OrderDataCountMap;
	map<int, OrderMap*> m_OrderMap;

	map<string, ScanParamCfg*> m_ScanParamCfgMap;
	//unordered_set<int> m_OrderSeq;

	bool m_IsLeftScan;
	Scanner* m_PairScan;

	static bitset<64> m_ScaningBit;
	static CRITICAL_SECTION m_SeqCS;

	static map<int, uint64_t> m_LimitMap2;
	static map<int, uint64_t> m_HorizontalSeq2;
	static bitset<8> m_SeqDataUnFinishBit;
	static bitset<8> m_SupportSeqDataUnFinishBit;
	static const int m_SeqCount = 32;
	
	
};