// EdgeFind.h: interface for the CEdgeFind class.
|
//
|
//////////////////////////////////////////////////////////////////////
|
|
#if !defined(AFX_EDGEFIND_H__390230EE_3748_47C9_B543_04276FAFACA4__INCLUDED_)
|
#define AFX_EDGEFIND_H__390230EE_3748_47C9_B543_04276FAFACA4__INCLUDED_
|
|
#if _MSC_VER > 1000
|
#pragma once
|
#endif // _MSC_VER > 1000
|
|
#include "EDGE_DIPM.h"
|
|
class CSISBuffer;
|
class CEdgeProc;
|
|
enum EDGELINE_DIR{DIR_HORIZONTAL=0,DIR_VERTICAL};
|
enum EDGELINE_POLAR{POLAR_WTOB=0,POLAR_BTOW,POLAR_ANY};
|
enum enEdgeFindType{EDGE_MAXCONTRAST=0,EDGE_FIRSTEDGE,EDGE_PROJECTION,EDGE_NONE};
|
enum EdgeSearchType { SearchTypeMinMax, SearchTypeOut2In, SearchTypeIn2Out };
|
enum EdgeSignalType { EdgeTypeNegative=0, EdgeTypePositive, EdgeTypeNone };
|
enum EdgeResultType { EdgeResultMid=0, EdgeResultLeft, EdgeResultRight, };
|
enum SubPixelType { SubPixelLinear=0, SubPixelQuadratic, SubPixelRegression };
|
enum PreProcessType { PreProcNone=0, PreProcSobel };
|
enum TriangleResult { ImageFailModel=-1, ImageFailSource=-2, ImageFailSub=-3, ImageFailBandModel=-4, ImageFailBandSource=-5,
|
RecipeFailModel=-6, RecipeFailMarker=-7, RecipeFailFormula=-8,
|
ProcessFailModel=-9, ProcessFailMarker=-10, ProcessFailFormula=-11,
|
ResultFailModel=-12, ResultFailMarker=-13, ResultFailFormula=-14,
|
EdgeFailLeft=-15, EdgeFailRight=-16, PreProcessFail=-17,
|
ProcessSuccess=1, ProcessNone=0 };
|
|
//Projection data
|
#ifndef _IMPROJ_
|
#define _IMPROJ_
|
enum PROJECTION_TYPE{PROJECTION_VERTICAL=0,PROJECTION_HORIZONTAL};
|
typedef struct ImProj{
|
int x;
|
int f;
|
} IMPROJ, *LPIMPROJ;
|
#endif
|
|
class CPolynomial
|
{
|
public:
|
CPolynomial() { Reset(); }
|
CPolynomial(int degree, double coef)
|
{
|
nDegree = degree;
|
dCoef = coef;
|
}
|
~CPolynomial() { Reset(); }
|
void Reset()
|
{
|
nDegree = 0;
|
dCoef = 0.0;
|
}
|
int nDegree;
|
double dCoef;
|
};
|
|
typedef std::list<CPolynomial*> ListPolynomial;
|
typedef std::list<CPolynomial*>::iterator ListPolynomialIt;
|
|
typedef std::vector<double> VectorDouble;
|
typedef std::vector<double>::iterator VectorDoubleIt;
|
|
typedef std::vector<int> VectorInteger;
|
typedef std::vector<int>::iterator VectorIntegerIt;
|
|
class AFX_EXT_CLASS CEdgeResult
|
{
|
public:
|
CEdgeResult() { Reset(); }
|
|
CEdgeResult(int indexValue, int signalValue, int positionValue, double edgeValue)
|
{
|
|
nIndex = indexValue;
|
nSignal = signalValue;
|
nEdgePosition = positionValue;
|
dEdgeValue = edgeValue;
|
|
nEdgeType = EdgeResultMid;
|
dPosition = 0.0;
|
dStrength = 0.0;
|
|
nLeftPosition = positionValue;
|
nRightPosition = positionValue;
|
}
|
|
CEdgeResult(int indexValue, int signalValue, double positionValue, double strengthValue)
|
{
|
|
nIndex = indexValue;
|
nSignal = signalValue;
|
dPosition = positionValue;
|
dStrength = strengthValue;
|
|
nEdgeType = EdgeResultMid;
|
nLeftPosition = 0;
|
nRightPosition = 0;
|
}
|
|
~CEdgeResult() { Reset(); }
|
|
void Reset()
|
{
|
nEdgeType = EdgeResultMid;
|
nIndex = -1;
|
nSignal = EdgeTypeNone;
|
nEdgePosition = 0;
|
dEdgeValue = 0.0;
|
dPosition = 0.0;
|
dStrength = 0.0;
|
|
nLeftPosition = 0;
|
nRightPosition = 0;
|
}
|
|
int nEdgeType;
|
int nIndex;
|
int nSignal;
|
int nEdgePosition;
|
double dEdgeValue;
|
|
int nLeftPosition;
|
int nRightPosition;
|
|
double dPosition;
|
double dStrength;
|
};
|
typedef std::vector<CEdgeResult> VectorEdgeResult;
|
typedef std::vector<CEdgeResult>::iterator VectorEdgeResultIt;
|
|
class AFX_EXT_CLASS CEdgeFind
|
{
|
CSISBuffer *m_Buffer;
|
LPIMPROJ m_pHproj;
|
LPIMPROJ m_pVproj;
|
VectorDouble m_vectorEdgeData;
|
VectorInteger m_vectorEdgeType;
|
VectorDouble m_vectorImageData;
|
VectorEdgeResult m_vectorEdgeResult;
|
|
public:
|
CEdgeFind();
|
virtual ~CEdgeFind();
|
|
public:
|
int Find_LeftEdge(CSISBuffer *pBuffer, double pitch, int threshold, double rDefect, int nContinue);
|
int Find_RightEdge(CSISBuffer *pBuffer, double pitch, int threshold, double rDefect, int nContinue);
|
|
public:
|
int Find_LeftCanny(CSISBuffer *pBuffer,int nThres);
|
double FindLine_H(LPBYTE pImg,CSize szImg,CRect &rectIns,int nThres,EDGELINE_POLAR enDir,EdgeSignalType enSignalType,enEdgeFindType enFind);
|
double FindLine_V(LPBYTE pImg,CSize szImg,CRect &rectIns,int nThres,EDGELINE_POLAR enDir,EdgeSignalType enSignalType,enEdgeFindType enFind,BOOL bTop);
|
double FindGlassHorizontalLine(LPBYTE pImg,CSize szImg,CRect &rectIns,int nThres,BOOL bDir, int nDist = 20);
|
double FindGlassVerticalLine(LPBYTE pImg,CSize szImg,CRect &rectIns,int nThres,BOOL bDir,int nDist = 10);
|
double FindLineSubPixel(LPBYTE pImg,CSize szImg,CRect &rectIns,int nPosiThres,int nNegaThres,EDGELINE_DIR enDir,EdgeSearchType enSearchType,EdgeSignalType enSignalType,int nKernelSize=2);
|
|
protected:
|
void AssertOnFrameRect(CRect &rect,CSize szImg=CSize(0,0));
|
BOOL FV_ProjGet(LPBYTE src,CSize szImg, CRect &rect, PROJECTION_TYPE type, IMPROJ* res, ULONG* max, ULONG* min);
|
int FindMaxContrastEx(IMPROJ* src, int nStart,int nEnd, long Width, long Height, EDGELINE_POLAR enDir, long Thresh,BOOL bForward=TRUE);
|
int FindFirstEdge(IMPROJ* src, int nStart,int nEnd, long Width, long Height, EDGELINE_POLAR enDir, long Thresh,BOOL bForward=TRUE);
|
int FindMaxContrast(CSISBuffer &bufferOrg,CRect rect,BOOL bHor,int &nMaxDiff,BOOL bForward=TRUE);
|
BOOL QuadraticRegression(VectorDouble& vectorX, VectorDouble& vectorY, double& a0, double& a1, double& a2);
|
bool parabolicInterpolate(double hm, double h0, double hp, double *c);
|
BOOL FindGlssEdgeLine(int &nPos,CRect rect,LPIMPROJ pProj,BOOL bDir,PROJECTION_TYPE nType,int nThres,int nContiValue,int nDist);
|
|
protected:
|
BOOL CalculateInterpolateLinear(CEdgeResult& edgeResult, double dEdgeThreshold);
|
BOOL CalculateInterpolateQuadratic(CEdgeResult& edgeResult);
|
BOOL CalculateInterpolateRegression(CEdgeResult& edgeResult);
|
void CalculateEdgePosition(int nSubPixelType, double dPosiThres, double dNegaThres);
|
BOOL CalculateImageValue(EDGELINE_DIR nDirection, BYTE *pImage, int nWidth, int nHeight, CRect &rect,int nStep, VectorDouble& vectorImageData);
|
BOOL CalculateEdgeValue(const VectorDouble& vectorImageData, VectorDouble& vectorEdgeData, int nKernelSize);
|
BOOL CalculateEdgeValue(const VectorDouble& vectorImageData, VectorDouble& vectorEdgeData, VectorInteger& vectorEdgeType, double dPositiveThres, double dNegativeThres, int nKernelSize);
|
BOOL CalculateEdgeValue(EDGELINE_DIR nDirection, short *pImage, int nWidth, int nHeight, int nStep, VectorDouble& vectorEdgeData, VectorInteger& vectorEdgeType, double dPositiveThres, double dNegativeThres);
|
BOOL GetEdgeLeftPosition(int nEdgeType, int nSearchType, int nStartPos, double& dPosition);
|
BOOL GetEdgeRightPosition(int nEdgeType, int nSearchType, int nStartPos, double& dPosition);
|
|
double AbsSum(double init, double x);
|
double Sum(double init, double x);
|
static double Square(double init, double x);
|
static double Cubic(double init, double x);
|
static double ForthPower(double init, double x);
|
double Combi(VectorDouble& vectorX, VectorDouble& vectorY, int n, int r);
|
void InsertPolynomial(ListPolynomial &listPolynomial, int degree, double coef);
|
void RemovePolynomial(ListPolynomial& listPolynomial);
|
BOOL CalculateLagrange(VectorDouble& vectorX, VectorDouble& vectorY, ListPolynomial& listPolynomial);
|
|
template <class T>
|
inline void imMinMax(const T *map, int count, T& min, T& max)
|
{
|
min = *map++;
|
max = min;
|
for (int i = 1; i < count; i++)
|
{
|
T value = *map++;
|
|
if (value > max)
|
max = value;
|
else if (value < min)
|
min = value;
|
}
|
}
|
};
|
|
|
#endif // !defined(AFX_EDGEFIND_H__390230EE_3748_47C9_B543_04276FAFACA4__INCLUDED_)
|
