opencv测试

╰半橙微兮° 2022-11-07 01:44 64阅读 0赞

#include<iostream>
    #include<string.h>
    #include<math.h>
    #include<vector>
    #include<opencv2/core/core.hpp>
    #include<opencv2/opencv.hpp>
    #include <opencv2/imgproc.hpp>
    #include<opencv2/highgui.hpp>
    #include "opencv2/ml.hpp"
    #include "opencv2/objdetect.hpp"
    #include<opencv2/imgproc/imgproc.hpp>
    #include<opencv2\imgproc\imgproc_c.h>
    #include<opencv2\highgui\highgui.hpp>
    #include "opencv2/highgui/highgui.hpp"
    
    
    
    using namespace std;
    using namespace cv;
    
    
    void swap(int& x, int& y)
    { 
     int temp;
     temp = x;
     x = y;
     y = temp;
    
    }
    
    // 去噪匹配
    int searchmedia(int *arr, int length)
    { 
     int i, j;
     for (i = 0; i < length - 1; i++)
         for (j = 0; j < length - i - 1; j++)
         { 
             if (arr[j] > arr[j + 1])
                 swap(arr[j], arr[j + 1]);
         }
    
     return arr[4];
    
    }
    
    
    // 中值滤波去噪处理
    void MediaFilter(Mat& Saltimg, Mat& _dst)
    { 
     Mat dst = Mat(Saltimg.size(), Saltimg.type());
     int arr[9];
     // channels()返回矩阵通道的数量。
     if (dst.channels() == 3)
     { 
         for (int i = 0; i < dst.rows; i++)
             for (int j = 0; j < dst.cols; j++)
             { 
                 if (i - 1 > 0 && j - 1 > 0 && i < dst.rows - 1 && j < dst.cols - 1)
                 { 
                     arr[0] = Saltimg.at<Vec3b>(i - 1, j - 1)[0];
                     arr[1] = Saltimg.at<Vec3b>(i - 1, j)[0];
                     arr[2] = Saltimg.at<Vec3b>(i - 1, j + 1)[0];
                     arr[3] = Saltimg.at<Vec3b>(i, j - 1)[0];
                     arr[4] = Saltimg.at<Vec3b>(i, j)[0];
                     arr[5] = Saltimg.at<Vec3b>(i, j + 1)[0];
                     arr[6] = Saltimg.at<Vec3b>(i + 1, j - 1)[0];
                     arr[7] = Saltimg.at<Vec3b>(i + 1, j)[0];
                     arr[8] = Saltimg.at<Vec3b>(i + 1, j + 1)[0];
                     dst.at<Vec3b>(i, j)[0] = searchmedia(arr, 9);
    
                     arr[0] = Saltimg.at<Vec3b>(i - 1, j - 1)[1];
                     arr[1] = Saltimg.at<Vec3b>(i - 1, j)[1];
                     arr[2] = Saltimg.at<Vec3b>(i - 1, j + 1)[1];
                     arr[3] = Saltimg.at<Vec3b>(i, j - 1)[1];
                     arr[4] = Saltimg.at<Vec3b>(i, j)[1];
                     arr[5] = Saltimg.at<Vec3b>(i, j + 1)[1];
                     arr[6] = Saltimg.at<Vec3b>(i + 1, j - 1)[1];
                     arr[7] = Saltimg.at<Vec3b>(i + 1, j)[1];
                     arr[8] = Saltimg.at<Vec3b>(i + 1, j + 1)[1];
                     dst.at<Vec3b>(i, j)[1] = searchmedia(arr, 9);
    
                     arr[0] = Saltimg.at<Vec3b>(i - 1, j - 1)[2];
                     arr[1] = Saltimg.at<Vec3b>(i - 1, j)[2];
                     arr[2] = Saltimg.at<Vec3b>(i - 1, j + 1)[2];
                     arr[3] = Saltimg.at<Vec3b>(i, j - 1)[2];
                     arr[4] = Saltimg.at<Vec3b>(i, j)[2];
                     arr[5] = Saltimg.at<Vec3b>(i, j + 1)[2];
                     arr[6] = Saltimg.at<Vec3b>(i + 1, j - 1)[2];
                     arr[7] = Saltimg.at<Vec3b>(i + 1, j)[2];
                     arr[8] = Saltimg.at<Vec3b>(i + 1, j + 1)[2];
                     dst.at<Vec3b>(i, j)[2] = searchmedia(arr, 9);
    
                 }
                 else
                 { 
                     dst.at<Vec3b>(i, j)[0] = Saltimg.at<Vec3b>(i, j)[0];
                     dst.at<Vec3b>(i, j)[1] = Saltimg.at<Vec3b>(i, j)[1];
                     dst.at<Vec3b>(i, j)[2] = Saltimg.at<Vec3b>(i, j)[2];
                 }
             }
     }
     else if (dst.channels() == 1)
     { 
         for (int i = 0; i < dst.rows; i++)
             for (int j = 0; j < dst.cols; j++)
             { 
                 if (i - 1 > 0 && j - 1 > 0 && i < dst.rows - 1 && j < dst.cols - 1)
                 { 
    
                     arr[0] = Saltimg.at<uchar>(i - 1, j - 1);
                     arr[1] = Saltimg.at<uchar>(i - 1, j);
                     arr[2] = Saltimg.at<uchar>(i - 1, j + 1);
                     arr[3] = Saltimg.at<uchar>(i, j - 1);
                     arr[4] = Saltimg.at<uchar>(i, j);
                     arr[5] = Saltimg.at<uchar>(i, j + 1);
                     arr[6] = Saltimg.at<uchar>(i + 1, j - 1);
                     arr[7] = Saltimg.at<uchar>(i + 1, j);
                     arr[8] = Saltimg.at<uchar>(i + 1, j + 1);
                     dst.at<uchar>(i, j) = searchmedia(arr, 9);
                 }
    
                 else
                 { 
                     dst.at<uchar>(i, j) = Saltimg.at<uchar>(i, j);
                 }
    
             }
    
    
     }
     dst.copyTo(_dst);
    
    }
    
    int gray[256] = {  0 };  //记录每个灰度级别下的像素个数
    double gray_prob[256] = {  0 };  //记录灰度分布密度
    double gray_distribution[256] = {  0 };  //记录累计密度
    int gray_equal[256] = {  0 };  //均衡化后的灰度值
    
    int gray_sum = 0;  //像素总数
    
    Mat equalize_hist(Mat& input)
    { 
     Mat output = input.clone();
     gray_sum = input.cols * input.rows;
    
     //统计每个灰度下的像素个数
     for (int i = 0; i < input.rows; i++)
     { 
         uchar* p = input.ptr<uchar>(i);
         for (int j = 0; j < input.cols; j++)
         { 
             int vaule = p[j];
             gray[vaule]++;
         }
     }
    
    
     //统计灰度频率
     for (int i = 0; i < 256; i++)
     { 
         gray_prob[i] = ((double)gray[i] / gray_sum);
     }
    
     //计算累计密度
     gray_distribution[0] = gray_prob[0];
     for (int i = 1; i < 256; i++)
     { 
         gray_distribution[i] = gray_distribution[i - 1] + gray_prob[i];
     }
    
     //重新计算均衡化后的灰度值，四舍五入。参考公式：(N-1)*T+0.5
     for (int i = 0; i < 256; i++)
     { 
         gray_equal[i] = (uchar)(255 * gray_distribution[i] + 0.5);
     }
    
    
     //直方图均衡化,更新原图每个点的像素值
     for (int i = 0; i < output.rows; i++)
     { 
         uchar* p = output.ptr<uchar>(i);
         for (int j = 0; j < output.cols; j++)
         { 
             p[j] = gray_equal[p[j]];
         }
     }
    
     return output;
    }
    
    // 画直方图
    void drawHist(Mat& img)
    { 
     //为计算直方图配置变量 
     //首先是需要计算的图像的通道，就是需要计算图像的哪个通道（bgr空间需要确定计算 b或g货r空间） 
     int channels = 0;
     //然后是配置输出的结果存储的 空间 ，用MatND类型来存储结果 
     MatND dstHist;
     //接下来是直方图的每一个维度的 柱条的数目（就是将数值分组，共有多少组） 
     int histSize[] = {  256 };       //如果这里写成int histSize = 256; 那么下面调用计算直方图的函数的时候，该变量需要写 &histSize 
     //最后是确定每个维度的取值范围，就是横坐标的总数 
     //首先得定义一个变量用来存储 单个维度的 数值的取值范围 
     float midRanges[] = {  0, 256 };
     const float *ranges[] = {  midRanges };
    
     calcHist(&img, 1, &channels, Mat(), dstHist, 1, histSize, ranges, true, false);
    
     //calcHist 函数调用结束后，dstHist变量中将储存了 直方图的信息 用dstHist的模版函数 at<Type>(i)得到第i个柱条的值 
     //at<Type>(i, j)得到第i个并且第j个柱条的值 
    
     //开始直观的显示直方图——绘制直方图 
     //首先先创建一个黑底的图像，为了可以显示彩色，所以该绘制图像是一个8位的3通道图像 
     Mat drawImage = Mat::zeros(Size(256, 256), CV_8UC3);
     //因为任何一个图像的某个像素的总个数，都有可能会有很多，会超出所定义的图像的尺寸，针对这种情况，先对个数进行范围的限制 
     //先用 minMaxLoc函数来得到计算直方图后的像素的最大个数 
     double g_dHistMaxValue;
     minMaxLoc(dstHist, 0, &g_dHistMaxValue, 0, 0);
     //将像素的个数整合到 图像的最大范围内 
     //遍历直方图得到的数据 
     for (int i = 0; i < 256; i++)
     { 
         int value = cvRound(dstHist.at<float>(i) * 256 * 0.9 / g_dHistMaxValue);
    
         line(drawImage, Point(i, drawImage.rows - 1), Point(i, drawImage.rows - 1 - value), Scalar(255, 255, 255));
     }
     namedWindow("直方图",WINDOW_AUTOSIZE);
     imshow("直方图", drawImage);
    }
    
    int DetectThreshold(Mat *src)
    { 
     uchar iThrehold;//阀值
    
     try
     { 
         int height = src->cols; 
         int width = src->rows;
         int step = src->rows / sizeof(uchar);
         uchar *data = src->data;
    
         cout << src->cols << endl
             << src->rows<<endl;
    
         int iDiffRec = 0;
         int F[256] = {  0 }; //直方图数组 
         int iTotalGray = 0;//灰度值和 
         int iTotalPixel = 0;//像素数和 
         uchar bt;//某点的像素值 
    
         uchar iNewThrehold;//新阀值
         uchar iMaxGrayValue = 0, iMinGrayValue = 255;//原图像中的最大灰度值和最小灰度值 
         uchar iMeanGrayValue1, iMeanGrayValue2;
    
         //获取(i,j)的值，存于直方图数组F 
         for (int i = 0; i < width; i++)
         { 
             for (int j = 0; j < height; j++)
             { 
                 bt = data[i*step + j];
                 if (bt < iMinGrayValue)
                     iMinGrayValue = bt;
                 if (bt > iMaxGrayValue)
                     iMaxGrayValue = bt;
                 F[bt]++;
             }
         }
    
         iThrehold = 0;
         iNewThrehold = (iMinGrayValue + iMaxGrayValue) / 2;//初始阀值 
         iDiffRec = iMaxGrayValue - iMinGrayValue;
    
         for (int a = 0; (abs(iThrehold - iNewThrehold) > 0.5); a++)//迭代中止条件 
         { 
             iThrehold = iNewThrehold;
             //小于当前阀值部分的平均灰度值 
             for (int i = iMinGrayValue; i < iThrehold; i++)
             { 
                 iTotalGray += F[i] * i;//F[]存储图像信息 
                 iTotalPixel += F[i];
             }
             iMeanGrayValue1 = (uchar)(iTotalGray / iTotalPixel);
             //大于当前阀值部分的平均灰度值 
             iTotalPixel = 0;
             iTotalGray = 0;
             for (int j = iThrehold + 1; j < iMaxGrayValue; j++)
             { 
                 iTotalGray += F[j] * j;//F[]存储图像信息 
                 iTotalPixel += F[j];
             }
             iMeanGrayValue2 = (uchar)(iTotalGray / iTotalPixel);
    
             iNewThrehold = (iMeanGrayValue2 + iMeanGrayValue1) / 2; //新阀值 
             iDiffRec = abs(iMeanGrayValue2 - iMeanGrayValue1);
         }
     }
     catch (cv::Exception e)
     { 
     }
    
     return iThrehold;
    }
    
    
    //度数转换
    double degreeTurn(double theta)
    { 
     double finaldegree = theta / CV_PI * 180;
     return finaldegree;
    }
    
    //逆时针旋转图像degree角度（原尺寸） 
    void rotateImage(Mat Img, Mat& rotateImg, double degree)
    { 
     //旋转中心为图像中心 
     Point2f center;
     center.x = float(Img.cols / 2.0);
     center.y = float(Img.rows / 2.0);
     int length = 0;
     length = sqrt(Img.cols * Img.cols + Img.rows * Img.rows);
     Mat matrix = getRotationMatrix2D(center, degree, 1);//仿射变换矩阵
     warpAffine(Img, rotateImg, matrix, Size(length, length), 1, 0, Scalar(255, 255, 255));//原大小进行仿射变换
    }
    
    //通过霍夫变换计算角度
    double CalcDegree(const Mat& srcImage)
    { 
     Mat midImage;
     Sobel(srcImage, midImage, -1, 0, 1, 5);
     //通过霍夫变换检测直线
     vector<Vec2f> lines;
     HoughLines(midImage, lines, 1, CV_PI / 180, 300, 0, 0);//阈值越大，精度越高
     //根据阈值由大到小设置了三个阈值，如果经过大量试验后，可以固定一个适合的阈值。
     if (!lines.size())
     { 
         HoughLines(midImage, lines, 1, CV_PI / 180, 200, 0, 0);
     }
     if (!lines.size())
     { 
         HoughLines(midImage, lines, 1, CV_PI / 180, 150, 0, 0);
     }
     float all_t = 0;
     for (size_t i = 0; i < lines.size(); i++)
     { 
         float theta = lines[i][1];//选择角度最小的角作为旋转角
         //计算所有角度
         all_t += theta;
     }
     float average = all_t / lines.size(); //对所有角度求平均
     double degree = degreeTurn(average) - 90;
     return degree;
    }
    
    
    int main()
    { 
     // 存放所有路径名
     vector<string> m_item;
     //string m_pathname="D:\\Study\\temp\\image\\*.jpg";
     string m_pathname = "image\\*.jpg";
     glob(m_pathname, m_item);
     /* 路径测试 vector<string>::iterator it; for (it=m_item.begin();it!= m_item.end() ; it++) { cout << *it << endl; }*/
    
    
     // 处理每一个图片
     for (int i = 0; i < m_item.size(); ++i)
     { 
    
         Mat src = imread(m_item[i]);
         if (src.empty())
         { 
             cout << "加载图片 :" << m_item[i] << " 失败!" << endl;
             continue;
         }
         Mat gray_dst, result_dst;
         cvtColor(src, gray_dst, COLOR_BGR2GRAY);
         // 去噪处理
         MediaFilter(gray_dst, result_dst);
    
         /* 去噪处理后 图片显示测试代码 */
         namedWindow("原图", WINDOW_NORMAL);
         imshow("原图", src);
    
         namedWindow("灰度图", WINDOW_NORMAL);
         imshow("灰度图", gray_dst);
         // 去噪处理
         MediaFilter(gray_dst, result_dst);
    
         namedWindow("中值滤波去噪后", WINDOW_NORMAL);
         imshow("中值滤波去噪后", result_dst);
    
         //cout << "处理图片 :" << m_item[i] << " 成功!" << endl;
    
         // 灰度直方图
         //int nRows = 600, nCols = 800;
         //Mat g_dstImg(nRows, nCols, CV_8UC1, Scalar::all(0)); // 新建画布
         //namedWindow("g_dstImg", WINDOW_AUTOSIZE);
         //imshow("g_dstImg", g_dstImg);
    
    
         
         //Mat histImg = equalize_hist(result_dst);
         
         // namedWindow("均值化图", WINDOW_NORMAL);
         //imshow("均值化图", histImg);
    
         // drawHist(result_dst);
         drawHist(result_dst);
         // adaptiveThreshold(result_dst, temp, 255,ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY,21,10);
         //namedWindow("原图", WINDOW_NORMAL);
         //imshow("原图", histImg);
    
         Mat *decect=new Mat(result_dst);
         int dec=DetectThreshold(decect);
         
         cout << dec << endl;
         Mat binaryImg;
         threshold(result_dst, binaryImg, dec, 255, CV_THRESH_BINARY);
         namedWindow("二值图", WINDOW_NORMAL);
         imshow("二值图", binaryImg);
    
    
         //Mat angleImg;
         //angleCount(result_dst,angleImg);
         //namedWindow("角度图", WINDOW_NORMAL);
         //imshow("角度图", angleImg);
    
    
    
         // 输出二值图片
    
         //string strnn;
         //strnn += ".\\new\\";
         //strnn += m_item[i];
         //strnn += +".jpg";
         //cout << strnn << endl;
         //imwrite(strnn, binaryImg);
    
    
    
    
         waitKey(0);
     }
    
    
     waitKey(0);
     return 0;
    }