【OpenCV圖像處理】雷射條紋線段提取、中心線提取

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <stdio.h>
using namespace std;
using namespace cv;

//-----------------------------------【全局變量聲明部分】--------------------------------------
//		描述：全局變量聲明
//-----------------------------------------------------------------------------------------------
Mat g_srcImage, g_dstImage, g_midImage, g_grayImage, imgHSVMask;//原始圖、中間圖和效果圖
int threshold_value = 60;	//門檻值
int size = 800;				//面積因子
float start_time,end_time,sum_time;	//處理時間

//-----------------------------------【全局函數聲明部分】--------------------------------------
//		描述：全局函數聲明
//-----------------------------------------------------------------------------------------------
void ThinSubiteration1(Mat & pSrc, Mat & pDst);
void ThinSubiteration2(Mat & pSrc, Mat & pDst);
void normalizeLetter(Mat & inputarray, Mat & outputarray);
void Line_reflect(Mat & inputarray, Mat & outputarray);
void Delete_smallregions(Mat & pSrc, Mat & pDst);

//-----------------------------------【main( )函數】--------------------------------------------
//		描述：控制台應用程式的入口函數，我們的程式從這裡開始
//-----------------------------------------------------------------------------------------------
int main( )
{ 
	//載入原始圖
	g_srcImage = imread("3.jpg");  //讀取素材圖
	start_time = getTickCount();	//開始處理時間

	//顯示灰階圖  
	cvtColor(g_srcImage, g_grayImage, CV_RGB2GRAY);
	imshow("【灰階圖】", g_grayImage); 

	//二值化
	threshold(g_grayImage, imgHSVMask, threshold_value, 255, THRESH_BINARY);
	g_midImage = Mat::zeros(imgHSVMask.size(), CV_8UC1);  //繪制
	
	//去除小面積區域
	Delete_smallregions(imgHSVMask, g_midImage);
	imshow("【目标圖】", g_midImage);
	imwrite("Target_image3.jpg", g_midImage);

	//normalizeLetter顯示效果圖  
	normalizeLetter(g_midImage,g_dstImage);
	imshow("【效果圖】", g_dstImage);  
	
	//曲線映射到原圖
/*	threshold(g_grayImage, g_midImage, threshold_value, 255, CV_THRESH_BINARY);	*/
/*	imshow("【二值化圖】", g_midImage);											*/
	Line_reflect(g_dstImage,g_midImage);
	imshow("【映射圖】", g_midImage); 
	imwrite("Reflect_image3.jpg", g_midImage);

	//轉換類型，儲存skeleton圖像
	normalize(g_dstImage, g_midImage, 0, 255, NORM_MINMAX, CV_8U);	
	imwrite("Thinning_image3.jpg", g_midImage);

	//計算運作時間
	end_time = getTickCount();
	sum_time = (end_time - start_time)/ getTickFrequency();
	printf("%lf s",sum_time);
	
	waitKey(0);  

	return 0;  

}


void ThinSubiteration1(Mat & pSrc, Mat & pDst) {
        int rows = pSrc.rows;
        int cols = pSrc.cols;
        pSrc.copyTo(pDst);
        for(int i = 0; i < rows; i++) {
                for(int j = 0; j < cols; j++) {
                        if(pSrc.at<float>(i, j) == 1.0f) {
                                /// get 8 neighbors
                                /// calculate C(p)
                                int neighbor0 = (int) pSrc.at<float>( i-1, j-1);
                                int neighbor1 = (int) pSrc.at<float>( i-1, j);
                                int neighbor2 = (int) pSrc.at<float>( i-1, j+1);
                                int neighbor3 = (int) pSrc.at<float>( i, j+1);
                                int neighbor4 = (int) pSrc.at<float>( i+1, j+1);
                                int neighbor5 = (int) pSrc.at<float>( i+1, j);
                                int neighbor6 = (int) pSrc.at<float>( i+1, j-1);
                                int neighbor7 = (int) pSrc.at<float>( i, j-1);
                                int C = int(~neighbor1 & ( neighbor2 | neighbor3)) +
                                                 int(~neighbor3 & ( neighbor4 | neighbor5)) +
                                                 int(~neighbor5 & ( neighbor6 | neighbor7)) +
                                                 int(~neighbor7 & ( neighbor0 | neighbor1));
                                if(C == 1) {
                                        /// calculate N
                                        int N1 = int(neighbor0 | neighbor1) +
                                                         int(neighbor2 | neighbor3) +
                                                         int(neighbor4 | neighbor5) +
                                                         int(neighbor6 | neighbor7);
                                        int N2 = int(neighbor1 | neighbor2) +
                                                         int(neighbor3 | neighbor4) +
                                                         int(neighbor5 | neighbor6) +
                                                         int(neighbor7 | neighbor0);
                                        int N = min(N1,N2);
                                        if ((N == 2) || (N == 3)) {
                                                /// calculate criteria 3
                                                int c3 = ( neighbor1 | neighbor2 | ~neighbor4) & neighbor3;
                                                if(c3 == 0) {
                                                        pDst.at<float>( i, j) = 0.0f;
                                                }
                                        }
                                }
                        }
                }
        }
}


