|
|
#include "coutlinedetector.h"
|
|
|
#include "GSurface.h"
|
|
|
#include <QDebug>
|
|
|
#include "PolygonTreeInterface.h"
|
|
|
#include "InterfaceElements.h"
|
|
|
|
|
|
using namespace std;
|
|
|
COutlineDetector::COutlineDetector()
|
|
|
:m_pSurface(nullptr)
|
|
|
, m_nIterations(3)
|
|
|
, m_zlower(0)
|
|
|
, m_zupper(0)
|
|
|
, m_smoothTimes(0)
|
|
|
, m_minArea(0)
|
|
|
{
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
void COutlineDetector::clear()
|
|
|
{
|
|
|
// m_pSurface = nullptr;
|
|
|
m_originalContours.clear();
|
|
|
m_matMorp.release();
|
|
|
}
|
|
|
|
|
|
|
|
|
//设置最小轮廓线面积
|
|
|
void COutlineDetector::setContourMinArea(float area)
|
|
|
{
|
|
|
if(area < 0)
|
|
|
area = 0;
|
|
|
m_minArea = area;
|
|
|
}
|
|
|
//设置输出轮廓线平滑次数
|
|
|
void COutlineDetector::setContourSmoothTimes(unsigned int times)
|
|
|
{
|
|
|
if(times < 1)
|
|
|
times = 0;
|
|
|
m_smoothTimes = times;
|
|
|
}
|
|
|
|
|
|
|
|
|
void COutlineDetector::setSurface(GSurface *pSurf, float zlower, float zupper, unsigned int nIters)
|
|
|
{
|
|
|
m_pSurface = pSurf;
|
|
|
setIterations(nIters);
|
|
|
setTargetZRange(zlower,zupper);
|
|
|
}
|
|
|
|
|
|
void COutlineDetector::setTargetZRange(float zlower, float zupper)
|
|
|
{
|
|
|
m_zlower = zlower;
|
|
|
m_zupper = zupper;
|
|
|
}
|
|
|
|
|
|
bool COutlineDetector::ProcessImage()
|
|
|
{
|
|
|
if(nullptr == m_pSurface)
|
|
|
return false;
|
|
|
morphologySolve();
|
|
|
createContours();
|
|
|
SmoothContours();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
void COutlineDetector::multiContourToRealCoords(const std::vector< std::vector<cv::Point2f> >& inputContour, std::vector< std::vector<cv::Point2f> > & dstContours, int smoothTimes)
|
|
|
{
|
|
|
dstContours.resize(inputContour.size() );
|
|
|
for(int i = 0; i < inputContour.size(); i ++ )
|
|
|
contourToRealCoords(inputContour[i],dstContours[i],smoothTimes);
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
void COutlineDetector::contourToRealCoords(const std::vector<cv::Point2f>& inputContour, std::vector<cv::Point2f>& dstContour, int smoothTimes)
|
|
|
{
|
|
|
|
|
|
int N = inputContour.size();
|
|
|
double* x = new double[N];
|
|
|
double* y = new double[N];
|
|
|
|
|
|
float x0 = m_pSurface->X(0);
|
|
|
float y0 = m_pSurface->Y(0);
|
|
|
|
|
|
float dx = m_pSurface->DeltX();
|
|
|
float dy = m_pSurface->DeltY();
|
|
|
double tx,ty;
|
|
|
for(int i = 0; i < N; i ++ )
|
|
|
{
|
|
|
tx = inputContour[i].x;
|
|
|
ty = inputContour[i].y;
|
|
|
x[i] = x0 + dx* tx;
|
|
|
y[i] = y0 + dy*ty;
|
|
|
|
|
|
}
|
|
|
|
|
|
if(N > 4 && smoothTimes > 0)
|
|
|
{
|
|
|
Smooth53(x,N,smoothTimes);
|
|
|
Smooth53(y,N,smoothTimes);
|
|
|
}
|
|
|
|
|
|
dstContour.resize(N);
|
|
|
for(int i = 0; i < N; i ++ )
|
|
|
{
|
|
|
dstContour[i].x = x[i];
|
|
|
dstContour[i].y = y[i];
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
delete []x;
|
|
|
delete []y;
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
bool COutlineDetector::WriteContours( std::vector<std::vector<cv::Point2f>>& contours, const char* path)
|
|
|
{
|
|
|
FILE* fw = fopen(path,"w");
|
|
|
if(nullptr == fw)
|
|
|
return false;
|
|
|
|
|
|
float x, y;
|
|
|
for(int j = 0; j < contours.size(); j ++ )
|
|
|
{
|
|
|
/* if(contours[j].size() < 3)
|
|
|
continue;*/
|
|
|
|
|
|
fprintf(fw,"Pline.%d\n",j);
|
|
|
|
|
|
for(auto& p :contours[j] )
|
|
|
{
|
|
|
x = p.x;
|
|
|
y = p.y;
|
|
|
fprintf(fw,"%.12g,%.12g\n",x,y);
|
|
|
}
|
|
|
|
|
|
auto p = contours[j][0];
|
|
|
x = p.x;
|
|
|
y = p.y;
|
|
|
fprintf(fw,"%.12g,%.12g\n",x,y);
|
|
|
|
|
|
fprintf(fw,"\n");
|
|
|
}
|
|
|
|
|
|
fclose(fw);
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
// bool COutlineDetector::WriteContours(const char *path)
|
|
|
// {
|
|
|
//
|
|
|
//
|
|
|
// SmoothContours(); //平滑轮廓线
|
|
|
//
|
|
|
// vector<Point2f> cbd;
|
|
|
// CombineContours(cbd);
|
|
|
//
|
|
|
// vector<vector<Point2f>> vv; vv.push_back(cbd);
|
|
|
// WriteContours(vv, "d:/combined_contours.dfd");
|
|
|
//
|
|
|
// //转换为实际坐标
|
|
|
// vector< vector<Point2f>> realCoords;
|
|
|
// realCoords.resize(1);
|
|
|
// contourToRealCoords(cbd,realCoords[0],0);
|
|
|
//
|
|
|
//
|
|
|
// return WriteContours(realCoords,path);
|
|
|
//
|
|
|
// /*
|
|
|
//
|
|
|
// vector<vector<cv::Point2f> > ReservedContours;
|
|
|
//
|
|
|
// FilterContours(m_minArea,ReservedContours);
|
|
|
// vector<vector<cv::Point2f>> contours;
|
|
|
// multiContourToRealCoords(ReservedContours,contours,m_smoothTimes);
|
|
|
//
|
|
|
//
|
|
|
// return WriteContours(contours,path);
|
|
|
//
|
|
|
// */
|
|
|
//
|
|
|
//
|
|
|
//// float x, y;
|
|
|
//// for(int j = 0; j < contours.size(); j ++ )
|
|
|
//// {
|
|
|
//// if(contours[j].size() < 3)
|
|
|
//// continue;
|
|
|
//
|
|
|
//// fprintf(fw,"Pline\n");
|
|
|
//
|
|
|
//// for(auto& p :contours[j] )
|
|
|
//// {
|
|
|
//// x = p.x;
|
|
|
//// y = p.y;
|
|
|
//// fprintf(fw,"%.12g,%.12g\n",x,y);
|
|
|
//// }
|
|
|
//
|
|
|
//// auto p = contours[j][0];
|
|
|
//// x = p.x;
|
|
|
//// y = p.y;
|
|
|
//// fprintf(fw,"%.12g,%.12g\n",x,y);
|
|
|
//
|
|
|
//// fprintf(fw,"\n");
|
|
|
//// }
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//// float x0 = m_pSurface->X(0);
|
|
|
//// float y0 = m_pSurface->Y(0);
|
|
|
//
|
|
|
//// float dx = m_pSurface->DeltX();
|
|
|
//// float dy = m_pSurface->DeltY();
|
|
|
//
|
|
|
//// float x,y;
|
|
|
//// for(int j = 0; j < m_contours.size(); j ++ )
|
|
|
//// {
|
|
|
//// if(m_contours[j].size() < 3)
|
|
|
//// continue;
|
|
|
//
|
|
|
//// fprintf(fw,"Pline\n");
|
|
|
//
|
|
|
//// for(auto& p :m_contours[j] )
|
|
|
//// {
|
|
|
//// x = x0 + dx* p.x;
|
|
|
//// y = y0 + dy*p.y;
|
|
|
//// fprintf(fw,"%.12g,%.12g\n",x,y);
|
|
|
//// }
|
|
|
//
|
|
|
//// auto p = m_contours[j][0];
|
|
|
//// x = x0 + dx* p.x;
|
|
|
//// y = y0 + dy*p.y;
|
|
|
//// fprintf(fw,"%.12g,%.12g\n",x,y);
|
|
|
//
|
|
|
//// fprintf(fw,"\n");
|
|
|
//// }
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//// fclose(fw);
|
|
|
// // return true;
|
|
|
// }
|
|
|
//
|
|
|
void toPline(vector<Point2f>& src, CPolyline& dstLine )
|
|
|
{
|
|
|
dstLine.Clear();
|
|
|
for(auto p:src)
|
|
|
{
|
|
|
dstLine.AddPoint(p.x,p.y,0);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void fromPline(CPolyline& src, vector<Point2f>& dst)
|
|
|
{
|
|
|
CPointXYZ pt;
|
|
|
dst.resize(src.GetSize());
|
|
|
for(int i = 0; i < src.GetSize(); i ++ )
|
|
|
{
|
|
|
pt = src.GetPoint(i);
|
|
|
dst[i].x = pt.x0;
|
|
|
dst[i].y = pt.y0;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
//生成沉积相轮廓线,局部合并内部包含孔洞的轮廓线
|
|
|
int COutlineDetector::CreateFaciesContours(void)
|
|
|
{
|
|
|
|
|
|
m_faciesContours.clear();
|
|
|
|
|
|
vector<CPolyline*> polygons;
|
|
|
|
|
|
int i = 0;
|
|
|
char chs[20];
|
|
|
polygons.reserve(m_originalContours.size());
|
|
|
for (auto& p : m_originalContours)
|
|
|
{
|
|
|
CPolyline* pl = new CPolyline;
|
|
|
toPline(p, *pl);
|
|
|
sprintf(chs, "%d", i);
|
|
|
pl->SetName(chs);
|
|
|
pl->setClosed();
|
|
|
i++;
|
|
|
polygons.push_back(pl);
|
|
|
}
|
|
|
|
|
|
vector<vector<int>> hierarchy;
|
|
|
hierarchy.resize(m_hierarchy.size(), vector<int>(4, -1));
|
|
|
|
|
|
for (i = 0; i < m_hierarchy.size(); i++)
|
|
|
{
|
|
|
for (int j = 0; j < 4; j++)
|
|
|
hierarchy[i][j] = m_hierarchy[i][j];
|
|
|
}
|
|
|
|
|
|
|
|
|
CPolygonTreeInterface pgnTree;
|
|
|
pgnTree.SetPolygons(polygons);
|
|
|
pgnTree.SetHierarchy(hierarchy);
|
|
|
|
|
|
double dx = m_pSurface->DeltX();
|
|
|
double dy = m_pSurface->DeltY();
|
|
|
|
|
|
double minArea = m_minArea / (dx*dy);
|
|
|
if(minArea < 1e-4)
|
|
|
minArea = 1e-4;
|
|
|
|
|
|
|
|
|
|
|
|
pgnTree.Create(minArea);
|
|
|
|
|
|
int N = pgnTree.GetResultPolygons().size();
|
|
|
m_faciesContours.resize(N);
|
|
|
for (int i = 0; i < N; i++)
|
|
|
{
|
|
|
fromPline(*pgnTree.GetResultPolygons().at(i), m_faciesContours[i]);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//清空临时变量
|
|
|
for (auto p : polygons)
|
|
|
delete p;
|
|
|
|
|
|
|
|
|
return N;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
// void COutlineDetector::CombineContours(std::vector<Point2f> &dstContour)
|
|
|
// {
|
|
|
//
|
|
|
// vector<CPolyline*> polygons;
|
|
|
//
|
|
|
// int i = 0;
|
|
|
// char chs[20];
|
|
|
// polygons.reserve(m_originalContours.size());
|
|
|
// for(auto& p: m_originalContours)
|
|
|
// {
|
|
|
// CPolyline* pl = new CPolyline;
|
|
|
// toPline(p,*pl);
|
|
|
// sprintf(chs,"%d",i);
|
|
|
// pl->SetName(chs);
|
|
|
// pl->setClosed();
|
|
|
// i++;
|
|
|
// polygons.push_back(pl);
|
|
|
// }
|
|
|
//
|
|
|
// vector<vector<int>> hierarchy;
|
|
|
// hierarchy.resize(m_hierarchy.size(),vector<int>(4,-1));
|
|
|
//
|
|
|
// for(i = 0; i < m_hierarchy.size(); i ++ )
|
|
|
// {
|
|
|
// for(int j = 0; j < 4; j ++ )
|
|
|
// hierarchy[i][j] = m_hierarchy[i][j];
|
|
|
// }
|
|
|
//
|
|
|
//
|
|
|
// CPolygonTreeInterface pgnTree;
|
|
|
// pgnTree.SetPolygons(polygons);
|
|
|
// pgnTree.SetHierarchy(hierarchy);
|
|
|
//
|
|
|
// double dx = m_pSurface->DeltX();
|
|
|
// double dy = m_pSurface->DeltY();
|
|
|
//
|
|
|
// double minArea = m_minArea/(dx*dy);
|
|
|
//
|
|
|
//
|
|
|
// pgnTree.Create(minArea);
|
|
|
//
|
|
|
// CPolyline& pc = pgnTree.GetCombinedPolygon();
|
|
|
//
|
|
|
// fromPline(pc,dstContour);
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
// //清空临时变量
|
|
|
// for(auto p:polygons)
|
|
|
// delete p;
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//// pgnTree.GetHierarchy().resize(m_hierarchy.size());
|
|
|
//
|
|
|
//// for(int i = 0; i < m_hierarchy.size(); i ++ )
|
|
|
//// {
|
|
|
//// pgnTree.GetHierarchy()[i].resize(4);
|
|
|
//// for(int j = 0; j <4 ; j ++ )
|
|
|
//// pgnTree.GetHierarchy()[i][j] = m_hierarchy[i][j];
|
|
|
//// }
|
|
|
//
|
|
|
//
|
|
|
//// for(int i = 0; i < m_contours.size(); i ++ )
|
|
|
//// {
|
|
|
//// CPolyline* pc = new CPolyline;
|
|
|
//// for(auto& p: m_contours[i] )
|
|
|
//// pc->AddPoint(p.x,p.y,0);
|
|
|
//
|
|
|
//// pgnTree.GetPolygons().push_back(pc);
|
|
|
//
|
|
|
//// }
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
// }
|
|
|
//
|
|
|
|
|
|
bool COutlineDetector::WriteContours(std::vector<std::vector<Point> > &contours, const char* path)
|
|
|
{
|
|
|
|
|
|
FILE* fw = fopen(path,"w");
|
|
|
if(nullptr == fw)
|
|
|
return false;
|
|
|
|
|
|
float x, y;
|
|
|
for(int j = 0; j < contours.size(); j ++ )
|
|
|
{
|
|
|
if(contours[j].size() < 3)
|
|
|
continue;
|
|
|
|
|
|
fprintf(fw,"Pline.%d\n",j);
|
|
|
|
|
|
for(auto& p :contours[j] )
|
|
|
{
|
|
|
x = p.x;
|
|
|
y = p.y;
|
|
|
fprintf(fw,"%.12g,%.12g\n",x,y);
|
|
|
}
|
|
|
|
|
|
auto p = contours[j][0];
|
|
|
x = p.x;
|
|
|
y = p.y;
|
|
|
fprintf(fw,"%.12g,%.12g\n",x,y);
|
|
|
|
|
|
fprintf(fw,"\n");
|
|
|
}
|
|
|
|
|
|
fclose(fw);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void COutlineDetector::setIterations(unsigned int nIterations)
|
|
|
{
|
|
|
m_nIterations = nIterations;
|
|
|
}
|
|
|
|
|
|
void COutlineDetector::morphologySolve()
|
|
|
{
|
|
|
|
|
|
TraceBorder();
|
|
|
|
|
|
Mat srcMat ;
|
|
|
convertSurfaceToMat(m_pSurface,m_zlower,m_zupper, srcMat); //surface to bin mat
|
|
|
|
|
|
|
|
|
// imshow("bordermat",m_matBorder);
|
|
|
// waitKey(0);
|
|
|
|
|
|
m_matSrc = srcMat;
|
|
|
|
|
|
Mat bin = srcMat;
|
|
|
|
|
|
Mat kernel;
|
|
|
kernel = getStructuringElement(MORPH_CROSS, Size(3, 3));//矩形结构元素
|
|
|
Mat materode, matdilate;
|
|
|
//膨胀
|
|
|
dilate(bin, matdilate, kernel, Point(-1, -1), m_nIterations);
|
|
|
//腐蚀
|
|
|
erode(matdilate, materode, kernel,Point(-1,-1),m_nIterations+1);
|
|
|
//imshow("腐蚀", materode);
|
|
|
|
|
|
|
|
|
|
|
|
// erode(bin, materode, kernel,Point(-1,-1),m_nIterations);
|
|
|
// //imshow("腐蚀", materode);
|
|
|
|
|
|
// //膨胀
|
|
|
// dilate(materode, matdilate, kernel, Point(-1, -1), m_nIterations+1);
|
|
|
// //imshow("膨胀", matdilate);
|
|
|
// // imwrite("d:/腐蚀膨胀后.bmp", matdilate);
|
|
|
m_matMorp = matdilate;
|
|
|
|
|
|
//由matBorder对越界部分进行修改
|
|
|
for(int j = 0; j < m_matMorp.rows; j ++ )
|
|
|
{
|
|
|
for(int i = 0; i < m_matMorp.cols; i ++ )
|
|
|
{
|
|
|
|
|
|
if(0 == m_matBorder.at<uchar>(j,i))
|
|
|
{
|
|
|
m_matMorp.at<uchar>(j,i) = 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
//五点三次平滑 n 必须大于4
|
|
|
bool COutlineDetector::Smooth53(double* val, int n, int stimes)
|
|
|
{
|
|
|
if (n < 5 || stimes < 1) return false;
|
|
|
|
|
|
int i, k; //k为平滑次数
|
|
|
double *xx = new double[n];
|
|
|
|
|
|
for (k = 0; k < stimes; k ++)
|
|
|
{
|
|
|
xx[0] = 69 * val[0] + 4 * val[1] - 6 * val[2] + 4 * val[3] - val[4];
|
|
|
xx[0] = xx[0] / 70;
|
|
|
xx[1] = 2 * val[0] + 27 * val[1] + 12 * val[2] - 8 * val[3];
|
|
|
xx[1] = (xx[1] + 2 * val[4]) / 35;
|
|
|
|
|
|
for (i = 2; i <= n - 3; i++)
|
|
|
{
|
|
|
xx[i] = -3 * val[i - 2] + 12 * val[i - 1] + 17 * val[i];
|
|
|
xx[i] = (xx[i] + 12 * val[i + 1] - 3 * val[i + 2]) / 35;
|
|
|
}
|
|
|
|
|
|
xx[n - 2] = 2 * val[n - 5] - 8 * val[n - 4] + 12 * val[n - 3];
|
|
|
xx[n - 2] = (xx[n - 2] + 27 * val[n - 2] + 2 * val[n - 1]) / 35;
|
|
|
xx[n - 1] = -val[n - 5] + 4 * val[n - 4] - 6 * val[n - 3];
|
|
|
xx[n - 1] = (xx[n - 1] + 4 * val[n - 2] + 69 * val[n - 1]) / 70;
|
|
|
|
|
|
for (int i = 0; i < n; i++)
|
|
|
val[i] = xx[i];
|
|
|
}
|
|
|
|
|
|
delete []xx;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
void COutlineDetector::SmoothContours()
|
|
|
{
|
|
|
int N = m_originalContours.size();
|
|
|
|
|
|
for(int i = 0; i < N; i ++ )
|
|
|
{
|
|
|
//一级轮廓线
|
|
|
if(-1 == m_hierarchy[i][3] )
|
|
|
SmoothRootContour(m_originalContours[i],m_smoothTimes);
|
|
|
else
|
|
|
SmoothContour(m_originalContours[i],m_smoothTimes);
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
std::vector<std::vector<cv::Point2f>>& COutlineDetector::GetOriginalContours(void)
|
|
|
{
|
|
|
|
|
|
return m_originalContours;
|
|
|
|
|
|
}
|
|
|
//获取沉积相轮廓线
|
|
|
std::vector<std::vector<cv::Point2f>>& COutlineDetector::GetFaciesContours(void)
|
|
|
{
|
|
|
return m_faciesContours;
|
|
|
}
|
|
|
|
|
|
|
|
|
void COutlineDetector::SmoothRootContour(std::vector<cv::Point2f>& inputContour, int nTimes)
|
|
|
{
|
|
|
|
|
|
|
|
|
if(nTimes < 1 || inputContour.size() < 4)
|
|
|
return;
|
|
|
|
|
|
|
|
|
int N = inputContour.size();
|
|
|
|
|
|
|
|
|
//查找inputContour在边界上的部分
|
|
|
|
|
|
int istart = 0;
|
|
|
int iend = 0;
|
|
|
int i = 0;
|
|
|
vector<Point2f> subline;
|
|
|
while(i < N)
|
|
|
{
|
|
|
if( !isPtOnBorder(inputContour[i])) //找到不在边界上的首点
|
|
|
{
|
|
|
|
|
|
istart = i;
|
|
|
for( i = istart +1; i < N; i ++ )
|
|
|
{
|
|
|
if( N-1 == i )
|
|
|
{
|
|
|
iend = N-1;
|
|
|
break;
|
|
|
}
|
|
|
else if(isPtOnBorder(inputContour[i]))
|
|
|
{
|
|
|
iend = i-1;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if(istart > 0)
|
|
|
istart --;
|
|
|
if(iend < N-1)
|
|
|
iend ++;
|
|
|
|
|
|
if(iend - istart > 3) //至少5个点
|
|
|
{
|
|
|
//平滑不在边界线上的局部曲线[istart,iend]
|
|
|
subline.clear();
|
|
|
subline.reserve(iend-istart +1);
|
|
|
for(int k = istart; k <= iend; k ++ )
|
|
|
subline.push_back(inputContour[k]);
|
|
|
|
|
|
SmoothContour(subline,nTimes);
|
|
|
//将平滑后的局部曲线替换原曲线
|
|
|
int t = 0;
|
|
|
for(int k = istart; k <= iend; k ++ )
|
|
|
inputContour[k] = subline[t++];
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
i++;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
bool COutlineDetector::isPtOnBorder(const Point &pt)
|
|
|
{
|
|
|
for(auto& p:m_border)
|
|
|
{
|
|
|
if(fabs(pt.x - p.x) < 0.5 && fabs(pt.y-p.y) < 0.5)
|
|
|
return true;
|
|
|
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
void COutlineDetector::SmoothContour( std::vector<cv::Point2f>& inputContour, int nTimes)
|
|
|
{
|
|
|
if(nTimes < 1 || inputContour.size() < 4)
|
|
|
return;
|
|
|
|
|
|
int N = inputContour.size();
|
|
|
double* x = new double[N];
|
|
|
double* y = new double[N];
|
|
|
|
|
|
double tx,ty;
|
|
|
for(int i = 0; i < N; i ++ )
|
|
|
{
|
|
|
tx = inputContour[i].x;
|
|
|
ty = inputContour[i].y;
|
|
|
x[i] = tx;
|
|
|
y[i] = ty;
|
|
|
|
|
|
}
|
|
|
|
|
|
if(N > 4 && nTimes > 0)
|
|
|
{
|
|
|
Smooth53(x,N,nTimes);
|
|
|
Smooth53(y,N,nTimes);
|
|
|
}
|
|
|
|
|
|
|
|
|
for(int i = 0; i < N; i ++ )
|
|
|
{
|
|
|
inputContour[i].x = x[i];
|
|
|
inputContour[i].y = y[i];
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
delete []x;
|
|
|
delete []y;
|
|
|
}
|
|
|
|
|
|
void COutlineDetector::TraceBorder()
|
|
|
{
|
|
|
m_border.clear();
|
|
|
|
|
|
convertSurfaceToMat(m_pSurface,m_pSurface->GetRange()[0],m_pSurface->GetRange()[1],
|
|
|
m_matBorder);
|
|
|
|
|
|
vector<vector<Point>> contours;
|
|
|
vector<Vec4i> hierarchy;
|
|
|
// hierarchy 四个参数：下一个，前一个，子轮廓，父轮廓 （不存在则为-1)
|
|
|
findContours(m_matBorder, contours, hierarchy, RETR_TREE, CHAIN_APPROX_NONE, Point());
|
|
|
|
|
|
if(contours.size() > 0)
|
|
|
{
|
|
|
m_border.resize(contours[0].size());
|
|
|
for(int i = 0; i < contours[0].size(); i ++ )
|
|
|
{
|
|
|
m_border[i] = contours[0][i];
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void COutlineDetector::createContours()
|
|
|
{
|
|
|
|
|
|
|
|
|
m_originalContours.clear();
|
|
|
m_faciesContours.clear();
|
|
|
|
|
|
vector<vector<Point>> contours;
|
|
|
vector<Vec4i> hierarchy;
|
|
|
// hierarchy 四个参数：下一个，前一个，子轮廓，父轮廓 （不存在则为-1)
|
|
|
findContours(m_matMorp, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point());
|
|
|
|
|
|
|
|
|
// //查看轮廓线
|
|
|
// Mat tmpMat;
|
|
|
// cvtColor(m_matMorp,tmpMat,COLOR_GRAY2RGB);
|
|
|
|
|
|
// drawContours(tmpMat,contours,-1,Scalar(0,0,255));
|
|
|
// namedWindow("tmpMat",WINDOW_NORMAL);
|
|
|
// imshow("tmpMat",tmpMat);
|
|
|
// waitKey(0);
|
|
|
|
|
|
|
|
|
////begin test
|
|
|
// WriteContours(contours,"d:/outcontours.dfd");
|
|
|
|
|
|
// FILE * fw = fopen("d:/hierarchy.txt","w");
|
|
|
// int i = 0;
|
|
|
// for(auto p: hierarchy)
|
|
|
// {
|
|
|
// fprintf(fw,"%d:%d,%d,%d,%d\n",i++,p[0],p[1],p[2],p[3]);
|
|
|
// }
|
|
|
|
|
|
// fclose(fw);
|
|
|
////end test
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// vector<vector<Point>> dstcontous;
|
|
|
// dstcontous.resize(contours.size());
|
|
|
m_originalContours.resize(contours.size() );
|
|
|
|
|
|
for (int i = 0; i < contours.size(); i ++ )
|
|
|
{
|
|
|
approxPolyDP(contours[i], m_originalContours[i], 1, true);
|
|
|
|
|
|
}
|
|
|
|
|
|
m_hierarchy.assign(hierarchy.begin(),hierarchy.end() );
|
|
|
|
|
|
// m_hierarchy.clear();
|
|
|
|
|
|
// //去除首个曲线（总轮廓线）
|
|
|
// m_hierarchy.reserve(hierarchy.size()-1);
|
|
|
// for(int i = 1; i < hierarchy.size(); i ++ )
|
|
|
// {
|
|
|
// cv::Vec4i tmp = hierarchy[i];
|
|
|
// for(int j = 0; j < 4; j ++ )
|
|
|
// {
|
|
|
// tmp[j] -= 1;
|
|
|
// if(tmp[j] < -1)
|
|
|
// tmp[j] = -1;
|
|
|
// }
|
|
|
|
|
|
// m_hierarchy.push_back(tmp);
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
// drawContours(m_matSrc, m_contours, -1, Scalar(255, 0, 0));
|
|
|
|
|
|
// namedWindow("轮廓线",WINDOW_NORMAL);
|
|
|
// imshow("轮廓线",m_matSrc);
|
|
|
|
|
|
|
|
|
// //imshow("轮廓", big);
|
|
|
// imwrite("d:/轮廓线.bmp", img);
|
|
|
// //WriteContours("d:/等值线.dfd", contours, 10, 10);
|
|
|
|
|
|
|
|
|
// waitKey(0);
|
|
|
|
|
|
|
|
|
// TraceBorder();//追踪边界轮廓线
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
void COutlineDetector::FilterContours(float minArea, std::vector<std::vector<cv::Point2f>>& ReservedContours)
|
|
|
{
|
|
|
|
|
|
double dx = m_pSurface->DeltX();
|
|
|
double dy = m_pSurface->DeltY();
|
|
|
double gridArea = dx*dy;
|
|
|
//对应图片上的面积
|
|
|
double imArea = minArea/gridArea;
|
|
|
|
|
|
if(m_originalContours.empty() || imArea < 1e-4 )
|
|
|
{
|
|
|
ReservedContours.assign(m_originalContours.begin(),m_originalContours.end() );
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
ReservedContours.reserve(m_originalContours.size() );
|
|
|
|
|
|
for(auto& p:m_originalContours)
|
|
|
{
|
|
|
if(p.size() < 3)
|
|
|
continue;
|
|
|
double area = contourArea(p);
|
|
|
if(area < imArea)
|
|
|
continue;
|
|
|
ReservedContours.push_back(p);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
Mat &COutlineDetector::getResultMat()
|
|
|
{
|
|
|
return m_matMorp;
|
|
|
}
|
|
|
|
|
|
void COutlineDetector::convertSurfaceToMat(GSurface *pSrcSurf, float zlower, float zupper, Mat &dstMat)
|
|
|
{
|
|
|
int nx = pSrcSurf->XNum()-1;
|
|
|
int ny = pSrcSurf->YNum() - 1;
|
|
|
|
|
|
|
|
|
// Mat构造：行数，列数，存储结构，数据，step每行多少字节
|
|
|
dstMat = cv::Mat::zeros(ny,nx, CV_8UC1) ; //缺省黑色
|
|
|
|
|
|
float v;
|
|
|
zlower -= 1e-4;
|
|
|
zupper += 1e-4;
|
|
|
for(int j = 0; j < ny; j ++)
|
|
|
{
|
|
|
for(int i = 0; i < nx; i ++)
|
|
|
{
|
|
|
v = pSrcSurf->Z(i,j);
|
|
|
if(v > zlower && v < zupper)
|
|
|
{
|
|
|
dstMat.at<uchar>(j,i) = 255; // 对指定的像素赋值为白色
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
bool COutlineDetector::convertMatToSurface(Mat& mat, float x0, float y0, float deltX, float deltY, GSurface* pDstSurf)
|
|
|
{
|
|
|
|
|
|
int nx = mat.cols;
|
|
|
int ny = mat.rows;
|
|
|
if(nx < 2 || ny < 2)
|
|
|
return false;
|
|
|
|
|
|
pDstSurf->Create(nx,ny,x0,y0,deltX,deltY);
|
|
|
|
|
|
|
|
|
switch (mat.type())
|
|
|
{
|
|
|
case CV_8UC1:
|
|
|
|
|
|
for(int j = 0; j < ny; j ++)
|
|
|
{
|
|
|
uchar* p = mat.ptr<uchar>(j);
|
|
|
for(int i = 0; i < nx; i ++ )
|
|
|
{
|
|
|
pDstSurf->setZ(i,j,(unsigned int)p[i]);
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
case CV_32FC1: //float
|
|
|
|
|
|
for(int j = 0; j < ny; j ++)
|
|
|
{
|
|
|
float* p = mat.ptr<float>(j);
|
|
|
for(int i = 0; i < nx; i ++ )
|
|
|
{
|
|
|
pDstSurf->setZ(i,j,(float)p[i]);
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
|
|
|
return false;
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pDstSurf->CalcRange();
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
bool COutlineDetector::ConvertMatToQImage(cv::Mat & mat, QImage & image, QImage::Format fmt )
|
|
|
{
|
|
|
|
|
|
if (mat.empty()) {
|
|
|
qDebug() << "load image fail!";
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
switch (mat.type())
|
|
|
{
|
|
|
case CV_8UC1:
|
|
|
{
|
|
|
image = QImage(mat.cols, mat.rows, QImage::Format_Indexed8);
|
|
|
//set the color table
|
|
|
image.setColorCount(256);
|
|
|
for (int i = 0; i < 256; i++)
|
|
|
image.setColor(i, qRgb(i, i, i));
|
|
|
|
|
|
//copy input mat
|
|
|
uchar* pSrc = mat.data;
|
|
|
for (int row = 0; row < mat.rows; row++)
|
|
|
{
|
|
|
uchar* pDest = image.scanLine(row);
|
|
|
memcpy(pDest, pSrc, mat.cols);
|
|
|
pSrc += mat.step;
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
}
|
|
|
case CV_8UC3:
|
|
|
image = QImage((const unsigned char*)mat.data, mat.cols, mat.rows, mat.step, QImage::Format_RGB888);
|
|
|
image = image.rgbSwapped(); // BRG转为RGB
|
|
|
// Qt5.14增加了Format_BGR888
|
|
|
// image = QImage((const unsigned char*)mat.data, mat.cols, mat.rows, mat.cols * 3, QImage::Format_BGR888);
|
|
|
break;
|
|
|
case CV_8UC4:
|
|
|
image = QImage((const unsigned char*)mat.data, mat.cols, mat.rows, mat.step, QImage::Format_ARGB32);
|
|
|
break;
|
|
|
case CV_16UC4:
|
|
|
image = QImage((const unsigned char*)mat.data, mat.cols, mat.rows, mat.step, QImage::Format_RGBA8888);// Format_RGBA64);
|
|
|
image = image.rgbSwapped(); // BRG转为RGB
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
if (!image.isNull())
|
|
|
image = image.convertToFormat(fmt);
|
|
|
|
|
|
return true;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
bool COutlineDetector::ConvertQImageToMat(const QImage &image, cv::Mat& mat)
|
|
|
{
|
|
|
|
|
|
switch (image.format())
|
|
|
{
|
|
|
case QImage::Format_Grayscale8: // 灰度图，每个像素点1个字节（8位）
|
|
|
// Mat构造：行数，列数，存储结构，数据，step每行多少字节
|
|
|
mat = cv::Mat(image.height(), image.width(), CV_8UC1, (void*)image.constBits(), image.bytesPerLine());
|
|
|
break;
|
|
|
case QImage::Format_ARGB32: // uint32存储0xAARRGGBB，pc一般小端存储低位在前，所以字节顺序就成了BGRA
|
|
|
case QImage::Format_RGB32: // Alpha为FF
|
|
|
case QImage::Format_ARGB32_Premultiplied:
|
|
|
mat = cv::Mat(image.height(), image.width(), CV_8UC4, (void*)image.constBits(), image.bytesPerLine());
|
|
|
break;
|
|
|
case QImage::Format_RGB888: // RR,GG,BB字节顺序存储
|
|
|
mat = cv::Mat(image.height(), image.width(), CV_8UC3, (void*)image.constBits(), image.bytesPerLine());
|
|
|
// opencv需要转为BGR的字节顺序
|
|
|
cv::cvtColor(mat, mat, cv::COLOR_RGB2BGR);
|
|
|
break;
|
|
|
|
|
|
case QImage::Format_Indexed8:
|
|
|
mat = cv::Mat(image.height(), image.width(), CV_8UC1, (void*)image.bits(), image.bytesPerLine());
|
|
|
break;
|
|
|
//case QImage::Format_RGBA64: // uint64存储，顺序和Format_ARGB32相反，RGBA
|
|
|
// mat = cv::Mat(image.height(), image.width(), CV_16UC4, (void*)image.constBits(), image.bytesPerLine());
|
|
|
// // opencv需要转为BGRA的字节顺序
|
|
|
// cv::cvtColor(mat, mat, cv::COLOR_RGBA2BGRA);
|
|
|
// break;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
|