#pragma once
|
|
#include "cv.h"
|
#include "highgui.h"
|
#include "opencv.hpp"
|
#include "core.hpp"
|
#include <vector>
|
#include <algorithm>//20140528
|
#include "HardwareSettings.h"
|
|
#define MAX_STRING_LENGTH 1024
|
|
typedef struct tagJUDGEEDGE
|
{
|
BOOL bError; // 错误与否…
|
int nRefernce; // 标准
|
int nTolPlus; // +容许误差
|
int nTolMinus; // -容许误差
|
int nSlant; // 斜线
|
}JUDGEEDGE, *PJUDGEEDGE;
|
|
typedef struct tagUserDefectArea
|
{
|
int x;
|
int y;
|
int area_width;
|
int area_height;
|
int defect_threshold;
|
int defect_dilation;
|
int defect_width;
|
int defect_height;
|
|
void clear(void)
|
{
|
x = 0;
|
y = 0;
|
area_width = 0;
|
area_height = 0;
|
defect_threshold = 0;
|
defect_dilation = 0;
|
defect_width = 0;
|
defect_height = 0;
|
}
|
|
tagUserDefectArea(void)
|
{
|
clear();
|
}
|
}ST_USER_DEFECT_AREA;
|
|
typedef struct tagEXECPTION_AREA
|
{
|
int nAreaType;
|
CRect rc; // 区域位置（Mark 原点）
|
SIZE szErrSize; // 在这个领域适用的Size
|
int nAppDefect; // 适用的Defect种类
|
int nDetectLimitedArea; // 是否使用自定义ROI
|
|
void Init()
|
{
|
nAreaType = 0;
|
nAppDefect = 0;
|
nDetectLimitedArea = 0;
|
rc = CRect(0,0,0,0);
|
szErrSize.cx = 0;
|
szErrSize.cy = 0;
|
};
|
|
void CopyData(tagEXECPTION_AREA *pExp)
|
{
|
nAreaType = pExp->nAreaType;
|
rc = pExp->rc;
|
szErrSize = pExp->szErrSize;
|
nAppDefect = pExp->nAppDefect;
|
nDetectLimitedArea = pExp->nDetectLimitedArea;
|
}
|
|
}EXECPTION_AREA;
|
|
typedef std::vector<EXECPTION_AREA*> EXCEPTION_AREA_LIST;
|
typedef EXCEPTION_AREA_LIST::iterator itEXCEPTION_AREA_LIST;
|
typedef std::vector<ST_USER_DEFECT_AREA> USER_DEFECT_AREA_LIST;
|
typedef std::vector<ST_USER_DEFECT_AREA>::iterator itUSER_DEFECT_AREA_LIST;
|
|
typedef struct stLinkList
|
{
|
CString m_strUpperName;
|
CString m_strStepName;
|
CString m_strInsName;
|
|
public:
|
stLinkList()
|
{
|
reset();
|
}
|
void reset()
|
{
|
m_strUpperName = _T("");
|
m_strStepName = _T("");
|
m_strInsName = _T("");
|
}
|
} LinkList, *pLinkList;
|
typedef std::vector<LinkList*> VectorLinkList;
|
typedef std::vector<LinkList*>::iterator VectorLinkListIt;
|
|
class CRECIPE_INFO_PARM
|
{
|
public:
|
CRECIPE_INFO_PARM();
|
virtual ~CRECIPE_INFO_PARM(void);
|
CRECIPE_INFO_PARM& operator=(CRECIPE_INFO_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
void SetRecipeName(CString strRecipe);
|
void SetRecipeFileName(CString strFile);
|
|
void SetRecipeFileNameBackUp(CString strFile);
|
CString GetRecipeName();
|
CString GetRecipeFileName();
|
|
|
public:
|
TCHAR m_strRecipeName[MAX_STRING_LENGTH]; // 配方名称
|
TCHAR m_strRecipeFileName[MAX_STRING_LENGTH]; // 配方文件名称
|
|
TCHAR m_strRecipeFileNameBackUp[MAX_STRING_LENGTH]; // 配方文件名备份
|
int m_nSoftRevision;
|
};
|
|
typedef struct _STU_EXTRA_CHIP_REG
|
{
|
DimensionDir enSide;
|
BOOL bTB;
|
int nStartY;
|
int nYSize;
|
int nSizeX;
|
int nChamferThres;
|
int nChipThres;
|
int nJudgeBase;
|
int nJudgeDiff;
|
int nChipWidth;
|
int nChipHeight;
|
|
_STU_EXTRA_CHIP_REG()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
enSide = DIMENSION_NONE;
|
nStartY = nYSize = 0;
|
nSizeX = nChamferThres = nChipThres = 0;
|
nJudgeBase = nJudgeDiff = 0;
|
nChipWidth = nChipHeight = 0;
|
}
|
|
} STU_EXTRA_CHIP_REG, *pSTU_EXTRA_CHIP_REG;
|
|
typedef struct _STU_CUTAREA_EXP_POS
|
{
|
DimensionDir enSide;
|
int nPosY;
|
int nSize;
|
ExpRegionType enERType;
|
int nPosX;
|
int nSizeX;
|
|
_STU_CUTAREA_EXP_POS()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
enSide = DIMENSION_NONE;
|
nPosY = nSize = 0;
|
enERType = ER_NONE;
|
nPosX = nSizeX = 0;
|
}
|
|
} STU_CUTAREA_EXP_POS, *pSTU_CUTAREA_EXP_POS;
|
|
typedef struct _STU_CUTAREA_PARM
|
{
|
BOOL m_bCutArea;
|
int m_nThresT,m_nThresB;
|
int m_nSearchWidth;
|
int m_nCalArea;
|
|
_STU_CUTAREA_PARM()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_bCutArea = FALSE;
|
m_nThresT = m_nThresB = m_nSearchWidth = m_nCalArea = 0;
|
}
|
|
} STU_CUTAREA_PARM, *pSTU_CUTAREA_PARM;
|
|
typedef struct _STU_CUTAREA_ALIGN_MARK//20140611
|
{
|
BOOL m_bCutAreaAlignMark;
|
int m_nMarkXPos[2];
|
int m_nMarkXSize[2];
|
int m_nMarkYPos[2];
|
int m_nMarkYSize[2];
|
int m_nAlign2GlassPos;
|
|
_STU_CUTAREA_ALIGN_MARK()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_bCutAreaAlignMark = FALSE;
|
for (int i=0; i<2; i++)
|
{
|
m_nMarkXPos[i] = 0;
|
m_nMarkXSize[i] = 0;
|
m_nMarkYPos[i] = 0;
|
m_nMarkYSize[i] = 0;
|
}
|
m_nAlign2GlassPos = 0;
|
}
|
|
} STU_CUTAREA_ALIGN_MARK, *pSTU_CUTAREA_ALIGN_MARK;
|
|
typedef struct _STU_CHIP_PARM
|
{
|
BOOL m_bChipping;
|
int m_nThresMode; // 0:Fixed,1:First Line,2:Max Line
|
int m_nChippingInsArea;
|
int m_nCrackINsArea;
|
int m_nBrokenInsArea;
|
int m_nChippingThres_T;
|
int m_nChippingThres_T_White;
|
int m_nChipDiffThres;
|
|
int m_nChippingThres_B;
|
int m_nChippingThres_T_L;
|
int m_nChippingThres_B_L;
|
int m_nCrackThres;
|
int m_nBrokenThres;
|
|
// 20.11.14 - Candidate Filtering..
|
int m_nChippingInsMinSize;
|
int m_nCrackInsMinSize;
|
int m_nBrokenInsMinSize;
|
int m_nBurrInsMinSize;
|
|
int m_nChippingInsSideFilterRange;
|
int m_nCrackInsSideFilterRange;
|
int m_nBrokenInsSideFilterRnage;
|
int m_nBurrInsSideFilterRange;
|
|
_STU_CHIP_PARM()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_nThresMode = 0;
|
m_bChipping = FALSE;
|
m_nChippingInsArea = m_nChippingThres_T = m_nChippingThres_B = 0;
|
m_nChippingThres_T_White = 255;
|
m_nCrackINsArea = m_nBrokenInsArea = 0;
|
m_nChippingThres_T_L = m_nChippingThres_B_L = 0;
|
m_nCrackThres = m_nBrokenThres = 0;
|
m_nChipDiffThres = 255;
|
|
m_nChippingInsMinSize = m_nCrackInsMinSize = m_nBrokenInsMinSize = m_nBurrInsMinSize = 5;
|
|
m_nChippingInsSideFilterRange = m_nCrackInsSideFilterRange = m_nBrokenInsSideFilterRnage = m_nBurrInsSideFilterRange = 10;
|
}
|
|
} STU_CHIP_PARM, *pSTU_CHIP_PARM;
|
|
class CCUTAREA_PARM
|
{
|
public:
|
CCUTAREA_PARM();
|
virtual ~CCUTAREA_PARM(void);
|
CCUTAREA_PARM& operator=(CCUTAREA_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
CString GetFileString(void *pValue);
|
BOOL GetCutAreaUse(int iPos);
|
BOOL GetChipUse(int iPos);
|
BOOL GetCutAreaAlignMarkUse(int iPos);//20140611
|
|
pSTU_CUTAREA_PARM GetCutAreaParm(int iPos)
|
{
|
if(iPos>=0 && iPos<MAX_DIMENSION_COUNT)
|
return &m_stuCutAreaParm[iPos];
|
else
|
return NULL;
|
}
|
pSTU_CHIP_PARM GetChipParm(int iPos)
|
{
|
if(iPos>=0 && iPos<MAX_DIMENSION_COUNT)
|
return &m_stuChipParm[iPos];
|
else
|
return NULL;
|
}
|
std::vector<STU_CUTAREA_EXP_POS> *GetExpArea(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_vecCutAreaExpPos[iPos]:NULL;}
|
|
pSTU_CUTAREA_ALIGN_MARK GetCutAreaAlignMark(int iPos)//20140611
|
{
|
if(iPos>=0 && iPos<MAX_DIMENSION_COUNT)
|
return &m_stuCutAreaAlignMark[iPos];
|
else
|
return NULL;
|
}
|
|
public:
|
STU_CUTAREA_PARM m_stuCutAreaParm[MAX_DIMENSION_COUNT];
|
STU_CHIP_PARM m_stuChipParm[MAX_DIMENSION_COUNT];
|
std::vector<STU_CUTAREA_EXP_POS> m_vecCutAreaExpPos[MAX_DIMENSION_COUNT];
|
STU_CUTAREA_ALIGN_MARK m_stuCutAreaAlignMark[MAX_DIMENSION_COUNT];//20140611
|
};
|
|
class CCORNER_PARM
|
{
|
public:
|
CCORNER_PARM();
|
virtual ~CCORNER_PARM(void);
|
CCORNER_PARM& operator=(CCORNER_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
CString GetFileString(void *pValue);
|
|
public:
|
BOOL m_bSaveImage;
|
|
BOOL m_bUse;
|
int m_Thres[MAX_DIMENSION_COUNT];
|
};
|
|
enum DIMEN_FIND_TYPE{DIM_TYPE_PATTERN=0,DIM_TYPE_BMPOS,DIM_TYPE_NONE};
|
typedef struct _STU_DI_POS
|
{
|
int nBasePosX;
|
int nBasePosY;
|
int nSearchX;
|
int nSearchY;
|
|
_STU_DI_POS()
|
{
|
nBasePosX = nBasePosY = nSearchX = nSearchY = 0;
|
}
|
} STU_DI_POS, *pSTU_DI_POS;
|
|
typedef struct _STU_DIMEN_INS_PRM
|
{
|
BOOL m_bUsePos;
|
int m_nCamDir;
|
int m_nJudgeSetSize;
|
int m_nJudgeSizeRange;
|
int m_nOffset;
|
int m_nDetThres;
|
DIMEN_FIND_TYPE m_enDimenType;
|
|
_STU_DIMEN_INS_PRM()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_bUsePos = FALSE;
|
m_nJudgeSetSize = m_nJudgeSizeRange = m_nOffset = m_nDetThres = m_nCamDir = 0;
|
m_enDimenType = DIM_TYPE_NONE;
|
}
|
} STU_DIMEN_INS_PRM, *pSTU_DIMEN_INS_PRM;
|
|
class CDIMENSION_PARM
|
{
|
public:
|
CDIMENSION_PARM();
|
virtual ~CDIMENSION_PARM(void);
|
CDIMENSION_PARM& operator=(CDIMENSION_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
CString GetFileString(void *pValue);
|
BOOL GetDimenUse(int iPos);
|
|
pSTU_DIMEN_INS_PRM GetDimenIns(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_DimInsParm[iPos]:NULL;}
|
std::vector<STU_DI_POS> *GetDimenPos(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_vecDiPosition[iPos]:NULL;}
|
|
public:
|
BOOL m_bSaveDimImage;
|
STU_DIMEN_INS_PRM m_DimInsParm[MAX_DIMENSION_COUNT];
|
std::vector<STU_DI_POS> m_vecDiPosition[MAX_DIMENSION_COUNT];
|
};
|
|
typedef struct _STU_SPLINE_CHIP_POS
|
{
|
enum MAKE_IMAGE_METHOD{MAKE_METHOD_LINEAR=0,MAKE_METHOD_REGRESSION,MAKE_METHOD_NONE};
|
enum MAKE_IMAGE_POS{MAKE_IMAGE_POS_CCUT=0,MAKE_IMAGE_POS_RCUT,MAKE_IMAGE_POS_NONE};
|
enum SPLINE_INS_DIRECTION{SPLINE_INS_DIRECTION_X=0,SPLINE_INS_DIRECTION_Y,SPLINE_INS_DIRECTION_NONE};
|
|
BOOL bUse;
|
int nStartX;
|
int nEndX;
|
int nThres;
|
int nFindThres;
|
int nInsRange;
|
int nSkipDist;
|
MAKE_IMAGE_METHOD emMethod;
|
MAKE_IMAGE_POS emPos;
|
SPLINE_INS_DIRECTION emDir;
|
|
_STU_SPLINE_CHIP_POS()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
bUse = FALSE;
|
nStartX = nEndX = nThres = nFindThres = nInsRange = nSkipDist = 0;
|
emMethod = MAKE_METHOD_NONE;
|
emPos = MAKE_IMAGE_POS_NONE;
|
emDir = SPLINE_INS_DIRECTION_NONE;
|
}
|
} STU_SPLINE_CHIP_POS, *pSTU_SPLINE_CHIP_POS;
|
|
typedef struct _STU_SPLINE_CHIP_PARM
|
{
|
BOOL m_bSplineChip;
|
int m_nChipSize_Y;
|
int m_nChipSize_X;
|
BOOL m_bChipJudgeAnd;
|
int m_nChipInsArea;
|
int m_nChipThres;
|
BOOL m_bCornerUse;
|
int m_nCornerThres;
|
int m_nCornerRange;
|
double m_dChipStartTheta;
|
double m_dChipEndTheta;
|
double m_dChipDistTheta;
|
|
_STU_SPLINE_CHIP_PARM()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_bSplineChip = FALSE;
|
m_bChipJudgeAnd = FALSE;
|
m_nChipSize_X = m_nChipSize_Y = 0;
|
m_nChipInsArea = m_nChipThres = 0;
|
m_bCornerUse = m_nCornerThres = m_nCornerRange = 0;
|
m_dChipDistTheta = m_dChipEndTheta = m_dChipDistTheta = 0;
|
}
|
} STU_SPLINE_CHIP_PARM, *pSTU_SPLINE_CHIP_PARM;
|
|
enum EM_SPLINE_TYPE{EM_SP_CCUT=0,EM_SP_RCUT,EM_SP_NONE};
|
typedef struct _STU_SPLINE_INS_PARM
|
{
|
BOOL m_bSpline;
|
BOOL m_bSplinePointJudge;
|
int m_DetMinPointDist;
|
|
int m_nStartCornerSize_Y;
|
int m_nStartCornerRadius_um;
|
|
int m_nEndCornerSize_Y;
|
int m_nEndCornerRadius_um;
|
|
int m_DetMinDist;
|
int m_nLineThres;
|
EM_SPLINE_TYPE m_emSPType;
|
BOOL m_bSplineCorner;
|
|
int m_nStartChamferSize;
|
int m_nEndChamferSize;
|
|
_STU_SPLINE_INS_PARM()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_bSpline = FALSE;
|
m_bSplinePointJudge = FALSE;
|
m_DetMinPointDist = 50;
|
|
m_nStartCornerSize_Y = 0;
|
m_nStartCornerRadius_um = 0;
|
|
m_nEndCornerSize_Y = 0;
|
m_nEndCornerRadius_um = 0;
|
|
m_nLineThres = 0;
|
m_DetMinDist = 50;
|
m_emSPType = EM_SP_NONE;
|
m_bSplineCorner = FALSE;
|
|
m_nStartChamferSize = -1;
|
m_nEndChamferSize = -1;
|
}
|
} STU_SPLINE_INS_PARM, *pSTU_SPLINE_INS_PARM;
|
|
class CSPLINE_PARM
|
{
|
public:
|
CSPLINE_PARM();
|
virtual ~CSPLINE_PARM(void);
|
CSPLINE_PARM& operator=(CSPLINE_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
CString GetFileString(void *pValue);
|
BOOL GetSplineUse(int iPos);
|
BOOL GetSplineUsePointJudge(int iPos);
|
BOOL GetSplineChipUse(int iPos);
|
|
pSTU_SPLINE_INS_PARM GetSplineIns(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_SP_InsParm[iPos]:NULL;}
|
pSTU_SPLINE_CHIP_PARM GetSplineChipIns(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_SP_ChipParm[iPos]:NULL;}
|
std::vector<STU_SPLINE_CHIP_POS> *GetSplineChipPos(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_vecSplineChip[iPos]:NULL;}
|
|
public:
|
BOOL m_bSP_SaveImg;
|
STU_SPLINE_INS_PARM m_SP_InsParm[MAX_DIMENSION_COUNT];
|
STU_SPLINE_CHIP_PARM m_SP_ChipParm[MAX_DIMENSION_COUNT];
|
std::vector<STU_SPLINE_CHIP_POS> m_vecSplineChip[MAX_DIMENSION_COUNT];
|
};
|
|
typedef struct _STU_NOTCH_POS//20140528
|
{
|
int nPosX;
|
int nPosY;
|
|
_STU_NOTCH_POS()
|
{
|
nPosX = nPosY = 0;
|
}
|
} STU_NOTCH_POS, *pSTU_NOTCH_POS;
|
|
enum EM_NOTCH_INS_DIR{INS_DIR_NORMAL = 0, INS_DIR_DY, INS_DIR_NONE};
|
typedef struct _STU_NOTCH_DATA
|
{
|
BOOL bChipIns;
|
BOOL bSizeIns;
|
int nChipDiff;
|
int nSizeDiff;
|
int nDetThres;
|
int nSizeThres;
|
int nChipThres;
|
double dBlank2EdgeRatio;
|
int nVStart;
|
int nVSize;
|
int nMarkXPos[2];
|
int nMarkXSize[2];
|
int nMarkYPos[2];
|
int nMarkYSize[2];
|
int nAlign2GlassPos;
|
int nJudgeBaseWidth;
|
int nJudgeDiffWidth;
|
|
int nSkipSize;
|
BOOL bSpChipIns[2];
|
int nSpChipSize[2];
|
|
BOOL bPointInsDimensionJudge;//20140528
|
BOOL bPointInsChamferJudge;//20140721
|
int nPointInsAveCount;//20140528
|
|
_STU_NOTCH_DATA()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
bChipIns = bSizeIns = FALSE;
|
nChipDiff = nSizeDiff = 0;
|
nDetThres = nSizeThres = 0;
|
nChipThres = nVStart = nVSize = 0;
|
ZeroMemory(nMarkXPos,sizeof(int)*2);
|
ZeroMemory(nMarkXSize,sizeof(int)*2);
|
ZeroMemory(nMarkYPos,sizeof(int)*2);
|
ZeroMemory(nMarkYSize,sizeof(int)*2);
|
nJudgeBaseWidth = nJudgeDiffWidth = 0;
|
nAlign2GlassPos = 0;
|
nSkipSize = 0;
|
dBlank2EdgeRatio = 0.;
|
ZeroMemory(bSpChipIns,sizeof(BOOL)*2);
|
ZeroMemory(nSpChipSize,sizeof(int)*2);
|
bPointInsDimensionJudge = FALSE;//20140721
|
bPointInsChamferJudge = FALSE;//20140721
|
nPointInsAveCount = 5;
|
}
|
|
} STU_NOTCH_DATA, *pSTU_NOTCH_DATA;
|
|
#define MAX_NOTCH_INS_POS_COUNT 100//20140528
|
class CNOTCH_PARM
|
{
|
public:
|
CNOTCH_PARM();
|
virtual ~CNOTCH_PARM(void);
|
CNOTCH_PARM& operator=(CNOTCH_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
CString GetFileString(void *pValue);
|
BOOL GetNotchSizeUse(int iPos);
|
BOOL GetNotchChipUse(int iPos);
|
|
pSTU_NOTCH_DATA GetNotchIns(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_NotchParm[iPos]:NULL;}
|
std::vector<CPoint> *GetNotchPos(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_vecNotchPosition[iPos]:NULL;}//20140528
|
|
public:
|
STU_NOTCH_DATA m_NotchParm[MAX_DIMENSION_COUNT];
|
std::vector<CPoint> m_vecNotchPosition[MAX_DIMENSION_COUNT];//20140528
|
};
|
|
typedef struct _SortCPointYPos {//20140528
|
BOOL operator() (CPoint pt1, CPoint pt2) { return (pt1.y < pt2.y);}
|
} SortCPointYPos;
|
|
|
class CVCR_PARM
|
{
|
public:
|
CVCR_PARM();
|
virtual ~CVCR_PARM(void);
|
CVCR_PARM& operator=(CVCR_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
CString GetFileString(void *pValue);
|
CRect GetRect();
|
|
public:
|
BOOL m_bVCR;
|
BOOL m_bAlarm;
|
BOOL m_bSetResult;
|
int m_nVCPosY;
|
int m_nVCPosX;
|
int m_nHeight;
|
int m_nWidth;
|
BOOL m_nCamDir;
|
};
|
|
class CETC_PARM
|
{
|
public:
|
CETC_PARM();
|
virtual ~CETC_PARM(void);
|
CETC_PARM& operator=(CETC_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile,int nIdx);
|
BOOL WriteRecipe(CConfig *pFile,int nIdx);
|
|
public:
|
void Reset();
|
CString GetFileString(void *pValue,int nIdx);
|
|
public:
|
int m_nGlassFindthres_Top;
|
int m_nGlassFindHeight_Top;
|
int m_nGlassFindthres_Left;
|
int m_nGlassFindWidth_Left;
|
int m_nGlassLeftLineMargin[2];
|
};
|
//park
|
enum LIGHT_CONTROL_METHOD{LIGHT_CONTROL_METHOD_AUTO=0,LIGHT_CONTROL_METHOD_MANUAL,LIGHT_CONTROL_METHOD_NONE};
|
|
#define LIGHT_CONTROL_COUNT 2
|
#define LIGHT_CONTROL_CH_COUNT 4
|
|
class CLIGHT_PARM
|
{
|
public:
|
CLIGHT_PARM();
|
virtual ~CLIGHT_PARM(void);
|
CLIGHT_PARM& operator=(CLIGHT_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
CString GetFileString(void *pValue);
|
|
public:
|
BOOL m_bLightControl;
|
int m_nContValue[LIGHT_CONTROL_COUNT][LIGHT_CONTROL_CH_COUNT];
|
|
void SetContValue(int nIdx, int nCh, int nContValue);
|
};
|
|
enum EM_GLASSTYPE_COMP{GLASSTYPE_RCUT=0,GLASSTYPE_CCUT,GLASSTYPE_NCUT};
|
class CGLASS_INFO_PARM
|
{
|
public:
|
CGLASS_INFO_PARM();
|
virtual ~CGLASS_INFO_PARM(void);
|
CGLASS_INFO_PARM& operator=(CGLASS_INFO_PARM& rh);
|
|
public:
|
void Reset();
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
double GetOneScanTime(){return m_dOneScanTime;}
|
BOOL GetOneSacnMode(){return m_bOneScanMode;}
|
|
protected:
|
CString GetFileString(void *pValue);
|
|
public:
|
int m_nGlassSizeX;
|
int m_nGlassSizeY;
|
int m_nGlassImageSize;
|
int m_nGlassImageLeftMargin;
|
BOOL m_bGlassFullImageSave;
|
BOOL m_bAllImageSave;
|
GlassDirection m_OriginDirection;
|
CString m_strDisp;
|
BOOL m_bGlassDefaultImageSave;
|
BOOL m_bOneScanMode;
|
BOOL m_bPanelReverse;
|
double m_dOneScanTime;
|
EM_GLASSTYPE_COMP m_emGlassType;
|
int m_nFindGlassStartOffset[MAX_DIMENSION_COUNT];
|
int m_nGlassFindHorPos[MAX_DIMENSION_COUNT];
|
};
|
|
typedef struct stuDEFECT_CONDITION
|
{
|
BOOL bError; // 是否发生错误
|
BOOL bConditionAND; // TRUE: Width和Height都满足才会发生Error
|
SIZE szDefect; // Defect大小
|
int nMerge; // 合并
|
|
stuDEFECT_CONDITION(void)
|
{
|
bError = FALSE;
|
bConditionAND = FALSE;
|
szDefect.cx = 0;
|
szDefect.cy = 0;
|
nMerge = 0;
|
}
|
}DEFECT_CONDITION;
|
|
typedef struct tagJUDGE_DEFECT
|
{
|
|
DEFECT_CONDITION Chip_Side;
|
DEFECT_CONDITION Burr_Side;
|
DEFECT_CONDITION Broken;
|
DEFECT_CONDITION Bevel;
|
DEFECT_CONDITION Chip_CF;
|
DEFECT_CONDITION Burr_CF;
|
DEFECT_CONDITION Crack;
|
DEFECT_CONDITION Compare_Panel;
|
|
int nRangeStart;
|
int nRangeEnd;
|
}JUDGE_DEFECT, *PJUDGE_DEFECT;
|
|
typedef struct tagJUDGE_EDGE
|
{
|
BOOL bError; // 错误与否
|
int nRefernce; // 标准
|
int nTolPlus; // +容许误差
|
int nTolMinus; // -容许误差
|
}JUDGE_EDGE, *PJUDGE_EDGE;
|
|
typedef struct tagJUDGE_AVG
|
{
|
BOOL bUse;
|
int nDiff;
|
}JUDGE_AVG, *PJUDGE_AVG;
|
|
#define MAX_MARKER_COUNT 3
|
#define MAX_POS_MARKER_COUNT 3
|
class CINSPECT_JUDGEMENT_PARM
|
{
|
public:
|
CINSPECT_JUDGEMENT_PARM(void);
|
virtual ~CINSPECT_JUDGEMENT_PARM(void);
|
CINSPECT_JUDGEMENT_PARM& operator=(CINSPECT_JUDGEMENT_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
|
public:
|
JUDGE_EDGE corner_X[MAX_PANEL_SIDE];
|
JUDGE_EDGE corner_Y[MAX_PANEL_SIDE];
|
JUDGE_EDGE grind[2][MAX_PANEL_SIDE];
|
JUDGE_EDGE chamfer[2][MAX_PANEL_SIDE];
|
JUDGE_EDGE cutting[2][MAX_PANEL_SIDE]; // 截断量判定标准
|
CPoint ptAlign[MAX_MARKER_COUNT][MAX_DIMENSION_COUNT];
|
JUDGE_EDGE EdgeToSubMark[MAX_DIMENSION_COUNT];
|
JUDGE_DEFECT defect[MAX_DIMENSION_COUNT][3];
|
JUDGE_EDGE Dimension[MAX_DIMENSION_COUNT];
|
int nCFGrind[MAX_PANEL_SIDE];
|
BOOL bUseLengthDepthComp;
|
int nCornerJugeLength;
|
int nCornerJugeDepth;
|
BOOL bCoordProUse;
|
JUDGE_AVG AvgProfile[MAX_DIMENSION_COUNT];
|
JUDGE_AVG AvgChamfer[MAX_DIMENSION_COUNT];
|
|
int nMinProfileNgCount[MAX_DIMENSION_COUNT];
|
int nMinProfileNgCount_MinDiff[MAX_DIMENSION_COUNT];
|
};
|
|
class CINSPECT_INFO_PARM
|
{
|
public:
|
CINSPECT_INFO_PARM(void);
|
virtual ~CINSPECT_INFO_PARM(void);
|
CINSPECT_INFO_PARM& operator=(CINSPECT_INFO_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
|
BOOL GetCutAreaUse(DimensionDir enDimen){return m_CutAreaParm.GetCutAreaUse((int)enDimen);}
|
BOOL GetCutAreaAlignMarkUse(DimensionDir enDimen){return m_CutAreaParm.GetCutAreaAlignMarkUse((int)enDimen);}
|
BOOL GetChipUse(DimensionDir enDimen){return m_CutAreaParm.GetChipUse((int)enDimen);}
|
BOOL GetDimenUse(DimensionDir enDimen){return m_DimensionParm.GetDimenUse((int)enDimen);}
|
BOOL GetSplineUse(DimensionDir enDimen){return m_SplineParm.GetSplineUse((int)enDimen);}
|
BOOL GetSplineChipUse(DimensionDir enDimen){return m_SplineParm.GetSplineChipUse((int)enDimen);}
|
BOOL GetNotchSizeUse(DimensionDir enDimen){return m_NotchParm.GetNotchSizeUse((int)enDimen);}
|
BOOL GetNotchChipUse(DimensionDir enDimen){return m_NotchParm.GetNotchChipUse((int)enDimen);}
|
BOOL GetSplineUsePointJudge(int iPos){return m_SplineParm.GetSplineUsePointJudge(iPos);}
|
|
CCUTAREA_PARM *GetCutParm(){return &m_CutAreaParm;}
|
pSTU_CUTAREA_PARM GetCutAreaParm(DimensionDir enDimen){return m_CutAreaParm.GetCutAreaParm((int)enDimen);}
|
pSTU_CHIP_PARM GetChipParm(DimensionDir enDimen){return m_CutAreaParm.GetChipParm((int)enDimen);}
|
std::vector<STU_CUTAREA_EXP_POS> *GetExpArea(DimensionDir enDimen){return m_CutAreaParm.GetExpArea((int)enDimen);}
|
pSTU_CUTAREA_ALIGN_MARK GetCutAreaAlignMark(DimensionDir enDimen){return m_CutAreaParm.GetCutAreaAlignMark((int)enDimen);}//20140611
|
|
CCORNER_PARM *GetCornerParm(){return &m_CornerParm;}
|
|
CDIMENSION_PARM *GetDimensionParm(){return &m_DimensionParm;}
|
pSTU_DIMEN_INS_PRM GetDimenIns(DimensionDir enDimen){return m_DimensionParm.GetDimenIns((int)enDimen);}
|
std::vector<STU_DI_POS> *GetDimenPos(DimensionDir enDimen){return m_DimensionParm.GetDimenPos((int)enDimen);}
|
|
CSPLINE_PARM *GetSplineParm(){return &m_SplineParm;}
|
pSTU_SPLINE_INS_PARM GetSplineIns(DimensionDir enDimen){return m_SplineParm.GetSplineIns((int)enDimen);}
|
pSTU_SPLINE_CHIP_PARM GetSplineChipIns(DimensionDir enDimen){return m_SplineParm.GetSplineChipIns((int)enDimen);}
|
std::vector<STU_SPLINE_CHIP_POS> *GetSplineChipPos(DimensionDir enDimen){return m_SplineParm.GetSplineChipPos((int)enDimen);}
|
|
CNOTCH_PARM *GetNotchParm(){return &m_NotchParm;}
|
pSTU_NOTCH_DATA GetNotchIns(DimensionDir enDimen){return m_NotchParm.GetNotchIns((int)enDimen);}
|
|
public:
|
CVCR_PARM m_VCRParm;
|
CCUTAREA_PARM m_CutAreaParm;
|
CCORNER_PARM m_CornerParm;
|
CDIMENSION_PARM m_DimensionParm;
|
CSPLINE_PARM m_SplineParm;
|
CNOTCH_PARM m_NotchParm;
|
std::vector<STU_EXTRA_CHIP_REG> m_vecExtraChipReg;
|
|
int m_nRCutThresGlass[MAX_DIMENSION_COUNT][2];
|
int m_nRCutThresChamfer[MAX_DIMENSION_COUNT][2];
|
};
|
|
|
class CALIGNMARK_PARM
|
{
|
public:
|
CALIGNMARK_PARM();
|
virtual ~CALIGNMARK_PARM(void);
|
CALIGNMARK_PARM& operator=(CALIGNMARK_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile,int nIdx);
|
BOOL WriteRecipe(CConfig *pFile,int nIdx);
|
|
public:
|
void Reset();
|
void MarkImgDelete();
|
|
public:
|
BOOL m_bIsMark[MAX_MARKER_COUNT]; // 是否存在标志?
|
int m_nMarkType[MAX_MARKER_COUNT];
|
double m_dMarkMatchingRate[MAX_MARKER_COUNT][MAX_POS_MARKER_COUNT];
|
JUDGEEDGE m_JudgeAlign;
|
IplImage *IpMarkImg[MAX_MARKER_COUNT][MAX_POS_MARKER_COUNT];
|
};
|
|
enum EM_INS_TYPE{EM_INS_EDGE=0,EM_INS_CORNER,EM_INS_DIMENSION,EM_INS_SPLINE,EM_INS_NOTCH,EM_INS_SPLINE_POINT_JUDGE};
|
|
// Hole Inspsect Parameter
|
struct HOLE_INS_PARM
|
{
|
int m_nSideIdx;
|
CRect m_rtArea;
|
CRect m_rtHoleArea;
|
int m_nThreshold;
|
int m_nOffset;
|
int m_nMinSize;
|
double m_dMatRate;
|
CString m_strTemplatePath;
|
};
|
|
class CHOLEINSPECT_PARM
|
{
|
public:
|
CHOLEINSPECT_PARM() {Reset();};
|
virtual ~CHOLEINSPECT_PARM(void) {Reset();};
|
CHOLEINSPECT_PARM& operator=(CHOLEINSPECT_PARM& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
|
public:
|
int m_nTotalHoleCount;
|
vector<HOLE_INS_PARM> m_vecHoleInsParam;
|
};
|
// End of Hole Inspsect Parameter
|
|
typedef struct tagProfileSetting
|
{
|
double x;
|
double y;
|
double radius;
|
double plus;
|
double minus;
|
BOOL use;
|
|
tagProfileSetting(void)
|
{
|
x = 0.0;
|
y = 0.0;
|
radius = 0.0;
|
plus = 50.0;
|
minus = 50.0;
|
use = TRUE;
|
}
|
}ST_PROFILE_SETTING;
|
|
typedef struct tagChamferSetting
|
{
|
double reference;
|
double plus;
|
double minus;
|
BOOL use;
|
|
tagChamferSetting(void)
|
{
|
reference = 100.0;
|
plus = 50.0;
|
minus = 50.0;
|
use = TRUE;
|
}
|
}ST_CHAMFER_SETTING;
|
|
|
|
class CProfileInspect_Prm
|
{
|
public:
|
CProfileInspect_Prm() {Reset();};
|
virtual ~CProfileInspect_Prm(void) {Reset();};
|
CProfileInspect_Prm& operator=(CProfileInspect_Prm& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
|
public:
|
void Reset();
|
|
public:
|
BOOL m_bUseOriginAlignKey[MAX_DIMENSION_COUNT];
|
int m_nOriginAlignKeyOffsetX[MAX_DIMENSION_COUNT];
|
int m_nOriginAlignKeyOffsetY[MAX_DIMENSION_COUNT];
|
int m_nOriginAlignKeyOffsetDwX[MAX_DIMENSION_COUNT];
|
int m_nOriginAlignKeyOffsetDwY[MAX_DIMENSION_COUNT];
|
|
int m_nCADOffsetX[MAX_DIMENSION_COUNT];
|
int m_nCADOffsetY[MAX_DIMENSION_COUNT];
|
ST_PROFILE_SETTING m_stProfile[MAX_PROFILE_SETTING_COUNT];
|
ST_CHAMFER_SETTING m_stCamferUp[MAX_PROFILE_SETTING_COUNT];
|
ST_CHAMFER_SETTING m_stCamferDn[MAX_PROFILE_SETTING_COUNT];
|
|
double m_dConvResolution[MAX_DIMENSION_COUNT][MAX_STAGE_HAND_COUNT];
|
double m_dScanResolution[MAX_DIMENSION_COUNT][MAX_STAGE_HAND_COUNT];
|
};
|
|
class CGlassRecipe
|
{
|
public:
|
CGlassRecipe(void);
|
virtual ~CGlassRecipe(void);
|
CGlassRecipe& operator=(CGlassRecipe& rh);
|
|
public:
|
BOOL ReadRecipe(CConfig *pFile);
|
BOOL WriteRecipe(CConfig *pFile);
|
BOOL WriteRecipeFile();
|
BOOL WriteRecipeFileBackUp();
|
BOOL MakeRecipeFileName(CString strRecipe);
|
BOOL MakeRecipeFileNameBackUp(CString strRecipe);
|
BOOL ReadRecipeFile();
|
|
int GetLightValue(int iCon,int iCh);
|
CINSPECT_INFO_PARM *GetInspectInfo(){return &m_InspectInfoParm;}
|
CALIGNMARK_PARM *GetAlignMarkPrm(DimensionDir eDim);
|
BOOL LoadAlignMark();
|
BOOL SaveAlignMark();
|
|
pSTU_CUTAREA_PARM GetCutAreaPrm(DimensionDir eDim);
|
CCORNER_PARM *GetCornerParm(){return m_InspectInfoParm.GetCornerParm();}
|
|
CETC_PARM *GetEtcPrm(DimensionDir eDim);
|
|
CINSPECT_JUDGEMENT_PARM *GetJudgePrm(){return &m_Judgement;}
|
USER_DEFECT_AREA_LIST *GetUserDefectList(DimensionDir eDim){return &m_UserDefectPrm[eDim];}
|
EXCEPTION_AREA_LIST *GetExpAreaList(DimensionDir eDim){return &m_ExpAreaPrm[eDim];}
|
CHOLEINSPECT_PARM *GetHolePrm(){return &m_HoleInspectParm;}
|
|
CDIMENSION_PARM *GetDimensionParm(){return m_InspectInfoParm.GetDimensionParm();}
|
CProfileInspect_Prm *GetProfileParm(){return &m_ProfilePrm;}
|
CGLASS_INFO_PARM *GetGlassInfo(){return &m_GlassParm;}
|
|
CString GetRecipeName();
|
void Reset();
|
|
BOOL Save_Image(CString strPath,IplImage *IpImg);
|
BOOL Load_Image(CString strPath,IplImage **pIpImg);
|
|
BOOL LoadUserDefectList();
|
BOOL SaveUserDefectList();
|
BOOL LoadExpAreaList();
|
BOOL SaveExpAreaList();
|
void DeleteExpAreaList();
|
|
public:
|
CRECIPE_INFO_PARM m_RecieParm;
|
CGLASS_INFO_PARM m_GlassParm;
|
CETC_PARM m_ETCParm[MAX_DIMENSION_COUNT];
|
CLIGHT_PARM m_LightParm;
|
CALIGNMARK_PARM m_AlignMarkParm[MAX_DIMENSION_COUNT];
|
USER_DEFECT_AREA_LIST m_UserDefectPrm[MAX_DIMENSION_COUNT];
|
EXCEPTION_AREA_LIST m_ExpAreaPrm[MAX_DIMENSION_COUNT];
|
|
CINSPECT_INFO_PARM m_InspectInfoParm;
|
|
CINSPECT_JUDGEMENT_PARM m_Judgement;
|
CHOLEINSPECT_PARM m_HoleInspectParm;
|
CProfileInspect_Prm m_ProfilePrm;
|
|
protected:
|
CConfig m_RecipeFile;
|
};
|
