#pragma once
|
|
#include <vector>
|
|
enum MapDrawType {
|
MapDrawCell=0, MapDrawDefect,
|
MapDrawReviewDefect, MapDrawReviewPath,
|
MapDrawWsiDefect, MapDrawWsiPath,
|
MapDrawSelectedDefect, MapDrawCameraPosition,
|
MapDrawUserPoint, MapDrawUserPath,
|
MapDrawMeasurePoint, MapDrawMeasurePath,
|
MapDrawWsiReflowDefect, MapDrawWsiReflowPath,
|
MapDrawWsiUserDefect, MapDrawWsiUserPath,
|
MapDrawCount
|
};
|
|
struct SDefectFilter
|
{
|
SDefectFilter()
|
{
|
Reset();
|
}
|
|
void Reset()
|
{
|
bMeasurePoint = FALSE;
|
bUseWSI = FALSE;
|
bUseWSIMeasurement = FALSE;
|
bAutoSelectCamera = FALSE;
|
bUseSimulation = FALSE;
|
|
for (int i=0; i<MapDrawCount; i++) pDraw[i] = TRUE;
|
|
nOptionType = 0;
|
|
bOpticDark = TRUE;
|
bOpticBright = TRUE;
|
bOpticDkBr = TRUE;
|
|
bGrayBlack = TRUE;
|
bGrayWhite = TRUE;
|
|
bStackTD=TRUE;
|
bStackSD = TRUE;
|
bStackSP = TRUE;
|
bStackCD = TRUE;
|
bStackPD = TRUE;
|
|
bSizeSmall = TRUE;
|
bSizeMedium = TRUE;
|
bSizeLarge = TRUE;
|
bSizeHuge = TRUE;
|
|
bJudgeOK = TRUE;
|
bJudgeTR = TRUE;
|
bJudgePR = TRUE;
|
bJudgeND = TRUE;
|
|
bProcessNormal = TRUE;
|
bProcessMask = TRUE;
|
bProcessCommon = TRUE;
|
bProcessCrack = TRUE;
|
|
bPositionFront = TRUE;
|
bPositionBack = TRUE;
|
}
|
|
|
BOOL bMeasurePoint;
|
BOOL bUseWSI;
|
BOOL bUseWSIMeasurement;
|
BOOL bAutoSelectCamera;
|
BOOL bUseSimulation;
|
|
BOOL pDraw[MapDrawCount];
|
|
int nOptionType;
|
|
BOOL bOpticDark;
|
BOOL bOpticBright;
|
BOOL bOpticDkBr;
|
|
BOOL bGrayBlack;
|
BOOL bGrayWhite;
|
|
BOOL bStackTD;
|
BOOL bStackSD;
|
BOOL bStackSP;
|
BOOL bStackCD;
|
BOOL bStackPD; //taek
|
|
BOOL bSizeSmall;
|
BOOL bSizeMedium;
|
BOOL bSizeLarge;
|
BOOL bSizeHuge;
|
|
BOOL bJudgeOK;
|
BOOL bJudgeTR;
|
BOOL bJudgePR;
|
/*< LYW 20211220 - #0000 ADD Start >*/
|
BOOL bJudgeND;
|
/*< LYW 20211220 - #0000 ADD End >*/
|
|
BOOL bProcessNormal;
|
BOOL bProcessMask;
|
BOOL bProcessCommon;
|
BOOL bProcessCrack;
|
|
BOOL bPositionFront;
|
BOOL bPositionBack;
|
};
|
|
struct SCameraControl
|
{
|
SCameraControl()
|
{
|
bSelected = FALSE;
|
bAFMTracking = FALSE;
|
bDigitalZoom = FALSE;
|
nCameraControl = 0;
|
nZoomLevel = 0; //tEST 0702
|
strAFMRecipe = _T("");
|
nAFMRecipe = 0;
|
nAFMLevel = 0;
|
nReviewedDefectCount =0;
|
|
nLightLevel = 0;
|
nLightStatus = 100;
|
nLightLevelMin = 0;
|
nLightLevelMax = 255;
|
|
nExposureTime = 500;
|
}
|
|
BOOL bSelected;
|
BOOL bAFMTracking;
|
BOOL bDigitalZoom;
|
int nCameraControl;
|
int nZoomLevel;
|
|
CString strAFMRecipe;
|
int nAFMRecipe;
|
int nAFMLevel;
|
int nReviewedDefectCount;
|
|
int nLightStatus;
|
int nLightLevel;
|
int nLightLevelMin;
|
int nLightLevelMax;
|
|
int nExposureTime;
|
};
|
|
struct SCameraInfo
|
{
|
SCameraInfo()
|
{
|
nFrameWidth = 0;
|
nFrameHeight = 0;
|
nFrameChannels = 0;
|
|
nDirectionX = 1;
|
nDirectionY = 1;
|
|
dOffsetX = 0.0;
|
dOffsetY = 0.0;
|
|
dTriangleGab = 100.0;//
|
dResolution = 1.0; // um/pixel
|
}
|
int nFrameWidth;
|
int nFrameHeight;
|
int nFrameChannels;
|
|
int nDirectionX;
|
int nDirectionY;
|
|
double dOffsetX;
|
double dOffsetY;
|
|
double dTriangleGab;
|
double dResolution;
|
|
};
|
typedef std::vector<SCameraInfo> VectorSCameraInfo;
|
typedef std::vector<SCameraInfo>::iterator VectorSCameraInfoIt;
|
|
struct SMotorPosition
|
{
|
SMotorPosition()
|
{
|
dMotorPosX = 0.0;
|
dMotorPosY = 0.0;
|
dMotorPosZ = 0.0;
|
dGlassPosX = 0.0;
|
dGlassPosY = 0.0;
|
dGlassPosZ = 0.0;
|
|
bUseWSI = FALSE;
|
dWSIOffsetX = 0.0;
|
dWSIOffsetY = 0.0;
|
dWSIPosX = 0.0;
|
dWSIPosY = 0.0;
|
}
|
|
double dMotorPosX;
|
double dMotorPosY;
|
double dMotorPosZ;
|
|
double dGlassPosX;
|
double dGlassPosY;
|
double dGlassPosZ;
|
|
BOOL bUseWSI;
|
double dWSIOffsetX;
|
double dWSIOffsetY;
|
double dWSIPosX;
|
double dWSIPosY;
|
|
};
|
|
|
struct SMotorStatus
|
{
|
SMotorStatus()
|
{
|
lMotorStatusX = 0;
|
lMotorStatusY = 0;
|
lMotorStatusSx = 0;
|
nBitCount = 8;
|
}
|
|
BOOL AxisStatusX(int nIndex)
|
{
|
long nTemp = 1 << nIndex;
|
return (lMotorStatusX & nTemp);
|
}
|
|
BOOL AxisStatusY(int nIndex)
|
{
|
long nTemp = 1 << nIndex;
|
return (lMotorStatusY & nTemp);
|
}
|
|
BOOL AxisStatusSx(int nIndex)
|
{
|
long nTemp = 1 << nIndex;
|
return (lMotorStatusSx & nTemp);
|
}
|
|
long lMotorStatusX;
|
long lMotorStatusY;
|
long lMotorStatusSx;
|
|
int nBitCount;
|
};
|
|
|
struct SThetaMotorInfo
|
{
|
SThetaMotorInfo()
|
{
|
lStatus = 0;
|
dPosition = 0.0;
|
}
|
|
BOOL AxisStatus(int nIndex)
|
{
|
long nTemp = 1 << nIndex;
|
return (lStatus & nTemp);
|
}
|
|
long lStatus;
|
double dPosition;
|
};
|
|
struct SSignalIOStatus
|
{
|
SSignalIOStatus()
|
{
|
Reset();
|
}
|
|
void Reset()
|
{
|
nSignalRead = 0;
|
nSignalWrite = 0;
|
nBitCount = 16;
|
}
|
|
int GetBitCount() const
|
{
|
return nBitCount;
|
}
|
|
BOOL GetReadSignal(int nIndex) const
|
{
|
UINT nTemp = 1 << nIndex;
|
return (nSignalRead & nTemp);
|
}
|
|
BOOL GetWriteSignal(int nIndex) const
|
{
|
UINT nTemp = 1 << nIndex;
|
return (nSignalWrite & nTemp);
|
}
|
|
UINT nSignalRead;
|
UINT nSignalWrite;
|
int nBitCount;
|
};
|
|
struct SAxisIndex
|
{
|
SAxisIndex()
|
{
|
nAxisIndexX = -1;
|
nAxisIndexY = -1;
|
nAxisIndexSx = -1;
|
}
|
int nAxisIndexX;
|
int nAxisIndexY;
|
int nAxisIndexSx;
|
};
|
|
struct SCoordInfo
|
{
|
SCoordInfo()
|
{
|
bStandard = FALSE;
|
nDirectionX = 1;
|
nDirectionY = 1;
|
dDistanceX = 0.0;
|
dDistanceY = 0.0;
|
dOffsetX = 0.0;
|
dOffsetY = 0.0;
|
}
|
|
BOOL bStandard;
|
short nDirectionX;
|
short nDirectionY;
|
double dDistanceX;
|
double dDistanceY;
|
double dOffsetX;
|
double dOffsetY;
|
};
|
|
struct SExternalIndex
|
{
|
SExternalIndex()
|
{
|
nLight_Index = -1;
|
nLight_Channel = 0;
|
nAFM_Index = -1;
|
nAFM_Channel = 0;
|
nRevolver_Index = -1;
|
nRevolver_Channel = 0;
|
nWSI_Index = -1;
|
nWSI_Channel = 0;
|
}
|
|
int nLight_Index;
|
int nLight_Channel;
|
int nAFM_Index;
|
int nAFM_Channel;
|
int nRevolver_Index;
|
int nRevolver_Channel;
|
int nWSI_Index;
|
int nWSI_Channel;
|
};
|
|
struct SMagnificInfo
|
{
|
SMagnificInfo()
|
{
|
strMagnificName = _T("1.0X");
|
dMagnification = 1.0;
|
dMagnificOffsetX = 0.0;
|
dMagnificOffsetY = 0.0;
|
//dTestOffsetX = 0.0;
|
//dTestOffsetY = 0.0;
|
nMsgHomePosition = 0;
|
}
|
|
double dMagnification;
|
CString strMagnificName;
|
double dMagnificOffsetX;
|
double dMagnificOffsetY;
|
//double dTestOffsetX; //배율별 오프셋
|
//double dTestOffsetY;
|
int nMsgHomePosition;
|
};
|
//
|
//struct _ProtocalReviewModlueData
|
//{
|
// _ProtocalReviewModlueData()
|
// {
|
// //모듈 현재 좌표
|
// int m_nModuleGlassPosX; //글라스 X위치
|
// int m_nModuleGlassPosY; //글라스 Y위치
|
//
|
// int m_nPlanDefectNum; //리뷰할 결함 갯수
|
// int m_nReviewedDefectNum; //리뷰한 결함 갯수
|
//
|
// //리뷰할 결함 위치
|
// int m_nPlanReviewPosX;
|
// int m_nPlanReviewPosY;
|
// }
|
//};
|
|
typedef std::vector<SMagnificInfo> VectorSMagnificInfo;
|
typedef std::vector<SMagnificInfo>::iterator VectorSMagnificInfoIt;
|
typedef std::vector<SMagnificInfo>::const_iterator constVectorSMagnificInfoIt;
|
|
|
|
class CModuleStatus
|
{
|
public:
|
CModuleStatus(int nType, int nLens, int nModuleIdx, int nGantryIdx, int nHeaderIdx);
|
virtual ~CModuleStatus(void);
|
void SetStandard(BOOL bStandard) { sCoordInfo.bStandard = bStandard; }
|
void SetSelected(BOOL bSelected);
|
|
int GetModuleType() const { return nModuleType; }
|
int GetLensType() const { return nLensType; }
|
int GetModuleIndex() const { return nModuleIndex; }
|
int GetGantryIndex() const { return nGantryIndex; }
|
int GetHeaderIndex() const { return nHeaderIndex; }
|
BOOL GetStandard() const { return sCoordInfo.bStandard; }
|
BOOL GetSelected() const { return sCameraControl.bSelected; }
|
|
int GetCameraInfoCount() const;
|
int GetMagnificInfoCount() const;
|
|
SExternalIndex* GetExternalIndex();
|
SCameraControl* GetCameraControl();
|
SMotorPosition* GetMotorPosition();
|
SMotorStatus* GetMotorStatus();
|
SAxisIndex* GetAxisIndex();
|
SCoordInfo* GetCoordInfo();
|
SCameraInfo* GetCameraInfo(int nIndex);
|
SCameraInfo* GetCurrentCameraInfo();
|
SMagnificInfo* GetCurrentMagnificInfo();
|
SMagnificInfo* GetMagnificInfo(int nIndex);
|
VectorSCameraInfo* GetVectorCameraInfo();
|
VectorSMagnificInfo* GetVectorSMagnificInfo();
|
|
// _ProtocalReviewModlueData* GetProtocolReviewModuleData(); //181031
|
|
const SExternalIndex* GetExternalIndex() const;
|
const SCameraControl* GetCameraControl() const;
|
const SMotorPosition* GetMotorPosition() const;
|
const SMotorStatus* GetMotorStatus() const;
|
const SAxisIndex* GetAxisIndex() const;
|
const SCoordInfo* GetCoordInfo() const;
|
const SCameraInfo* GetCameraInfo(int nIndex) const;
|
const SCameraInfo* GetCurrentCameraInfo() const;
|
const SMagnificInfo* GetMagnificInfo(int nIndex) const;
|
const SMagnificInfo* GetCurrentMagnificInfo() const;
|
const VectorSCameraInfo* GetVectorCameraInfo() const;
|
const VectorSMagnificInfo* GetVectorSMagnificInfo() const;
|
|
// _ProtocalReviewModlueData* GetProtocolReviewModuleData()const; //181031
|
|
|
void SetRevolverType(int nType);
|
void SetExternalIndex(const SExternalIndex& externalIndex);
|
void SetCameraControl(const SCameraControl& cameraControl);
|
void SetMotorPosition(const SMotorPosition& motorPosition);
|
void SetMotorStatus(const SMotorStatus& motorStatus);
|
void SetAxisIndex(const SAxisIndex& axisIndex);
|
void SetCoordInfo(const SCoordInfo& coordInfo);
|
void SetCameraInfo(int nIndex, const SCameraInfo& cameraInfo);
|
void SetVectorCameraInfo(const VectorSCameraInfo& vectorCameraInfo);
|
void SetMagnificInfo(int nIndex, const SMagnificInfo& magnificInfo);
|
void SetVectorMagnificInfo(const VectorSMagnificInfo& vectorMagnificInfo);
|
|
// void SetProtocolReviewModuleData1(const _ProtocalReviewModlueData& moduleData); //181031
|
|
void AddCameraInfo(const SCameraInfo& cameraInfo);
|
void AddMagnificInfo(const SMagnificInfo& magnificInfo);
|
|
private:
|
int nModuleType;
|
int nLensType;
|
int nModuleIndex;
|
int nGantryIndex;
|
int nHeaderIndex;
|
SExternalIndex sExternalIndex;
|
SCameraControl sCameraControl;
|
SMotorPosition sMotorPosition;
|
SMotorStatus sMotorStatus;
|
SAxisIndex sAxisIndex;
|
SCoordInfo sCoordInfo;
|
|
VectorSMagnificInfo vectorMagnificInfo;
|
VectorSCameraInfo vectorCameraInfo;
|
};
|
typedef std::vector<CModuleStatus> VectorModuleStatus;
|
typedef std::vector<CModuleStatus>::iterator VectorModuleStatusIt;
|
typedef std::vector<CModuleStatus>::const_iterator constVectorModuleStatusIt;
|
|
interface IUpdateSelectedModuleIndex
|
{
|
virtual void UpdateSelectedModuleIndex(int nModuleIndex, const CModuleStatus* pModuleStatus) = 0;
|
};
|
typedef std::vector<IUpdateSelectedModuleIndex*> ObserverUpdateSelectedModuleIndex;
|
typedef std::vector<IUpdateSelectedModuleIndex*>::iterator ObserverUpdateSelectedModuleIndexIt;
|
|
interface IUpdateCameraControl
|
{
|
virtual void UpdateCameraControl(int nModuleIndex, const SCameraControl* pCameraControl, const SCameraInfo* pCameraInfo) = 0;
|
};
|
typedef std::vector<IUpdateCameraControl*> ObserverUpdateCameraControl;
|
typedef std::vector<IUpdateCameraControl*>::iterator ObserverUpdateCameraControlIt;
|
|
interface IUpdateCameraInfo
|
{
|
virtual void UpdateCameraInfo(int nModuleIndex, const SCameraInfo* pCameraInfo) = 0;
|
};
|
typedef std::vector<IUpdateCameraInfo*> ObserverUpdateCameraInfo;
|
typedef std::vector<IUpdateCameraInfo*>::iterator ObserverUpdateCameraInfoIt;
|
|
interface IUpdateMotorPosition
|
{
|
virtual void UpdateMotorPosition(int nModuleIndex, BOOL bSelected, const SMotorPosition* pMotorPosition) = 0;
|
};
|
typedef std::vector<IUpdateMotorPosition*> ObserverUpdateMotorPosition;
|
typedef std::vector<IUpdateMotorPosition*>::iterator ObserverUpdateMotorPositionIt;
|
|
interface IUpdateMotorStatus
|
{
|
virtual void UpdateMotorStatus(int nModuleIndex, const SMotorStatus* pMotorStatus) = 0;
|
};
|
typedef std::vector<IUpdateMotorStatus*> ObserverUpdateMotorStatus;
|
typedef std::vector<IUpdateMotorStatus*>::iterator ObserverUpdateMotorStatusIt;
|
|
interface IUpdateThetaMotorInfo
|
{
|
virtual void UpdateThetaMotorInfo(const SThetaMotorInfo* pThetaMotorInfo) = 0;
|
};
|
typedef std::vector<IUpdateThetaMotorInfo*> ObserverUpdateThetaMotorInfo;
|
typedef std::vector<IUpdateThetaMotorInfo*>::iterator ObserverUpdateThetaMotorInfoIt;
|
|
interface IUpdatePCControlIOSignal
|
{
|
virtual void UpdateSignalIOStatus(const SSignalIOStatus* pSignalIOStatus) = 0;
|
};
|
typedef std::vector<IUpdatePCControlIOSignal*> ObserverUpdatePCControlIOSignal;
|
typedef std::vector<IUpdatePCControlIOSignal*>::iterator ObserverUpdatePCControlIOSignalIt;
|
|
interface IUpdateDefectFilter
|
{
|
virtual void UpdateDefectFilter(const SDefectFilter* pDefectFilter) = 0;
|
};
|
typedef std::vector<IUpdateDefectFilter*> ObserverUpdateDefectFilter;
|
typedef std::vector<IUpdateDefectFilter*>::iterator ObserverUpdateDefectFilterIt;
|
|
interface IUpdateReviewProcessStatus
|
{
|
virtual void UpdateReviewProcessStatus(int nReviewStatus, int nPlanIndex=0) = 0;
|
};
|
typedef std::vector<IUpdateReviewProcessStatus*> ObserverUpdateReviewProcessStatus;
|
typedef std::vector<IUpdateReviewProcessStatus*>::iterator ObserverUpdateReviewProcessStatusIt;
|
|
|
interface IUpdateDefocusList
|
{
|
virtual void UpdateDefocusList() = 0;
|
|
};
|
|
typedef std::vector<IUpdateDefocusList*> ObserverUpdateDefocusList;
|
typedef std::vector<IUpdateDefocusList*>::iterator ObserverUpdateDefocusListIt;
|