void ThinSubiteration2(Mat & pSrc, Mat & pDst) {
        int rows = pSrc.rows;
        int cols = pSrc.cols;
        pSrc.copyTo( pDst);
        for(int i = 0; i < rows; i++) {
                for(int j = 0; j < cols; j++) {
                        if (pSrc.at<float>( i, j) == 1.0f) {
                                /// get 8 neighbors
                                /// calculate C(p)
                            int neighbor0 = (int) pSrc.at<float>( i-1, j-1);
                            int neighbor1 = (int) pSrc.at<float>( i-1, j);
                            int neighbor2 = (int) pSrc.at<float>( i-1, j+1);
                            int neighbor3 = (int) pSrc.at<float>( i, j+1);
                            int neighbor4 = (int) pSrc.at<float>( i+1, j+1);
                            int neighbor5 = (int) pSrc.at<float>( i+1, j);
                            int neighbor6 = (int) pSrc.at<float>( i+1, j-1);
                            int neighbor7 = (int) pSrc.at<float>( i, j-1);
                                int C = int(~neighbor1 & ( neighbor2 | neighbor3)) +
                                        int(~neighbor3 & ( neighbor4 | neighbor5)) +
                                        int(~neighbor5 & ( neighbor6 | neighbor7)) +
                                        int(~neighbor7 & ( neighbor0 | neighbor1));
                                if(C == 1) {
                                        /// calculate N
                                        int N1 = int(neighbor0 | neighbor1) +
                                                int(neighbor2 | neighbor3) +
                                                int(neighbor4 | neighbor5) +
                                                int(neighbor6 | neighbor7);
                                        int N2 = int(neighbor1 | neighbor2) +
                                                int(neighbor3 | neighbor4) +
                                                int(neighbor5 | neighbor6) +
                                                int(neighbor7 | neighbor0);
                                        int N = min(N1,N2);
                                        if((N == 2) || (N == 3)) {
                                                int E = (neighbor5 | neighbor6 | ~neighbor0) & neighbor7;
                                                if(E == 0) {
                                                        pDst.at<float>(i, j) = 0.0f;
                                                }
                                        }
                                }
                        }
                }
        }
}


void normalizeLetter(Mat & inputarray, Mat & outputarray) {
        bool bDone = false;
        int rows = inputarray.rows;
        int cols = inputarray.cols;

        inputarray.convertTo(inputarray,CV_32FC1);

        inputarray.copyTo(outputarray);

        outputarray.convertTo(outputarray,CV_32FC1);

        /// pad source
        Mat p_enlarged_src = Mat(rows + 2, cols + 2, CV_32FC1);
        for(int i = 0; i < (rows+2); i++) {
            p_enlarged_src.at<float>(i, 0) = 0.0f;
            p_enlarged_src.at<float>( i, cols+1) = 0.0f;
        }
        for(int j = 0; j < (cols+2); j++) {
                p_enlarged_src.at<float>(0, j) = 0.0f;
                p_enlarged_src.at<float>(rows+1, j) = 0.0f;
        }
        for(int i = 0; i < rows; i++) {
                for(int j = 0; j < cols; j++) {
                        if (inputarray.at<float>(i, j) >= threshold_value) {			//調參
                                p_enlarged_src.at<float>( i+1, j+1) = 1.0f;
                        }
                        else
                                p_enlarged_src.at<float>( i+1, j+1) = 0.0f;
                }
        }

        /// start to thin
        Mat p_thinMat1 = Mat::zeros(rows + 2, cols + 2, CV_32FC1);
        Mat p_thinMat2 = Mat::zeros(rows + 2, cols + 2, CV_32FC1);
        Mat p_cmp = Mat::zeros(rows + 2, cols + 2, CV_8UC1);

        while (bDone != true) {
                /// sub-iteration 1
                ThinSubiteration1(p_enlarged_src, p_thinMat1);
                /// sub-iteration 2
                ThinSubiteration2(p_thinMat1, p_thinMat2);
                /// compare
                compare(p_enlarged_src, p_thinMat2, p_cmp, CV_CMP_EQ);	//比較輸入的src1和src2中的元素，真為255，否則為0
                /// check
                int num_non_zero = countNonZero(p_cmp);					//傳回灰階值不為0的像素數
                if(num_non_zero == (rows + 2) * (cols + 2)) {
                        bDone = true;
                }
                /// copy
                p_thinMat2.copyTo(p_enlarged_src);
        }
        // copy result
        for(int i = 0; i < rows; i++) {
                for(int j = 0; j < cols; j++) {
                        outputarray.at<float>( i, j) = p_enlarged_src.at<float>( i+1, j+1);
                }
        }
}

