• 实验一 熟悉OpenCV环境和基本操作

     实验一 熟悉OpenCV环境和基本操作

    一、实验目的

    熟悉OpenCV运行环境，了解图像的基本操作及直方图均衡化。

    二、实验内容

    一个简单的图像处理例子。

    代码如下：

    #include

    using namespace cv;

    int main( ) {

           Mat  img = imread("result1.bmp");

           int nr = img.rows; // number of rows

           int nc = img.cols; // number of columns

           Mat result;

           result.create(img.rows, img.cols, img.type());

           for (int j = 0; j < nr; j++) {

                  for (int i = 0; i < nc; i++) {

                         result.at(j, i)[0] = 255 - img.at(j, i)[0];

                         result.at(j, i)[1] = 255 - img.at(j, i)[1];

                         result.at(j, i)[2] = 255 - img.at(j, i)[2];

                  } // end of row

           }

           namedWindow("source");

           imshow("source", img);

           namedWindow("result");

           imshow("result", result);

           waitKey(0);

           return 0;

    }

    三、实验要求

    1.按上述代码运行，给出结果。

    2.利用OpenCV产生一幅图像，尺寸为200*240，三通道，其中某一块为红色，其它皆为黑色，示例图如下。

     

    3.对一副图像进行直方图均衡化处理。要求自行编写直方图均衡化函数，实现图像灰度均衡的算法步骤如下：

    1. 统计直方图数组，用一个数组p记录p[i]；
    2. i从1开始，令S[i]=S[i-1]+p[i]，S[0]=p[0]；
    3. 一个数组L记录新的S索引值，即令L[i]=S[i]*(256-1)；

    依次循环每一个像素，取原图的像素值作为数组L的下标值，取该下标对应的数组值为均衡化之后的像素值。

    四、实验设计思路

    1.opencv的安装与环境配置，根据所给代码进行运行并输出结果。

    2.先生成一个200*240三通道的黑色图像，再生成一个rgb只有一个红色通道的红色图像。

    3. 将一副图像的直方图分布变成近似均匀分布，从而增强图像的对比度。对图像进行非线性拉伸,重新分配图像象元值,使一定灰度范围内象元值的数量大致相等。统计每个灰度级别下的像素个数与灰度分布密度，通过均衡化算法累加概率乘以255，并四舍五入步骤等更新原图每个点的像素值。

    五、实验代码

    1.

    1. #include 
    2.  
    3. using namespace cv;
    4.  
    5. int main() {
    6.  
    7.     Mat img = imread("result1.bmp");
    8.  
    9.     int nr = img.rows; // number of rows
    10.  
    11.     int nc = img.cols; // number of columns
    12.  
    13.     Mat result;
    14.  
    15.     result.create(img.rows, img.cols, img.type());
    16.  
    17.     for (int j = 0; j < nr; j++) {
    18.  
    19.         for (int i = 0; i < nc; i++) {
    20.  
    21.             result.at(j, i)[0] = 255 - img.at(j, i)[0];
    22.  
    23.             result.at(j, i)[1] = 255 - img.at(j, i)[1];
    24.  
    25.             result.at(j, i)[2] = 255 - img.at(j, i)[2];
    26.  
    27.         } // end of row
    28.  
    29.     }
    30.  
    31.     namedWindow("source");
    32.  
    33.     imshow("source", img);
    34.  
    35.     namedWindow("result");
    36.  
    37.     imshow("result", result);
    38.  
    39.     waitKey(0);
    40.  
    41.     return 0;
    42.  
    43. }

    2.

    1. #include 
    2.  
    3. using namespace cv;
    4.  
    5. int main() {
    6.  
    7.     Mat img = imread("result1.bmp");
    8.  
    9.     int nr = 240; // number of rows
    10.  
    11.     int nc = 200; // number of columns
    12.  
    13.     Mat result;
    14.  
    15.     result.create(240, 200, img.type());
    16.  
    17.     for (int j = 0; j < nr; j++) {
    18.  
    19.         for (int i = 0; i < nc; i++) {
    20.  
    21.                 result.at(j, i)[0] = 0;
    22.  
    23.                 result.at(j, i)[1] = 0;
    24.  
    25.                 result.at(j, i)[2] = 0;
    26.  
    27.             } // end of row
    28.  
    29.     }
    30.  
    31.     for (int j = nr/5; j < nr/2; j++) {
    32.  
    33.             for (int i = nc/4; i < nc/2; i++) {
    34.  
    35.                 result.at(j, i)[0] = 0;
    36.  
    37.                 result.at(j, i)[1] = 0;
    38.  
    39.                 result.at(j, i)[2] = 255;
    40.  
    41.             } // end of row
    42.  
    43.     }
    44.  
    45.     namedWindow("result");
    46.  
    47.     imshow("result", result);
    48.  
    49.     waitKey(0);
    50.  
    51.     return 0;
    52.  
    53.    
    54.  
    55. }

    3.

    1. #include
    2.  
    3. #include
    4.  
    5. using namespace cv;
    6.  
    7. using namespace std;
    8.  
    9.  
    10.  
    11. int main()
    12.  
    13. {
    14.  
    15.  
    16.  
    17.     //Mat InputImage = imread("D:\\shana.jpg ", 1);
    18.  
    19.     Mat InputImage = imread("result1.bmp");
    20.  
    21.     imshow("原图", InputImage);
    22.  
    23.     int  Gray_Count[256] = { 0 };  //每个灰度级别下的像素个数
    24.  
    25.     double Gray_Distribution_Density[256] = { 0 }; //灰度分布密度
    26.  
    27.     double Gray_Density_Sum[256] = { 0 }; //累计密度
    28.  
    29.     int Result[256] = { 0 };  //均衡化后的灰度值
    30.  
    31.     int Pixel_Sum = InputImage.cols * InputImage.rows;
    32.  
    33.     int Pixel_Value;
    34.  
    35.  
    36.  
    37.     Mat OutputImage(InputImage.size(), CV_8UC1, Scalar(0));
    38.  
    39.     //gray=0.299R+0.587G+0.114b
    40.  
    41.     uchar r, g, b;
    42.  
    43.     float fgray;
    44.  
    45.     //对图像的灰度处理
    46.  
    47.     for (int m = 0; m < 100; m++)
    48.  
    49.         for (int i = 0; i < InputImage.size().height; i++)
    50.  
    51.             for (int j = 0; j < InputImage.size().width; j++)
    52.  
    53.             { //默认图像的channel排列顺序为 BGR
    54.  
    55.                 b = InputImage.at(i, j)[0];
    56.  
    57.                 g = InputImage.at(i, j)[1];
    58.  
    59.                 r = InputImage.at(i, j)[2];
    60.  
    61.                 fgray = 0.299 * r + 0.587 * g + 0.114 * b;//R,G,B转换灰度图像的常用公式
    62.  
    63.                 OutputImage.at(i, j) = saturate_cast(fgray);//防止颜色溢出，对图像色彩变化时做的保护
    64.  
    65.             }
    66.  
    67.     imshow("灰度图", OutputImage);//显示灰度图像
    68.  
    69.  
    70.  
    71.     for (int image_y = 0; image_y < InputImage.rows; image_y++)//遍历图片
    72.  
    73.     {
    74.  
    75.         uchar* p = InputImage.ptr(image_y);
    76.  
    77.         for (int image_x = 0; image_x < InputImage.cols; image_x++)
    78.  
    79.         {
    80.  
    81.             Pixel_Value = p[image_x];
    82.  
    83.             Gray_Count[Pixel_Value]++;//统计每个灰度下的像素个数
    84.  
    85.         }
    86.  
    87.     }
    88.  
    89.  
    90.  
    91.     for (int i = 0; i < 256; i++)
    92.  
    93.     {
    94.  
    95.         Gray_Distribution_Density[i] = ((double)Gray_Count[i] / Pixel_Sum);//统计灰度频率
    96.  
    97.     }
    98.  
    99.     Gray_Density_Sum[0] = Gray_Distribution_Density[0];
    100.  
    101.     for (int i = 1; i < 256; i++)
    102.  
    103.     {
    104.  
    105.         Gray_Density_Sum[i] = Gray_Density_Sum[i - 1] + Gray_Distribution_Density[i]; //计算累计密度
    106.  
    107.     }
    108.  
    109.     for (int i = 0; i < 256; i++)
    110.  
    111.     {
    112.  
    113.         Result[i] = 255 * Gray_Density_Sum[i];//计算均衡化后的灰度值
    114.  
    115.     }
    116.  
    117.  
    118.  
    119.     for (int image_y = 0; image_y < InputImage.rows; image_y++)//遍历图片
    120.  
    121.     {
    122.  
    123.         uchar* p = OutputImage.ptr(image_y);
    124.  
    125.         for (int image_x = 0; image_x < InputImage.cols; image_x++)
    126.  
    127.         {
    128.  
    129.             p[image_x] = Result[p[image_x]]; //直方图均衡化,更新原图每个点的像素值
    130.  
    131.         }
    132.  
    133.     }
    134.  
    135.     imshow("均衡化", OutputImage);
    136.  
    137.     waitKey();
    138.  
    139.     return 0;
    140.  
    141. }

    六、实验结果与心得体会

    1.

    2.

    3.

  • 相关阅读:
    Kuboard - Kubernetes 多集群管理界面
    面试突击55：delete、drop、truncate有什么区别？
    【Spring Cloud系列】 雪花算法原理及实现
    618过后，该如何做视频号？
    第2-4-4章 规则引擎Drools规则属性-业务规则管理系统-组件化-中台
    Vue3学习——pinia
    沙盘游戏咨询感悟
    用户体验成为继MAU后，手机银行竞争分化的下一分水岭，易观千帆重磅发布手机银行APP用户体验GX评测
    六、DataLoader
    [附源码]java毕业设计网上书店的设计
  • 原文地址：https://blog.csdn.net/weixin_48388330/article/details/126415301