#pragma once
|
#include "CHImageControls/CHImageData.h"
|
#include "RecipeTriangle.h"
|
|
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, CircleCoefficientFail=-18,
|
ProcessSuccess=1, ProcessNone=0 };
|
|
typedef std::vector<double> VectorDouble;
|
typedef std::vector<double>::iterator VectorDoubleIt;
|
|
typedef std::vector<int> VectorInteger;
|
typedef std::vector<int>::iterator VectorIntegerIt;
|
|
typedef std::vector<CPoint> VectorPoint;
|
typedef std::vector<CPoint>::iterator VectorPointIt;
|
|
class CPixelRegion
|
{
|
public:
|
int nLeft;
|
int nTop;
|
int nRight;
|
int nBottom;
|
VectorPoint vectorPoint;
|
|
CPixelRegion() { Reset(); }
|
virtual ~CPixelRegion() { Reset(); }
|
|
CPixelRegion(int left, int top, int right, int bottom)
|
{
|
nLeft = left;
|
nTop = top;
|
nRight = right;
|
nBottom = bottom;
|
|
vectorPoint.clear();
|
}
|
|
void Reset()
|
{
|
nLeft = INT_MAX;
|
nTop = INT_MAX;
|
nRight = INT_MIN;
|
nBottom = INT_MIN;
|
|
vectorPoint.clear();
|
}
|
|
int GetSquareSize() const { return (nRight-nLeft+1) * (nBottom-nTop+1); }
|
int GetWidth() const { return (nRight-nLeft+1); }
|
int GetHeight() const { return (nBottom-nTop+1); }
|
int GetCenterX() const { return nLeft + (nRight - nLeft + 1) / 2; }
|
int GetCenterY() const { return nTop + (nBottom - nTop + 1) / 2; }
|
int GetMaxSize() const { return (GetWidth() < GetHeight()) ? GetHeight(): GetWidth(); }
|
int GetMinSize() const { return (GetWidth() > GetHeight()) ? GetHeight(): GetWidth(); }
|
size_t GetPixelCount() const { return vectorPoint.size(); }
|
};
|
typedef std::vector<CPixelRegion> VectorPixelRegion;
|
typedef std::vector<CPixelRegion>::iterator VectorPixelRegionIt;
|
|
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 = EdgeResult_Mid;
|
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 = EdgeResult_Mid;
|
nLeftPosition = 0;
|
nRightPosition = 0;
|
}
|
|
~CEdgeResult() { Reset(); }
|
|
void Reset()
|
{
|
nEdgeType = EdgeResult_Mid;
|
nIndex = -1;
|
nSignal = EdgeSignal_None;
|
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 CEdgeTriangle
|
{
|
public:
|
CEdgeTriangle(void);
|
~CEdgeTriangle(void);
|
void Reset()
|
{
|
m_imageSource.ReleaseImage();
|
m_imageModel.ReleaseImage();
|
m_recipeTriangle.Reset();
|
m_resultTriangle.Reset();
|
}
|
|
|
VectorDouble GetImageData() { return m_vectorImageData; }
|
VectorDouble GetEdgeData() { return m_vectorEdgeData; }
|
VectorInteger GetEdgeType() { return m_vectorEdgeType; }
|
VectorEdgeResult GetEdgeResult() { return m_vectorEdgeResult; }
|
|
// getter
|
CRecipeTriangle* GetRecipeTriangle() { return &m_recipeTriangle; }
|
CResultTriangle* GetResultTriangle() { return &m_resultTriangle; }
|
|
// setter
|
BOOL SetImageSource(CCHImageData* imageSource);
|
BOOL SetImageModel(CCHImageData* imageModel);
|
BOOL SetRecipeTriangle(const CRecipeTriangle& recipeTriangle);
|
|
// reset
|
void ResetImageSource() { m_imageSource.ReleaseImage(); }
|
void ResetImageModel() { m_imageModel.ReleaseImage(); }
|
void ResetRecipeTriangle() { m_recipeTriangle.Reset(); }
|
void ResetResultTriangle() { m_resultTriangle.Reset(); }
|
|
// process function
|
int ProcessModel();
|
int ProcessModel(CCHImageData* imageSource, const CRecipeModel& recipeModel);
|
int ProcessModel(CCHImageData* imageSource, const VectorRecipeModel& vectorRecipeModel);
|
int ProcessModel(CCHImageData* imageModel, CCHImageData* imageSource, const CRecipeModel& recipeModel);
|
int ProcessModel(CCHImageData* imageModel, CCHImageData* imageSource, const VectorRecipeModel& vectorRecipeModel);
|
|
int ProcessMarker();
|
int ProcessMarker(CCHImageData* imageSource, const CRecipeMarker& recipeMarker);
|
int ProcessMarker(CCHImageData* imageSource, const VectorRecipeMarker& vectorRecipeMarker);
|
|
int ProcessModelMarker();
|
int ProcessModelMarker(CCHImageData* imageSource, const CRecipeModel& recipeModel, const CRecipeMarker& recipeMarker);
|
int ProcessModelMarker(CCHImageData* imageSource, const CRecipeModel& recipeModel, const VectorRecipeMarker& vectorRecipeMarker);
|
int ProcessModelMarker(CCHImageData* imageSource, const VectorRecipeModel& vectorRecipeModel, const VectorRecipeMarker& vectorRecipeMarker);
|
int ProcessModelMarker(CCHImageData* imageModel, CCHImageData* imageSource, const CRecipeModel& recipeModel, const CRecipeMarker& recipeMarker);
|
int ProcessModelMarker(CCHImageData* imageModel, CCHImageData* imageSource, const CRecipeModel& recipeModel, const VectorRecipeMarker& vectorRecipeMarker);
|
int ProcessModelMarker(CCHImageData* imageModel, CCHImageData* imageSource, const VectorRecipeModel& vectorRecipeModel, const VectorRecipeMarker& vectorRecipeMarker);
|
|
int ProcessMarkerFormula();
|
int ProcessMarkerFormula(CCHImageData* imageSource, const CRecipeMarker& recipeMarker, const CRecipeFormula& recipeFormula);
|
int ProcessMarkerFormula(CCHImageData* imageSource, const VectorRecipeMarker& vectorRecipeMarker, const VectorRecipeFormula& vectorRecipeFormula);
|
|
int ProcessTriangle();
|
int ProcessTriangle(CCHImageData* imageSource);
|
int ProcessTriangle(CCHImageData* imageSource, const CRecipeTriangle& recipeTriangle);
|
int ProcessTriangle(CCHImageData* imageModel, CCHImageData* imageSource, const CRecipeTriangle& recipeTriangle);
|
|
// static func
|
static int ImageResizeHalf(CCHImageData* pSource, CCHImageData* pResult);
|
static int ImageResizeQuarter(CCHImageData* pSource, CCHImageData* pResult);
|
static int ImageResizeOneEighth(CCHImageData* pSource, CCHImageData* pResult);
|
static BOOL ImageSobelEdge(CCHImageData* pSource, CCHImageData* pResult);
|
|
static BOOL GetImageData(CCHImageData* pSubImage, VectorDouble& vectorImageData);
|
static BOOL GetEdgeData(CCHImageData* pSubImage, VectorDouble& vectorEdgeData, int nKernelSize, double dKernelSigma);
|
static BOOL GetEdgeData(int& nBandType, CCHImageData* pSubImage, VectorDouble& vectorEdgeData, int nKernelSize, double dKernelSigma);
|
|
static double AbsSum(double init, double x);
|
static 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);
|
|
static int ImageSobelEdge(BYTE* pSrcImage, BYTE *pDstImage, int nWidth, int nHeight);
|
static int ImageAverage(BYTE* pSrcImage, BYTE *pDstImage, int nWidth, int nHeight);
|
static int ImageThresholding(BYTE* pImage, int nWidth, int nHeight, int nThresValue);
|
static int ImageThinning(BYTE* pImage, int nWidth, int nHeight);
|
static int ImageBlobAnalysis(BYTE *pImage, int nWidth, int nHeight, VectorPixelRegion& vectorRegion, int nBlobMargin=-1);
|
|
static int ImageErode(BYTE* pSrcImage, BYTE *pDstImage, int nWidth, int nHeight);
|
static int ImageDilate(BYTE* pSrcImage, BYTE *pDstImage, int nWidth, int nHeight);
|
static int ImageExclusiveOR(BYTE* pSrcImage1, BYTE *pSrcImage2, BYTE* pDstImage, int nWidth, int nHeight);
|
static int ImageAND(BYTE* pSrcImage1, BYTE *pSrcImage2, BYTE* pDstImage, int nWidth, int nHeight);
|
static int ImageOR(BYTE* pSrcImage1, BYTE *pSrcImage2, BYTE* pDstImage, int nWidth, int nHeight);
|
|
// check func
|
static BOOL CheckFormulationString(const CString& strFormulation, CString& strResultFormulation, CRecipeTriangle* pRecipeTriangle=NULL);
|
|
private:
|
// internal process
|
int FormulaProcess();
|
int MarkerProcess(CCHImageData *imageSource);
|
int MarkerFormulaProcess(CCHImageData *imageSource);
|
int ModelProcess(CCHImageData *imageModel, CCHImageData *imageSource);
|
int ModelMarkerProcess(CCHImageData *imageModel, CCHImageData *imageSource);
|
int TriangleProcess(CCHImageData *imageModel, CCHImageData *imageSource);
|
|
// model func
|
BOOL MatchImage(CCHImageData *pSource, CCHImageData *pModel, CRect* pRect, double dScore, int& nPosX, int& nPosY, double& dResult);
|
BOOL MatchImage(CCHImageData *pSource, CCHImageData *pModel, CRect* pRect, double dScore, double& dPosX, double& dPosY, double& dResult);
|
int MatchFull(CCHImageData *pSource, CCHImageData *pModel, const CRecipeModel *pRecipeModel, CResultModel& resultModel);
|
int MatchLevel(CCHImageData *pSource, CCHImageData *pModel, const CRecipeModel *pRecipeModel, CResultModel& resultModel);
|
static void GetMinLocation(float *pImage, int nWidth, int nHeight, int nStep, int& nPosX, int& nPosY, double& dValue);
|
static void GetMaxLocation(float *pImage, int nWidth, int nHeight, int nStep, int& nPosX, int& nPosY, double& dValue);
|
|
// Marker func
|
int MeasureImage(CCHImageData *imageSource, const CRecipeMarker* pRecipeMarker, CResultMarker& resultMarker);
|
int Process_MeasureLine(CCHImageData& imageData, const CRecipeMarker* pRecipeMarker, CResultMarker& resultMarker);
|
int Process_MeasureCircle(CCHImageData& imageData, const CRecipeMarker* pRecipeMarker, CResultMarker& resultMarker);
|
int Process_MeasureEllipse(CCHImageData& imageData, const CRecipeMarker* pRecipeMarker, CResultMarker& resultMarker);
|
void CalculateEdgePosition(int nSubPixelType, double dPosiThres, double dNegaThres, int nIteration=0);
|
|
BOOL CalculateInterpolateLinear(CEdgeResult& edgeResult, double dEdgeThreshold);
|
BOOL CalculateInterpolateQuadratic(CEdgeResult& edgeResult);
|
BOOL CalculateInterpolateGaussian(CEdgeResult& edgeResult, int nEdgeType);
|
BOOL CalculateInterpolateQuadraticRegression(CEdgeResult& edgeResult);
|
BOOL CalculateInterpolateGaussianRegression(CEdgeResult& edgeResult, int nEdgeType);
|
BOOL CalculateInterpolateGaussianRegressionReweight(CEdgeResult& edgeResult, int nEdgeType, int nIteartion);
|
|
|
BOOL GetEdgeLeftPosition(int nEdgeType, int nSearchType, int nStartPos, int nEndPos, double& dPosition);
|
BOOL GetEdgeRightPosition(int nEdgeType, int nSearchType, int nStartPos, int nEndPos, double& dPosition);
|
BOOL GetResultFormulation(const CString& strFormulation, CString& strResultFormulation);
|
|
static BOOL CalculateImageValue(int nDirection, BYTE *pImage, int nWidth, int nHeight, int nStep, VectorDouble& vectorImageData);
|
static BOOL CalculateEdgeValue(const VectorDouble& vectorImageData, VectorDouble& vectorEdgeData, int nKernelSize, double dKernelSigma);
|
static BOOL CalculateEdgeValue(const VectorDouble& vectorImageData, VectorDouble& vectorEdgeData, VectorInteger& vectorEdgeType, double dPositiveThres, double dNegativeThres, int nKernelSize, double dKernelSigma);
|
static BOOL CalculateEdgeValue(int nDirection, short *pImage, int nWidth, int nHeight, int nStep, VectorDouble& vectorEdgeData, VectorInteger& vectorEdgeType, double dPositiveThres, double dNegativeThres);
|
|
|
CCHImageData m_imageSource;
|
CCHImageData m_imageModel;
|
|
CRecipeTriangle m_recipeTriangle;
|
CResultTriangle m_resultTriangle;
|
|
VectorDouble m_vectorImageData;
|
VectorDouble m_vectorEdgeData;
|
VectorInteger m_vectorEdgeType;
|
VectorEdgeResult m_vectorEdgeResult;
|
|
};
|