void Line_reflect(Mat & inputarray, Mat & outputarray)
{
	int rows = inputarray.rows;
    int cols = inputarray.cols;
	for(int i = 0; i < rows; i++) {
                for(int j = 0; j < cols; j++) {
                        if (inputarray.at<float>(i, j) == 1.0f) {
                                outputarray.at<float>( i, j) = 0.0f;
                        }
                }
    }
}

// 提取連通區域，并剔除小面積聯通區域
void Delete_smallregions(Mat & pSrc, Mat & pDst)
{
	vector<vector<Point>> contours;           //二值圖像輪廓的容器
	vector<Vec4i> hierarchy;                  //4個int向量，分别表示後、前、父、子的索引編号
	findContours(pSrc, contours, hierarchy,RETR_LIST, CHAIN_APPROX_NONE);             //檢測所有輪廓
 
	vector<vector<Point>>::iterator k;                    //疊代器，通路容器資料
 
	for (k = contours.begin(); k != contours.end();)      //周遊容器,設定面積因子
	{
		if (contourArea(*k, false) < size)
		{//删除指定元素，傳回指向删除元素下一個元素位置的疊代器
			k = contours.erase(k);
		}
		else
			++k;
	}
 
	//contours[i]代表第i個輪廓，contours[i].size()代表第i個輪廓上所有的像素點
	for (int i = 0; i < contours.size(); i++)
	{
		for (int j = 0; j < contours[i].size(); j++)
		{
			//擷取輪廓上點的坐标
			Point P = Point(contours[i][j].x, contours[i][j].y);
		}
		drawContours(pDst, contours,i, Scalar(255), -1, 8);
	}
}

具體例子

原圖：

提取所需要線段圖：

【OpenCV圖像處理】雷射條紋線段提取、中心線提取

骨骼化：

【OpenCV圖像處理】雷射條紋線段提取、中心線提取

将骨骼化的曲線段映射到原圖：

【OpenCV圖像處理】雷射條紋線段提取、中心線提取

【OpenCV圖像處理】雷射條紋線段提取、中心線提取

繼續閱讀

自監督｜「CoCLR」視訊自監督對比學習筆記

ubuntu14.04 編譯安裝OpenCV 3.2

opencv學習筆記（十四）——圖像像素的通路

opencv028-輪廓發現

qt-opencv圖像增強之邊緣檢測（多線程）1 .pro項目檔案配置2 ui設計3 多線程邏輯4 Canny邊緣檢測和Laplace算子5 主要代碼6 運作結果

DLP面曝光3D列印機模型資料矯正

視訊對象分割（Video Object Segmentation）研究小記任務定義與資料集技術路線分類基于神經網絡的模型總結

opencv視覺跟蹤——消除背景模組化

圖形處理單元(GPU)的演進

VS2010 / MFC + OpenCV 2.4.9打開圖檔

2021-09-30三維點雲測量正方形包裹體積

DOG算子

Gsl在VS2008下的配置和使用

如何用Opencv求圖像的灰階投影曲線

opencv——圖像的灰階處理（線性變換/拉伸/直方圖/均衡化）

cs231n斯坦福基于卷積神經網絡的CV學習筆記（一）KNN和線性分類器/分類器損失/反向傳播一，KNN圖像分類算法二，線性分類器三，線性分類器損失四，反向傳播五，神經網絡