1060 lines
40 KiB
C++
1060 lines
40 KiB
C++
#pragma once
|
|
#include <opencv2/core/core.hpp>
|
|
#include <vector>
|
|
|
|
|
|
using namespace std;
|
|
using namespace cv;
|
|
|
|
typedef enum _RETURNTYPE
|
|
{
|
|
MV_Success = 0,
|
|
MV_NullPath = 1,//无效路径
|
|
MV_NullFile = 2,//无效文件
|
|
|
|
|
|
MV_NoImageFile = 3,//无输入图像或输入图像路径中不包含图像文件
|
|
MV_WrongParams = 4,//输入参数错误，如scaleOrigin>scaleEnd, angleOrigin>angleEnd等
|
|
MV_TrainFailed = 5,//模型训练失败
|
|
|
|
MV_NoFoundofEdgePoints = 6,//拟合到的点过少
|
|
MV_NoIntersect = 7,//两个图形不相交
|
|
MV_NULL = 8,//无结果
|
|
MV_WrongSize = 9,//无结果
|
|
|
|
MV_WrongDll=10,
|
|
MV_NoneMatch=11,//没有匹配到模板
|
|
MV_NoPpdlFoot=12,//无垂足
|
|
|
|
MV_NullImg = 13,//无效图片文件
|
|
MV_NullContour = 14,//无效轮廓
|
|
|
|
|
|
MV_WrongModel = 15,//模型错误
|
|
MV_WrongLabel = 16,//label错误
|
|
|
|
}RETURNTYPE;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////模板定位//////////////////////////////////////////////////////////////////////////
|
|
enum AccuracyLevel//根据图像大小选取精度模式，图像越大选取的模式越高，采样点更多
|
|
{
|
|
Easy = 64,
|
|
Simple = 96,
|
|
Normal = 128,
|
|
Accuracy = 160,
|
|
HighPrecision = 192
|
|
|
|
};
|
|
|
|
enum EdgeSamplingInterval//采样点颗粒度（边缘特征点最小间隔）
|
|
{
|
|
Small = 1,
|
|
Middle = 3,
|
|
Large = 5,
|
|
ExtraLarge = 7
|
|
};
|
|
|
|
struct TrainParams
|
|
{
|
|
float NOM_angleOrigin;//角度起始位置
|
|
float NOM_angleEnd;//角度介绍位置
|
|
|
|
float ADV_edgeThreshold = 60;//模板边缘灰度阈值
|
|
char *ADV_modelName = (char *)"t_Match.EHD";//模型名称
|
|
float ADV_scaleOrigin;//缩放起始范围如0.8，即在图像中找图像长宽各缩放0.8倍的模板图像
|
|
float ADV_scaleEnd;//缩放起始范围如1.2，即在图像中找图像长宽各缩放1.2倍的模板图像
|
|
float ADV_angleStep;//角度精度步幅，模板匹配的角度精度
|
|
float ADV_scaleStep;//尺度缩放精度
|
|
AccuracyLevel ADV_accuracyLevel;//根据图像大小选取精度模式，图像越大选取的模式越高
|
|
EdgeSamplingInterval ADV_edgeSamplingInterval;//根据图像大小选取精度模式，图像越大选取的模式越高，采样点更多
|
|
bool ADV_showTrainWindow;//采样点颗粒度（边缘特征点最小间隔）
|
|
std::vector<cv::Mat> ADV_maskMat;//掩膜图像，与训练图像一一对应
|
|
|
|
TrainParams(float _NOM_angleOrigin,float _NOM_angleEnd,float _ADV_edgeThreshold = 60,char *_ADV_modelName = (char *)"t_Match.EHD",float _ADV_scaleOrigin = 1.0, float _ADV_scaleEnd = 1.0, float _ADV_angleStep = 1, float _ADV_scaleStep = 0.01, AccuracyLevel _ADV_accuracyLevel = AccuracyLevel::Normal,
|
|
EdgeSamplingInterval _ADV_edgeSamplingInterval = EdgeSamplingInterval::Middle, bool _ADV_showTrainWindow = true, std::vector<cv::Mat> _ADV_maskMat = std::vector<cv::Mat>())
|
|
{
|
|
NOM_angleOrigin = _NOM_angleOrigin;
|
|
NOM_angleEnd = _NOM_angleEnd;
|
|
ADV_edgeThreshold = _ADV_edgeThreshold;
|
|
ADV_modelName = _ADV_modelName;
|
|
ADV_scaleOrigin = _ADV_scaleOrigin;
|
|
ADV_scaleEnd = _ADV_scaleEnd;
|
|
ADV_angleStep = _ADV_angleStep;
|
|
ADV_scaleStep = _ADV_scaleStep;
|
|
ADV_accuracyLevel = _ADV_accuracyLevel;
|
|
ADV_edgeSamplingInterval = _ADV_edgeSamplingInterval;
|
|
ADV_showTrainWindow = _ADV_showTrainWindow;
|
|
ADV_maskMat = _ADV_maskMat;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
struct TrainParams_new
|
|
{
|
|
float NOM_angleOrigin;//角度起始位置
|
|
float NOM_angleEnd;//角度介绍位置
|
|
|
|
float ADV_edgeThreshold = 60;//模板边缘灰度阈值
|
|
char *ADV_modelName = (char *)"t_Match.EHD";//模型名称
|
|
float ADV_scaleOrigin;//缩放起始范围如0.8，即在图像中找图像长宽各缩放0.8倍的模板图像
|
|
float ADV_scaleEnd;//缩放起始范围如1.2，即在图像中找图像长宽各缩放1.2倍的模板图像
|
|
bool ADV_showTrainWindow;//采样点颗粒度（边缘特征点最小间隔）
|
|
std::vector<cv::Mat> ADV_maskMat;//掩膜图像，与训练图像一一对应
|
|
|
|
TrainParams_new(float _NOM_angleOrigin, float _NOM_angleEnd, float _ADV_edgeThreshold = 60, char *_ADV_modelName = (char *)"t_Match.EHD", float _ADV_scaleOrigin = 1.0,
|
|
float _ADV_scaleEnd = 1.0, bool _ADV_showTrainWindow = true, std::vector<cv::Mat> _ADV_maskMat = std::vector<cv::Mat>())
|
|
{
|
|
NOM_angleOrigin = _NOM_angleOrigin;
|
|
NOM_angleEnd = _NOM_angleEnd;
|
|
ADV_edgeThreshold = _ADV_edgeThreshold;
|
|
ADV_modelName = _ADV_modelName;
|
|
ADV_scaleOrigin = _ADV_scaleOrigin;
|
|
ADV_scaleEnd = _ADV_scaleEnd;
|
|
ADV_showTrainWindow = _ADV_showTrainWindow;
|
|
ADV_maskMat = _ADV_maskMat;
|
|
}
|
|
};
|
|
|
|
struct ResRegionInfo
|
|
{
|
|
float feature_width;//特征区域的外接矩形宽
|
|
float feature_height;//特征区域的外接矩形高
|
|
float templateImgCenter_x;//模板匹配中心X
|
|
float templateImgCenter_y;//模板匹配中心Y
|
|
float scale;//模板缩放
|
|
float rotateAngle;//模板角度
|
|
float trainRegion_width;//模板图像宽
|
|
float trainRegion_height;//模板图像宽
|
|
int type;//模板类别
|
|
float score;//匹配得分
|
|
};
|
|
|
|
struct Coordinate
|
|
{
|
|
cv::Point2f orginPoint;//坐标原点在模板图像中的位置
|
|
float angle;//坐标原点在模板图像中的坐标角度
|
|
int templateType=0;
|
|
float score=100;
|
|
Coordinate(cv::Point2f _orginPoint, float _angle, int _templateType, float _score)
|
|
{
|
|
orginPoint = _orginPoint;
|
|
angle = _angle;
|
|
templateType = _templateType;
|
|
score = _score;
|
|
}
|
|
Coordinate(cv::Point2f _orginPoint, float _angle)
|
|
{
|
|
orginPoint = _orginPoint;
|
|
angle = _angle;
|
|
}
|
|
Coordinate()
|
|
{
|
|
|
|
}
|
|
};
|
|
|
|
class pContourMatch
|
|
{
|
|
public:
|
|
|
|
//以Mat作为图像输入参数，参数依次为匹配阈值，结果信息，匹配结果数量，图片paddsize
|
|
virtual RETURNTYPE TemplateMatch_withMat(cv::Mat input_srcMat, float input_matchThreshold,
|
|
int* output_matchNum, ResRegionInfo **output_resRegion) = 0;
|
|
|
|
//以路径作为图像输入参数，参数依次为匹配阈值，结果信息，匹配结果数量，图片paddsize
|
|
virtual RETURNTYPE TemplateMatch_withPath(char* input_filePath, float input_matchThreshold,
|
|
int* matchNum, ResRegionInfo **output_resRegion) = 0;
|
|
|
|
|
|
//以Mat作为图像输入参数，参数依次为匹配阈值，结果信息，匹配结果数量，图片paddsize
|
|
virtual RETURNTYPE TemplateMatch_withMat(cv::Mat input_srcMat, float input_matchThreshold,
|
|
int* output_matchNum, ResRegionInfo **output_resRegion, cv::Rect roi, cv::Mat& output_resMat) = 0;
|
|
|
|
//以路径作为图像输入参数，参数依次为匹配阈值，结果信息，匹配结果数量，图片paddsize
|
|
virtual RETURNTYPE TemplateMatch_withPath(char* input_filePath, float input_matchThreshold,
|
|
int* matchNum, ResRegionInfo **output_resRegion, cv::Rect roi, cv::Mat &output_resMat) = 0;
|
|
|
|
|
|
//以Mat作为图像输入参数，参数依次为匹配阈值，结果信息，匹配结果数量，图片paddsize
|
|
virtual RETURNTYPE TemplateMatch_withMat(cv::Mat input_srcMat, float input_matchThreshold,int* output_matchNum,
|
|
ResRegionInfo **output_resRegion, cv::Rect roi, Coordinate coordinateInTemplateImg, std::vector<Coordinate>& output_coordinateInImg, cv::Mat& output_resMat) = 0;
|
|
|
|
//以路径作为图像输入参数，参数依次为匹配阈值，结果信息，匹配结果数量，图片paddsize
|
|
virtual RETURNTYPE TemplateMatch_withPath(char* input_filePath, float input_matchThreshold,int* matchNum,
|
|
ResRegionInfo **output_resRegion, cv::Rect roi, Coordinate coordinateInTemplateImg, std::vector<Coordinate>& output_coordinateInImg, cv::Mat &output_resMat) = 0;
|
|
|
|
//销毁对象
|
|
virtual void DestoryObj() = 0;
|
|
};
|
|
|
|
/*输入图像模板训练
|
|
srcMat：训练图像来源；TrainParams：训练参数设置*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall TemplateTrain_withMat(std::vector<cv::Mat> input_srcMat, TrainParams intput_trainParams);
|
|
|
|
/*输入图像模板训练
|
|
srcMat：训练图像来源；TrainParams：训练参数设置*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall TemplateTrain_withMat_new(std::vector<cv::Mat> input_srcMat, TrainParams_new intput_trainParams);
|
|
|
|
|
|
/*输入图像路径模板训练
|
|
filePath：训练图像地址集合；TrainParams：训练参数设置*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall TemplateTrain_withPath(std::vector<std::string> input_filePath, TrainParams input_trainParams);
|
|
|
|
/*训练后直接返回匹配对象，无模型文件产生*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall TemplateTrainAndLoad(std::vector<cv::Mat> input_srcMat, TrainParams input_trainParams,
|
|
bool &output_trainRes, pContourMatch** ouput_contourMatch, float intput_edgeThreshold_check = 30);
|
|
|
|
|
|
/*加载模型
|
|
pCMatch：接收载入的模型文件；modelPath：模型路径；edgeThreshold：模型路径*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall LoadContourMatchObj(char* input_modelPath, pContourMatch** output_pCMatch, float intput_edgeThreshold = 30);
|
|
|
|
/*销毁模型
|
|
contourMatch：模型文件*/
|
|
extern "C" __declspec(dllexport) void _stdcall DestroyContourMatchObj(pContourMatch* contourMatch);
|
|
|
|
/*获取旋转矩形区域
|
|
inputImg：输入图片；center：中心点；angle：角度；width：宽度；height：高度*/
|
|
extern "C" __declspec(dllexport) cv::Mat _stdcall GetRotateRectROI(cv::Mat inputImg, cv::Point2f center, double angle, int width, int height);
|
|
|
|
|
|
/*点坐标映射，将模板图像中的坐标点映射到检测图像中*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall PointAffineTransform(ResRegionInfo positionInfo,cv::Point2f positionInTemplateImg, cv::Point2f &positionInImg);
|
|
|
|
|
|
/*点坐标映射，将模板图像中的坐标点映射到检测图像中*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall CoordinateAffineTransform(ResRegionInfo positionInfo, Coordinate coordinateInTemplateImg, Coordinate & coordinateInImg);
|
|
|
|
///////////////////////////////////////////////////////////////////////形状拟合与测量//////////////////////////////////////////////////////////////////////////////
|
|
struct Segment//线段结构体
|
|
{
|
|
cv::Point2f point1;//线段两点坐标
|
|
cv::Point2f point2;
|
|
};
|
|
|
|
struct Line//直线
|
|
{
|
|
//直线标准方程AX+BY+C=0
|
|
double resLine_a;
|
|
double resLine_b;
|
|
double resLine_c;
|
|
};
|
|
|
|
struct Circlef//圆形信息
|
|
{
|
|
float centerX;//圆心x
|
|
float centerY;//圆心y
|
|
float radius;//圆心r
|
|
};
|
|
|
|
struct Ring//圆环
|
|
{
|
|
cv::Point center;//中心点
|
|
double scanAngleStart;//圆环起始角度
|
|
double scanAngleEnd;//圆环结束角度
|
|
double rotateAngleStep;//圆环采样角度间隔
|
|
int outerScanRadious;//圆环外层半径
|
|
int innerScanRadious;//圆环内层半径
|
|
};
|
|
|
|
enum EdgeStrategy//边缘搜索方式
|
|
{
|
|
MaxGadient = 0,//最大梯度
|
|
Top = 1,//最上的边缘点
|
|
Bottom = 2//最下的边缘点
|
|
};
|
|
|
|
|
|
struct FitLinearParams//直线类拟合参数
|
|
{
|
|
cv::RotatedRect NOM_roi;
|
|
int NOM_samplingStep;
|
|
|
|
bool ADV_lightTodark;
|
|
int ADV_scanPixelCol;//采样框宽度
|
|
|
|
int ADV_grayEdgeThreshold;//边缘阈值
|
|
float ADV_refinePointsRate;//用于最终拟合的点集比例
|
|
EdgeStrategy ADV_edgeStagety;//边缘搜索方式
|
|
float ADV_posiTionEdgeRate;//非最大梯度边缘（Top、Bottom）和最大梯度边缘的比例阈值，在EdgeStrategy选Bottom或Top时当Top(最上边缘梯度)或Bottom(最下边缘梯度)大于最大梯度乘以该比例时，
|
|
int ADV_halfEdgewidth;//一半边缘宽度，图像边缘由暗到亮过渡像素的一半
|
|
|
|
FitLinearParams(cv::RotatedRect _NOM_roi, int _NOM_samplingStep, bool _ADV_lightTodark = true, int _ADV_scanPixelCol = 3, int _ADV_grayEdgeThreshold = 8,
|
|
float _ADV_refinePointsRate = 0.8, EdgeStrategy _ADV_edgeStagety = MaxGadient, float _ADV_posiTionEdgeRate = 0.5, int _ADV_halfEdgewidth = 2)
|
|
{
|
|
NOM_roi = _NOM_roi;
|
|
NOM_samplingStep = _NOM_samplingStep;
|
|
|
|
ADV_lightTodark = _ADV_lightTodark;
|
|
ADV_scanPixelCol = _ADV_scanPixelCol;
|
|
ADV_grayEdgeThreshold = _ADV_grayEdgeThreshold;
|
|
ADV_refinePointsRate = _ADV_refinePointsRate;
|
|
ADV_edgeStagety = _ADV_edgeStagety;
|
|
ADV_posiTionEdgeRate = _ADV_posiTionEdgeRate;
|
|
ADV_halfEdgewidth = _ADV_halfEdgewidth;
|
|
}
|
|
};
|
|
|
|
struct FitCurvParams
|
|
{
|
|
cv::Point NOM_center;//中心点
|
|
double NOM_scanAngleStart;//圆环起始角度
|
|
double NOM_scanAngleEnd;//圆环结束角度
|
|
double NOM_rotateAngleStep;//圆环采样角度间隔
|
|
int NOM_outerScanRadious;//圆环外层半径
|
|
int NOM_innerScanRadious;//圆环内层半径
|
|
|
|
bool ADV_lightTodark;//边缘过渡方式，亮到暗还是暗到亮
|
|
int ADV_scanPixelCol;//采样框宽度
|
|
int ADV_grayEdgeThreshold;//边缘阈值
|
|
float ADV_refinePointsRate;//用于最终拟合的点集比例
|
|
EdgeStrategy ADV_edgeStagety;//边缘搜索方式
|
|
float ADV_posiTionEdgeRate;//非最大梯度边缘（Top、Bottom）和最大梯度边缘的比例阈值，在EdgeStrategy选Bottom或Top时当Top(最上边缘梯度)或Bottom(最下边缘梯度)大于最大梯度乘以该比例时，
|
|
int ADV_halfEdgewidth;//一半边缘宽度，图像边缘由暗到亮过渡像素的一半
|
|
|
|
FitCurvParams(cv::Point _NOM_center, double _NOM_scanAngleStart, double _NOM_scanAngleEnd, double _NOM_rotateAngleStep, int _NOM_outerScanRadious,
|
|
int _NOM_innerScanRadious, bool _ADV_lightTodark = true, int _ADV_scanPixelCol = 3, int _ADV_grayEdgeThreshold = 8,float _ADV_refinePointsRate = 0.8,
|
|
EdgeStrategy _ADV_edgeStagety = MaxGadient, float _ADV_posiTionEdgeRate = 0.5, int _ADV_halfEdgewidth = 2)
|
|
{
|
|
NOM_center = _NOM_center;
|
|
NOM_scanAngleStart = _NOM_scanAngleStart;
|
|
NOM_scanAngleEnd = _NOM_scanAngleEnd;
|
|
NOM_rotateAngleStep = _NOM_rotateAngleStep;
|
|
NOM_outerScanRadious = _NOM_outerScanRadious;
|
|
NOM_innerScanRadious = _NOM_innerScanRadious;
|
|
|
|
ADV_lightTodark = _ADV_lightTodark;
|
|
ADV_scanPixelCol = _ADV_scanPixelCol;
|
|
ADV_grayEdgeThreshold = _ADV_grayEdgeThreshold;
|
|
ADV_refinePointsRate = _ADV_refinePointsRate;
|
|
ADV_edgeStagety = _ADV_edgeStagety;
|
|
ADV_posiTionEdgeRate = _ADV_posiTionEdgeRate;
|
|
ADV_halfEdgewidth = _ADV_halfEdgewidth;
|
|
}
|
|
|
|
};
|
|
|
|
struct CaliperWidthParams
|
|
{
|
|
cv::RotatedRect NOM_roi;
|
|
|
|
bool ADV_Edge1_lightTodark;
|
|
bool ADV_Edge2_lightTodark;
|
|
float ADV_edgeThreshold;
|
|
int ADV_halfEdgewidth;
|
|
float ADV_EdgeRate;
|
|
CaliperWidthParams(cv::RotatedRect _NOM_roi, bool _ADV_Edge1_lightTodark = true, bool _ADV_Edge2_lightTodark = false,
|
|
int _ADV_grayEdgeThreshold = 8, int _ADV_halfEdgewidth = 2)
|
|
{
|
|
NOM_roi = _NOM_roi;
|
|
ADV_Edge1_lightTodark = _ADV_Edge1_lightTodark;
|
|
ADV_Edge2_lightTodark = _ADV_Edge2_lightTodark;
|
|
ADV_edgeThreshold = _ADV_grayEdgeThreshold;
|
|
ADV_halfEdgewidth = _ADV_halfEdgewidth;
|
|
}
|
|
};
|
|
|
|
struct MeasDBandParams
|
|
{
|
|
cv::RotatedRect NOM_roi;
|
|
|
|
float ADV_edgeThreshold = 15;
|
|
int ADV_halfEdgewidth = 3;
|
|
float ADV_EdgeRate = 0.5;
|
|
|
|
MeasDBandParams(cv::RotatedRect _NOM_roi, float _ADV_edgeThreshold = 15, int _ADV_halfEdgewidth = 3, float _ADV_EdgeRate = 0.5)
|
|
{
|
|
NOM_roi = _NOM_roi;
|
|
ADV_edgeThreshold = _ADV_edgeThreshold;
|
|
ADV_halfEdgewidth = _ADV_halfEdgewidth;
|
|
ADV_EdgeRate = _ADV_EdgeRate;
|
|
}
|
|
|
|
};
|
|
|
|
extern "C" __declspec(dllexport) void _stdcall InitiateShapeFit();//初始化ShapeFit功能
|
|
|
|
extern "C" __declspec(dllexport) void _stdcall ShapeFitRelease();//释放ShapeFit功能
|
|
|
|
/*拟合直线
|
|
输入图像，结果绘制图像，拟合出的直线信息，需拟合的旋转矩形区域，采样框步幅，从亮到暗拟合标识，拟合参数设置 */
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall Fit_Line(cv::Mat input_img, cv::Mat output_img, FitLinearParams input_fitParams,Line& output_line);
|
|
|
|
/*拟合线段
|
|
输入图像，结果绘制图像，拟合出的线段信息，需拟合的旋转矩形区域，采样框步幅，从亮到暗拟合标识，拟合参数设置 */
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall Fit_Segment(cv::Mat input_img, cv::Mat output_img, FitLinearParams input_fitParams, Segment& output_segMen);
|
|
|
|
/*边缘点拟合
|
|
输入图像，结果绘制图像，找到的边缘点信息，边缘点长度，需拟合的旋转矩形区域，
|
|
采样框步幅，从亮到暗拟合标识，拟合参数设置 */
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall get_LineEdgePoints(cv::Mat input_img, cv::Mat output_img, FitLinearParams input_fitLinearParams,vector<cv::Point2f>& output_resPoints);
|
|
|
|
/*拟合圆
|
|
输入图像，结果绘制图像，拟合出的圆形信息，需拟合的圆环区域，从亮到暗拟合标识，拟合参数设置 */
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall Fit_Circle(cv::Mat input_img, cv::Mat output_img, FitCurvParams input_fitCurvParams,Circlef& output_circle);
|
|
|
|
/*拟合椭圆
|
|
输入图像，结果绘制图像，拟合出的椭圆信息，需拟合的圆环区域，从亮到暗拟合标识，拟合参数设置 */
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall Fit_Ellipse(cv::Mat input_img, cv::Mat output_img, FitCurvParams input_fitCurvParams,cv::RotatedRect& output_resRotateRect);
|
|
|
|
//卡尺工具用于测量线段宽度
|
|
extern "C" __declspec(dllexport) double _stdcall caliperWidthMeasure(cv::Mat input_img, cv::Mat output_img,CaliperWidthParams input_caliperWidthParams);
|
|
|
|
//卡尺检测黑色条带
|
|
extern "C" __declspec(dllexport) double _stdcall caliperMeasureDarkBand(cv::Mat input_img, cv::Mat output_img, MeasDBandParams input_measDBandParams);
|
|
|
|
//输入图片，旋转矩形中心，矩形角度，矩形宽，矩形高;
|
|
extern "C" __declspec(dllexport) cv::Mat _stdcall GetRotateRectROIWithMask(cv::Mat input_img, cv::Mat& out_mask, cv::RotatedRect input_recROI);
|
|
|
|
//画旋转矩形
|
|
extern "C" __declspec(dllexport) void _stdcall drawRotatedRectangle(cv::Mat& out_img,cv::RotatedRect input_rec, cv::Scalar input_color, int input_thickness);
|
|
|
|
//获取图像中投影差分分布，亮到暗或者暗到亮
|
|
extern "C" __declspec(dllexport) bool _stdcall GetEdgeDestribution(cv::Mat rotateRoiImg,
|
|
cv::Point2f rotateRectCenter, double angle, cv::Mat & resEdgeDestribution, bool lightTodark,
|
|
cv::Mat mask, float edgeThreshold = 15, int halfEdgeWidth = 2);
|
|
|
|
///////////////////////////////////////////////////////距离测量////////////////////////////////////////////////////////////////
|
|
//点到点距离
|
|
extern "C" __declspec(dllexport) double _stdcall PointToPointDistance(cv::Point2f point1, cv::Point2f point2);
|
|
|
|
//点到圆周距离
|
|
extern "C" __declspec(dllexport) double _stdcall PointToCircleDistance(cv::Point2f point, Circlef circle);
|
|
|
|
//根据直线的一般式求得点到直线距离
|
|
extern "C" __declspec(dllexport) double _stdcall PointToLineDistance(cv::Point2f point, Line line);
|
|
|
|
//点到线段距离
|
|
extern "C" __declspec(dllexport) double _stdcall PointToSegmentDistance(cv::Point2f point, Segment segment);
|
|
|
|
//点到椭圆圆周的距离
|
|
extern "C" __declspec(dllexport) double _stdcall PointToEllipseDistance(cv::Point2f point, cv::RotatedRect ellipse);
|
|
|
|
//圆周到圆周最小距离
|
|
extern "C" __declspec(dllexport) double _stdcall CircleToCircleDistance(Circlef circle1, Circlef circle2);
|
|
|
|
//圆周到直线距离
|
|
extern "C" __declspec(dllexport) double _stdcall CircleToLineDistance(Circlef circle, Line line);
|
|
|
|
//圆周到线段距离
|
|
extern "C" __declspec(dllexport) double _stdcall CircleToSegmentDistance(Circlef circle, Segment segment);
|
|
|
|
//圆周到椭圆圆周距离
|
|
extern "C" __declspec(dllexport) double _stdcall CircleToEllipseDistance(Circlef circle, cv::RotatedRect ellipse);
|
|
|
|
//椭圆到椭圆距离
|
|
//extern "C" __declspec(dllexport) double _stdcall EllipseToEllipseDistance(cv::RotatedRect ellipse1, cv::RotatedRect ellipse2);
|
|
|
|
//直线到椭圆距离
|
|
//extern "C" __declspec(dllexport) double _stdcall EllipseToLineDistance(cv::RotatedRect ellipse, double a, double b, double c);
|
|
|
|
//圆到椭圆距离
|
|
//extern "C" __declspec(dllexport) double _stdcall EllipseToSegmentDistance(cv::Point2f point, Segment segment);
|
|
|
|
//线段到线段距离
|
|
extern "C" __declspec(dllexport) double _stdcall SegmentToSegmentDistance(Segment segment1, Segment segment2);
|
|
|
|
//线段到直线距离
|
|
extern "C" __declspec(dllexport) double _stdcall SegmentToLineDistance(Segment segment, Line line);
|
|
|
|
//两条直线之间的夹角
|
|
extern "C" __declspec(dllexport) double _stdcall LineToLineAngle(Line line1, Line line2);
|
|
|
|
/////////////相交求交点/////////////
|
|
//两条直线交点
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall getNode_Line2Line(Line input_line1, Line input_line2, cv::Point2f& output_node);
|
|
|
|
//直线和圆得到交点
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall getNode_Line2Circle(Line input_line, Circlef input_circle, vector<cv::Point2f> &output_nodes);
|
|
|
|
//圆与圆交点
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall getNode_Circle2Circle(Circlef input_circle1, Circlef input_circle2, vector<cv::Point2f> &output_nodes);
|
|
|
|
|
|
//得到点在直线上的垂足
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall getPerpendicularFoot(Line input_line, cv::Point2f input_pt, cv::Point2f& output_node);
|
|
|
|
//直线和椭圆的交点
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall getNode_Line2Ellipse(Line input_line,cv::RotatedRect input_ellipse, vector<cv::Point2f>& output_nodes);
|
|
|
|
//两直线角平分线及两平行线中线
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall getLinesBisec(cv::Mat output_showImg, Line input_line1, Line input_line2, Line& output_resLine);
|
|
|
|
//拟合两条直线并求出交点和角度
|
|
extern "C" __declspec(dllexport) RETURNTYPE Fit_NodeLine(cv::Mat input_img, cv::Mat output_img, FitLinearParams input_fitParams1, FitLinearParams input_fitParams2, cv::Point2f& output_node, Line& output_line1, Line& output_line2, double &angle);
|
|
|
|
//拟合矩形的四条边并求角度
|
|
extern "C" __declspec(dllexport) RETURNTYPE Fit_RectLine(cv::Mat input_img, cv::Mat output_img, FitLinearParams input_fitParams1, FitLinearParams input_fitParams2, FitLinearParams input_fitParams3, FitLinearParams input_fitParams4, vector<Point2f>& output_node);
|
|
//两点求直线
|
|
extern "C" __declspec(dllexport) RETURNTYPE getLine_Node2Node(cv::Point2f& input_node0, cv::Point2f& input_node1, Line &line);
|
|
|
|
//线段求交点
|
|
extern "C" __declspec(dllexport) RETURNTYPE getNode_Seg2Seg(Segment input_seg1, Segment input_seg2, cv::Point2f& output_node);
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////blob分析////////////////////////////////////////////////////////////////////////////////////////
|
|
//斑点过滤模式
|
|
enum blobMeasureMode
|
|
{
|
|
Area,//面积
|
|
Perimeter,//周长
|
|
Linearity,//线性度
|
|
MainAngle,//主方向
|
|
CenterMass_x,//质心x
|
|
CenterMass_y,//质心y
|
|
BoundingRect_x,//外接正矩形x
|
|
BoundingRect_y,//外接正矩形y
|
|
BoundingRect_width,//外接正矩形宽
|
|
BoundingRect_height,//外接正矩形高
|
|
BoundingRect_area,//外接正矩形面积
|
|
BoundingRect_center_x,//外接正矩形中心x
|
|
BoundingRect_center_y,//外接正矩形中心y
|
|
BlobAreaRateofBoundingRect,//斑点面积在外接正矩形中的面积占比
|
|
MinAreaRect_width,//最小外接旋转矩形宽度
|
|
MinAreaRect_height,//最小外接旋转矩形高度
|
|
MinAreaRectAngle,//最小外接旋转矩形角度
|
|
MinAreaRect_center_x,//最小外接旋转矩形中心x
|
|
MinAreaRect_center_y,//最小外接旋转矩形中心y
|
|
BlobAreaRateofMinAreaRect,//斑点面积在最小外接旋转矩形中的面积占比
|
|
EnclosingCircle_x,//最小外接圆中心x
|
|
EnclosingCircle_y,//最小外接圆中心y
|
|
EnclosingCircle_radius,//最小外接圆半径
|
|
EnclosingCircle_area,//最小外接圆面积
|
|
BlobAreaRateofMinEnclosingCircle//斑点面积在最小外接圆中的面积占比
|
|
|
|
};
|
|
|
|
//斑点定位切割方式
|
|
enum blobFilterMode
|
|
{
|
|
MaxValue,//最大值
|
|
MinValue,//最小值
|
|
};
|
|
|
|
enum binaryMethod
|
|
{
|
|
binary,//二值化
|
|
binaryInv//二值化取反
|
|
};
|
|
|
|
//斑点过滤参数
|
|
struct blobMeasureParams
|
|
{
|
|
public:
|
|
blobMeasureMode measureMode;//检测方式,周长，面积，线性度，外接矩形等
|
|
double lowRange;//measureMode所对应检测最低值
|
|
double highRange;//measureMode所对应检测最低值
|
|
bool isIncluded;//是否包含在measureMode的检测范围之内
|
|
|
|
//blob测试的类型，最低值，最大值，是否包含
|
|
blobMeasureParams(blobMeasureMode _measureMode, double _lowRange, double _highRange, bool _isIncluded = true)
|
|
{
|
|
measureMode = _measureMode;
|
|
isIncluded = _isIncluded;
|
|
lowRange = _lowRange;
|
|
highRange = _highRange;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//斑点过滤结果,单个blob的单个属性结果
|
|
struct BlobSingleRes
|
|
{
|
|
public:
|
|
blobMeasureMode measureMode;//检测方式,周长，面积，线性度，外接矩形等
|
|
double value;//measureMode所对应检测最低值
|
|
//blob测试的类型，最低值，最大值，是否包含
|
|
BlobSingleRes(blobMeasureMode _measureMode, double _val)
|
|
{
|
|
measureMode = _measureMode;
|
|
value = _val;
|
|
}
|
|
BlobSingleRes()
|
|
{
|
|
}
|
|
};
|
|
|
|
//斑点过滤结果,单个blob的多个属性结果，由过滤参数决定
|
|
struct BlobResults
|
|
{
|
|
public:
|
|
vector<BlobSingleRes> blobResults;
|
|
|
|
};
|
|
//斑点过滤结果,多个blob的多个类型过滤结果
|
|
struct AllBlobsResults
|
|
{
|
|
public:
|
|
vector<BlobResults> allBlobsResults;
|
|
};
|
|
|
|
//blob查找方式
|
|
enum blobType
|
|
{
|
|
external,
|
|
outer,
|
|
inner,
|
|
all
|
|
};
|
|
|
|
|
|
//class pRunTimeMeasure//blob轮廓分析类
|
|
//{
|
|
//public:
|
|
//
|
|
// //运行过滤,获取某个区间的斑点图像
|
|
// //std::vector<blobMeasureParams> runTimeMeasureMode;
|
|
// //RETURNTYPE checkRes;
|
|
//
|
|
// //获取区间内或区间外的blob图像的轮廓，矩形或者Mat
|
|
// //运行过滤,得到斑点区域轮廓集合
|
|
//
|
|
// virtual std::vector<vector<cv::Point>> GetContourList(vector<vector<cv::Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode) = 0;
|
|
//
|
|
// //运行过滤,得到斑点区域轮廓集合
|
|
// virtual std::vector<vector<cv::Point>> GetContourList(cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode, bool input_isImageReverse = false) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域矩形集合
|
|
// virtual std::vector<cv::Rect> GetRectList(vector<vector<cv::Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode ) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域矩形集合
|
|
// virtual std::vector<cv::Rect> GetRectList(cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode, bool input_isImageReverse = false) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域Mat集合
|
|
// virtual std::vector<cv::Mat> GetMatList(cv::Mat input_srcMat, vector<vector<cv::Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域矩形集合
|
|
// virtual std::vector<cv::Mat> GetMatList(cv::Mat input_srcMat, cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode, bool input_isImageReverse = false) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域旋转矩形集合
|
|
// virtual std::vector<cv::RotatedRect> GetMinAreaRectList(vector<vector<cv::Point>> input_contours,std::vector<blobMeasureParams> input_runTimeMeasureMode) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域矩形集合
|
|
// virtual std::vector<cv::RotatedRect> GetMinAreaRectList(cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode, bool input_isImageReverse = false) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域旋转矩形Mat集合
|
|
// virtual std::vector<cv::Mat> GetMinAreaRectMatList(cv::Mat srcMat, vector<vector<cv::Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域旋转矩形Mat集合
|
|
// virtual std::vector<cv::Mat> GetMinAreaRectMatList(cv::Mat srcMat, cv::Mat binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode, bool input_isImageReverse = false) = 0;
|
|
//
|
|
// //**********************************************************************************************************************************//
|
|
// //获取blob图像的某个过滤模式下最值轮廓，矩形,最小外接旋转矩形或者Mat
|
|
// //运行过滤，得到轮廓区域矩形
|
|
// virtual cv::Rect runFilterGetRect(cv::Mat input_binaryMat, blobFilterMode input_filterMode,
|
|
// blobMeasureMode input_measureMode, bool input_isImageReverse = false) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域Mat
|
|
// virtual cv::Mat runFilterGetMat(cv::Mat input_srcMat, cv::Mat input_binaryMat,
|
|
// blobFilterMode input_filterMode, blobMeasureMode input_measureMode, bool input_isImageReverse = false) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域旋转矩形
|
|
// virtual cv::RotatedRect runFilterGetMinAreaRect(cv::Mat input_binaryMat,
|
|
// blobFilterMode input_filterMode, blobMeasureMode input_measureMode, bool input_isImageReverse = false) = 0;
|
|
//
|
|
// //运行过滤，得到轮廓区域旋转矩形Mat
|
|
// virtual cv::Mat runFilterGetMinAreaMat(cv::Mat input_srcMat, cv::Mat input_binaryMat,
|
|
// blobFilterMode input_filterMode, blobMeasureMode input_measureMode, bool input_isImageReverse = false) = 0;
|
|
//
|
|
//};
|
|
|
|
|
|
//找内外轮廓
|
|
RETURNTYPE FindInnerAndOuterContours(vector<vector<Point>> input_contours, vector<cv::Vec4i> input_hierarchy, int flag, vector<vector<Point>> &output_contours);
|
|
//传图找轮廓
|
|
RETURNTYPE GetMatContourList(cv::Mat input_binaryMat, blobType _blobType, vector<vector<Point>> &output_contours);
|
|
|
|
std::vector<vector<Point>> GetSelectedContours(vector<vector<Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode, AllBlobsResults& output_allBlobsRes);
|
|
|
|
//extern "C" __declspec(dllexport) pRunTimeMeasure* _stdcall getBlobRuntimeMeasure();//加载模型
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetBinaryImg(cv::Mat input_Mat,cv::Mat&output_Mat,double threshold, binaryMethod method= binaryMethod::binary);//得到二值化图像
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetContourList(vector<vector<Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<vector<Point>>& output_contours, AllBlobsResults& output_allBlobsRes);//运行过滤,得到斑点区域轮廓集合
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetContourList_(cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<vector<Point>>& output_contours, AllBlobsResults& output_allBlobsRes, blobType _blobType = outer);//运行过滤,得到斑点区域轮廓集合
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetRectList(vector<vector<Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<cv::Rect>& output_Rects, AllBlobsResults& output_allBlobsRes);//获取外接矩形集合
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetRectList_(cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<cv::Rect>& output_Rects, AllBlobsResults& output_allBlobsRes, blobType _blobType = outer);//获取外接矩形集合
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetMatList(cv::Mat input_srcMat, vector<vector<Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<Mat>& output_Mats, AllBlobsResults& output_allBlobsRes);//运行过滤,得到斑点区域图像
|
|
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetMatList_(cv::Mat input_srcMat, cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<Mat>& output_Mats, AllBlobsResults& output_allBlobsRes, blobType _blobType = outer);//运行过滤,得到斑点区域图像
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetMinAreaRectList(vector<vector<Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<cv::RotatedRect> &output_rotatedRects, AllBlobsResults& output_allBlobsRes);//获取最小外接矩形集合
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetMinAreaRectList_(cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<cv::RotatedRect>& output_rotatedRects, AllBlobsResults& output_allBlobsRes, blobType _blobType = outer);//获取最小外接矩形集合
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetMinAreaRectMatList(cv::Mat input_srcMat, vector<vector<Point>> input_contours, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<Mat>& output_Mats, AllBlobsResults& allBlobsRes);//获取最小外接矩形区域图像集合
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetMinAreaRectMatList_(cv::Mat input_srcMat, cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
std::vector<Mat>& output_Mats, AllBlobsResults& output_allBlobsRes, blobType _blobType = outer);//获取最小外接矩形区域图像集合
|
|
|
|
|
|
//画出结果
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetRectListAndDrawing(cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
cv::Mat& output_Mat, std::vector<cv::Rect>& output_Rects, AllBlobsResults& output_allBlobsRes, blobType _blobType = outer);//获取外接矩形集合
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetMatListAndDrawing(cv::Mat input_srcMat, cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
cv::Mat& output_Mat, std::vector<Mat>& output_regionMats, AllBlobsResults& output_allBlobsRes, blobType _blobType = outer);//运行过滤,得到斑点区域图像
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetMinAreaRectListAndDrawing(cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
cv::Mat& output_Mat, std::vector<cv::RotatedRect>& output_rotatedRects, AllBlobsResults& output_allBlobsRes, blobType _blobType = outer);//获取最小外接矩形集合
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE GetMinAreaRectMatListAndDrawing(cv::Mat input_srcMat, cv::Mat input_binaryMat, std::vector<blobMeasureParams> input_runTimeMeasureMode,
|
|
cv::Mat& output_Mat, std::vector<Mat>& output_regionMats, AllBlobsResults& output_allBlobsRes, blobType _blobType = outer);//获取最小外接矩形区域图像集合
|
|
|
|
/////////////////////////////////////////////////////////////////////////////读码////////////////////////////////////////////////////////////////////////////////////////
|
|
//读码类型
|
|
|
|
enum codeType
|
|
{
|
|
CODE_2d = 0,
|
|
QR_CODE = 1,
|
|
DATA_MATRIX = 2,
|
|
AZTEC = 3,
|
|
PDF417 = 4,
|
|
CODE_1d = 5,
|
|
CODABAR = 6,
|
|
CODE_39 = 7,
|
|
CODE_93 = 8,
|
|
CODE_128 = 9,
|
|
EAN_8 = 10,
|
|
EAN_13 = 11,
|
|
ITF = 12,
|
|
UPC_A = 13,
|
|
UPC_E = 14,
|
|
UNKNOWN = 15
|
|
};
|
|
|
|
enum codeParams
|
|
{
|
|
None = 0,//无处理，简单读码
|
|
TooSmall = 1,//过小->放大
|
|
Mirrored = 2, //镜像->翻转
|
|
BlackOnWhite = 3,//白底黑格
|
|
WhiteOnBlack = 4,//黑底白格
|
|
BlackExpand = 5,//黑色增强->腐蚀
|
|
WhiteExpand = 6, //白色增强->膨胀
|
|
Auto = 7//所有处理都尝试一遍，直到读出码或结束
|
|
};
|
|
|
|
|
|
struct decodeStyle//解码模式
|
|
{
|
|
public:
|
|
codeType NOM_decodedType;//解码类型
|
|
codeParams ADV_input_codeParams;
|
|
int ADV_input_indimension;//指定二维码规格，n*n，默认-1表示算法内自动识别
|
|
|
|
decodeStyle(codeType _NOM_decodedType, codeParams _ADV_input_codeParams= None,int _ADV_input_indimension = -1)
|
|
{
|
|
NOM_decodedType = _NOM_decodedType;
|
|
ADV_input_codeParams = _ADV_input_codeParams;
|
|
ADV_input_indimension = _ADV_input_indimension;
|
|
|
|
|
|
}
|
|
};
|
|
|
|
|
|
struct codeInformation//解码信息
|
|
{
|
|
string NOM_decodedData;//解码内容
|
|
codeType NOM_decodedType;//解码类型
|
|
cv::Rect NOM_codeROI;
|
|
};
|
|
|
|
|
|
|
|
class codeRS
|
|
{
|
|
public:
|
|
|
|
//以Mat作为图像输入参数，参数依次为匹配阈值，结果信息，匹配结果数量，图片paddsize
|
|
virtual RETURNTYPE codeRS_Mat_DetectAndDecode(cv::Mat input_img, cv::Mat& output_img, decodeStyle input_decode,
|
|
std::vector<codeInformation> &output_result) = 0;
|
|
|
|
//以路径作为图像输入参数，参数依次为匹配阈值，结果信息，匹配结果数量，图片paddsize
|
|
virtual RETURNTYPE codeRS_Mat_Roi_DetectAndDecode(cv::Mat input_img, cv::Mat& output_img, cv::Rect input_roi, decodeStyle input_decode,
|
|
std::vector<codeInformation> &output_result)= 0;
|
|
|
|
virtual RETURNTYPE codeRSdelete() = 0;
|
|
|
|
};
|
|
|
|
//加载读码模型
|
|
//pCMatch：接收载入的模型文件
|
|
extern "C" __declspec(dllexport) RETURNTYPE _stdcall Load_codeRSObj(codeRS** output_codeRS);
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE codeRS_Mat(cv::Mat input_img, decodeStyle input_decode, codeInformation& output_result);
|
|
|
|
/*解析条形码与二维码
|
|
@input_img:输入图像
|
|
@input_decode：解码模式
|
|
@output_result：解码结果信息*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE codeRS_Mat_DetectAndDecode(cv::Mat input_img, cv::Mat& output_img, decodeStyle input_decode,
|
|
std::vector<codeInformation> &output_result);
|
|
|
|
/*解析条形码与二维码
|
|
@input_img:输入图像
|
|
@input_decode：解码模式
|
|
@output_result：解码结果信息*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE codeRS_Mat_Decode(cv::Mat input_img, cv::Mat& output_img, decodeStyle input_decode,
|
|
codeInformation &output_result);
|
|
|
|
|
|
/*解析条形码与二维码
|
|
@input_img:输入图像
|
|
@input_decode：解码模式
|
|
@output_result：解码结果信息*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE codeRS_Mat_Roi_DetectAndDecode(cv::Mat input_img, cv::Mat& output_img, cv::Rect input_roi, decodeStyle input_decode,
|
|
std::vector<codeInformation> &output_result);
|
|
|
|
/*解析条形码与二维码
|
|
@input_img:输入图像
|
|
@input_decode：解码模式
|
|
@output_result：解码结果信息*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE codeRS_Mat_Roi_Decode(cv::Mat input_img, cv::Mat& output_img,cv::Rect input_roi, decodeStyle input_decode,
|
|
codeInformation &output_result);
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////辅助工具////////////////////////////////////////////////////////////////////////////////////////
|
|
struct skeletonParams//细化设置
|
|
{
|
|
bool ADV_thinner = 0;//进一步细化标志
|
|
int ADV_brunchLength = -1;//可留下的最小分支长度,默认-1代表不去毛刺
|
|
};
|
|
|
|
/*骨架算法
|
|
@input_img:输入图像(需为二值图)
|
|
@output_img：输出图像
|
|
@input_params：细化额外设置*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE findSkeleton(cv::Mat input_img, cv::Mat &output_img,
|
|
skeletonParams input_furtherParams);
|
|
|
|
/*圆弧拉直
|
|
@input_img:输入图像(需为二值图)
|
|
@output_img：输出图像
|
|
@input_circle：圆弧信息*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE cir2rec(cv::Mat input_img, cv::Mat &output_img,
|
|
Circlef input_circle);
|
|
|
|
enum accuracyFusion//根据图像大小选取精度模式，选取的模式数字越小，融合更细致
|
|
{
|
|
accuracy = 1,
|
|
simple = 2,
|
|
easy = 3,
|
|
};
|
|
|
|
struct fusionParams//融合参数设置，默认参数为时间充裕的情况下推荐
|
|
{
|
|
bool ADV_sort = true;//图像集排序标识
|
|
bool ADV_registration = true;//图像集配准标识
|
|
accuracyFusion ADV_accuracy = accuracy;//融合精度
|
|
};
|
|
|
|
/*多聚焦图像融合
|
|
@input_imgs:输入图像集合
|
|
@output_img：输出图像
|
|
@input_params：融合参数设置*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE imageFusion(vector<cv::Mat> input_imgs, cv::Mat &output_img,
|
|
fusionParams input_params);
|
|
|
|
|
|
struct circleGridParams//圆点标定板参数设置
|
|
{
|
|
int ADV_minThreshold = 100;//圆点标定板二值化最低阈值
|
|
int ADV_maxThreshold = 200;//圆点标定板二值化最高阈值
|
|
int ADV_minArea = 50;//圆点最小面积
|
|
int ADV_maxArea = 100;//圆点最大面积
|
|
};
|
|
|
|
enum gridType//标定板类型
|
|
{
|
|
chessBoard = 0,//棋盘格
|
|
circlesGrid = 1,//圆点标定板
|
|
};
|
|
|
|
struct calibrationParams//标定参数设置
|
|
{
|
|
gridType NOM_gridType;//标定板类型
|
|
int NOM_numCol;//标定板规格：列数
|
|
int NOM_numRow;//标定板规格：行数
|
|
bool ADV_external = false;//进行外参矫正标识
|
|
int ADV_poseid = -1;//基于第n张标定板位姿进行外参矫正，从0开始
|
|
circleGridParams ADV_circleGridParams;//圆点标定板参数设置
|
|
|
|
calibrationParams(gridType _NOM_gridType, int _NOM_numCol, int _NOM_numRow,
|
|
circleGridParams _ADV_circleGridParams, bool _ADV_external = false, int _ADV_poseid = -1)
|
|
{
|
|
NOM_gridType = _NOM_gridType;
|
|
NOM_numCol = _NOM_numCol;
|
|
NOM_numRow = _NOM_numRow;
|
|
ADV_external = _ADV_external;
|
|
ADV_poseid = _ADV_poseid;
|
|
ADV_circleGridParams = _ADV_circleGridParams;
|
|
}
|
|
};
|
|
|
|
struct calibrationResult//标定参数
|
|
{
|
|
cv::Mat NOM_cameraMatrix;//相机内参
|
|
cv::Mat NOM_distCoeffs;//畸变系数
|
|
cv::Mat NOM_transformEtn;//外参矫正矩阵
|
|
};
|
|
|
|
/*完整标定（相机标定+图片校准）
|
|
@input_imgsCalib：输入标定板图像集合
|
|
@input_imgsSrc：输入待校准图像集合
|
|
@output_imgs：输出结果图像集合
|
|
@input_params：标定参数设置*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE calibrationWhole(vector<cv::Mat> input_imgsCalib,
|
|
vector<cv::Mat> input_imgsSrc, vector<cv::Mat> &output_imgs, calibrationParams input_params);
|
|
|
|
/*相机标定
|
|
@input_imgsCalib：输入标定板图像集合
|
|
@input_params：标定参数设置
|
|
@output_resultCalib：输出标定系数结果*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE cameraCalibration(vector<cv::Mat> input_imgsCalib,
|
|
calibrationParams input_params, calibrationResult &output_resultCalib);
|
|
|
|
/*单张图片校准
|
|
@input_imgsSrc：输入待校准图像集合
|
|
@output_imgs：输出结果图像集合
|
|
@input_flagExternal：输入进行外参矫正标识
|
|
@input_resultCalib：输入标定系数结果*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE imageCalibration(cv::Mat input_imgSrc, cv::Mat &output_img,
|
|
bool input_flagExternal, calibrationResult input_resultCalib);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////图像预处理/////////////////////////////////////////////////////////////////////////////////
|
|
//滤波器的选择
|
|
enum SmoothMethod
|
|
{
|
|
meanblur = 0, //均值滤波
|
|
gaussianblur = 1,//高斯滤波
|
|
medianblur = 2//中值滤波
|
|
};
|
|
|
|
//图像开闭选择
|
|
enum Morphology
|
|
{
|
|
MopOpen = 0,//图像的开 先腐蚀后膨胀。去除图像中的小亮点
|
|
MopClose = 1//图像的闭 先膨胀后腐蚀。去除图像中的小暗点
|
|
};
|
|
|
|
//像素统计的输出结果
|
|
struct resPixel
|
|
{
|
|
public:
|
|
int NOM_maxValue;//最大值
|
|
int NOM_minValue;//最小值
|
|
int NOM_medianValue;//中值
|
|
double NOM_meanValue;//均值
|
|
double NOM_stdValue;//标准差
|
|
double NOM_varValue;//方差
|
|
};
|
|
|
|
//图像旋转 翻转选择
|
|
enum ImgRotOrFlip
|
|
{
|
|
rotate90Angle = 90,
|
|
rotate180Angle = 180,
|
|
rotate270Angle = 270,
|
|
flipX = 0,
|
|
flipY = 1
|
|
};
|
|
|
|
|
|
/*图像锐化
|
|
@input_img:输入的图像；
|
|
@output_img:输出图像；
|
|
@size:滤波模板的尺寸大小，size.width和size.height可以有所不同，但它们都必须是正数且都为奇数；
|
|
@value:锐化系数；*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE cvSharpen(cv::Mat input_img, cv::Mat &output_img,
|
|
cv::Size2i size, float value);
|
|
|
|
/*图像平滑
|
|
@param4:Y方向上的高斯核标准偏差，如果sigmaY为0，则将其设置为与sigmaX相同的值，
|
|
如果sigmaX和sigmaY都是0，则分别跟据ksize.width和ksize.height计算而来；
|
|
*/
|
|
|
|
/*图像平滑
|
|
@input_img:输入的图像；
|
|
@smoothmethod:平滑滤波器的选择；
|
|
@size_w:滤波模板size的第一个参数也可以是中值滤波第三个参数即滤波模板的尺寸大小；
|
|
@size_h:滤波模板size的第二个参数和size_w一样都要为奇数；
|
|
@sigma_x:X方向上的高斯核标准偏差；
|
|
@sigma_y:Y方向上的高斯核标准偏差；
|
|
@output_img:输出图像；*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE cvSmooth(cv::Mat input_img, SmoothMethod smoothmethod,
|
|
int size_w, int size_h, double sigma_x, double sigma_y, cv::Mat &output_img);
|
|
|
|
/*图像开闭
|
|
@input_img:输入的图像；
|
|
@morphology:开闭方式的选择；
|
|
@size:滤波模板的尺寸大小；
|
|
@output_img:输出图像；*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE cvMorphology(cv::Mat input_img, Morphology morphology,
|
|
cv::Size2i size, cv::Mat &output_img);
|
|
|
|
/*图像像素统计工具
|
|
@input_img:输入图像；
|
|
@output_res:输出像素统计结果的结构体类型，里面包含最大值、最小值、中值、平均值、标准差、方差的计算结果；
|
|
*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE cvPixelTool(cv::Mat input_img, resPixel &output_res);
|
|
|
|
/*图像像素统计工具 roi区域
|
|
@input_img:输入图像；
|
|
@pixeltool:像素统计类型选择有最大值、最小值、中值、平均值、标准差、方差可供选择；
|
|
@res0:int类型 求取最大值、最小值、中值所用，用于存储其结果；*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE cvPixelToolRoi(cv::Mat input_img, cv::Rect roi, resPixel &output_res);
|
|
|
|
|
|
|
|
/*
|
|
@input_img:输入的图像；
|
|
@output_img:输出图像；
|
|
@input_params:输入参数 可选择要旋转的角度 以及水平还是垂直翻转图片
|
|
*/
|
|
extern "C" __declspec(dllexport) RETURNTYPE cvImgRotaionFlip(cv::Mat input_img, ImgRotOrFlip input_params, cv::Mat &output_img);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////OCR////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE trainPics(std::string picsPath, cv::Size picSize,
|
|
std::string picFormat, std::string SVMFilePath, std::string labelPath);
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE loadSVMParams(std::string SVMFilePath, std::string labelPath,
|
|
cv::Ptr<cv::ml::SVM>& SVM, std::map<int, std::string>& predictMap);
|
|
|
|
extern "C" __declspec(dllexport) RETURNTYPE predictPic(cv::Mat in_Img, cv::Ptr<cv::ml::SVM> SVM,
|
|
std::map<int, std::string> predictMap, std::string& res); |