计算机视觉作业（EX2）

最新推荐文章于 2022-06-05 19:47:55 发布
最新推荐文章于 2022-06-05 19:47:55 发布
阅读量727 收藏 1
点赞数
分类专栏： 作业 文章标签： 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hkiller1999/article/details/101041822
版权

计算机视觉实验报告

Ex2：用 CImg 重写、封装给定的 Canny 代码，并测试

  1. 附件有三个 Canny 相关的 Code 以及测试数据若干(测试数据自己转化成 BMP 图
    像)；
  2. 同学按照各自学号最末尾的数字除 3 取余数，余数为 0 的改写 Code0，余数为 1
    的改写 Code1，余数为 2 的改写 Code2；
  3. 封装要求： (1)所有的图像读写、数据处理只能用 CImg 库(整个工程文件不允许
    使用 Opencv 之类的第三方库)； (2)代码封装要求函数接口简洁清晰， 可参考
    Code2 的方式封装。
  4. 在原来的代码基础上, 增加一个函数： 首先把相邻的边缘连成长的线条，并删除
    长度小于 20 的 Edge。 分析删除这些短 Edge 有何优缺点?
  5. 对算法的若干组参数，对所有测试图像进行测试， 保存输出 Canny 算法每个主
    要步骤的结果图像, 并分析各参数对结果的影响。

这里我们要改写的代码为code1

具体做法：
首先我们先查看一下code1中的代码，在代码中我们首先找到了关于canny边缘检测的几个博客，首先这里我们先说一下实验原理：

Canny-Edge-Algorithm：

实现 canny 边缘检测的原理通俗来说就是用离散化的梯度逼近函数根据二维灰度矩阵梯度向量来寻找图像灰度矩阵的灰度跃变位置，然后再图像中将这些点连起来就形成了图像的边缘。

开始

首先我们写的程序针对的图像类型是bmp，这里我直接没有打码，而是直接将图片通过转换工具转换成bmp24位位图格式。
接下来我们需要了解以下几个过程

1、图像的灰度化：

Gimg = 0.299R+0.587G+0.114B
话不多说，上代码。

void canny::toGrayScale()
{
    grayscaled.assign(img._width, img._height); //To one channel
    cimg_forXY(img, x, y) {
        
        int r = img(x,y,0);
        int g = img(x,y,1);
        int b = img(x,y,2);
        double newValue = (r * 0.2126 + g * 0.7152 + b * 0.0722);

        grayscaled(x,y) = (unsigned char)(newValue);
    }

}

这里使用cimg头文件编写灰度化代码类toGrayScale()。
测试灰度，效果如下：
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

使用sobel算子计算各点梯度矢量。
这里有对sobel算子的主要介绍：sobel算子

void canny::sobel()
{

    //Sobel X Filter
    double x1[] = {-1.0, 0, 1.0};
    double x2[] = {-2.0, 0, 2.0};
    double x3[] = {-1.0, 0, 1.0};

    vector< vector<double> > xFilter(3);
    xFilter[0].assign(x1, x1+3);
    xFilter[1].assign(x2, x2+3);
    xFilter[2].assign(x3, x3+3);
    
    //Sobel Y Filter
    double y1[] = {1.0, 2.0, 1.0};
    double y2[] = {0, 0, 0};
    double y3[] = {-1.0, -2.0, -1.0};
    
    vector< vector<double> > yFilter(3);
    yFilter[0].assign(y1, y1+3);
    yFilter[1].assign(y2, y2+3);
    yFilter[2].assign(y3, y3+3);
    
    //Limit Size
    int size = (int)xFilter.size()/2;
    
    sFiltered = CImg<unsigned char>(gFiltered._width - 2*size, gFiltered._height - 2*size);
    
    angles = CImg<unsigned char>(gFiltered._width - 2*size, gFiltered._height - 2*size); //AngleMap

	for (int i = size; i < gFiltered._height - size; i++)
	{
		for (int j = size; j < gFiltered._width - size; j++)
		{
			double sumx = 0;
            double sumy = 0;
            
			for (int x = 0; x < xFilter.size(); x++)
				for (int y = 0; y < xFilter.size(); y++)
				{
                    sumx += xFilter[x][y] * (double)(gFiltered(j + y - size, i + x - size)); //Sobel_X Filter Value
                    sumy += yFilter[x][y] * (double)(gFiltered(j + y - size, i + x - size)); //Sobel_Y Filter Value
				}
            double sumxsq = sumx*sumx;
            double sumysq = sumy*sumy;
            
            double sq2 = sqrt(sumxsq + sumysq);
            
            if(sq2 > 255) //Unsigned Char Fix
                sq2 =255;
            sFiltered(j-size, i-size) = sq2;
 
            if(sumx==0) //Arctan Fix
                angles(j-size, i-size) = 90;
            else
                angles(j-size, i-size) = atan(sumy/sumx);
		}
	}
    
}

其次对梯度幅值进行最大限制：

void canny::nonMaxSupp()
{
    nonMaxSupped = CImg<unsigned char>(sFiltered._width-2, sFiltered._height-2);
    for (int i=1; i< sFiltered._width - 1; i++) {
        for (int j=1; j<sFiltered._height - 1; j++) {
            float Tangent = angles(i,j) * 57.296f;
            // cout << Tangent << ' ';
            nonMaxSupped(i-1, j-1) = sFiltered(i,j);
            //Horizontal Edge
            if (((-22.5 < Tangent) && (Tangent <= 22.5)) || ((157.5 < Tangent) && (Tangent <= -157.5)))
            {
                if ((sFiltered(i,j) < sFiltered(i+1,j)) || (sFiltered(i,j) < sFiltered(i-1,j)))
                    nonMaxSupped(i-1, j-1) = 0;
            }
            //Vertical Edge
            if (((-112.5 < Tangent) && (Tangent <= -67.5)) || ((67.5 < Tangent) && (Tangent <= 112.5)))
            {
                if ((sFiltered(i,j) < sFiltered(i,j+1)) || (sFiltered(i,j) < sFiltered(i,j-1)))
                    nonMaxSupped(i-1, j-1) = 0;
            }
            
            //-45 Degree Edge
            if (((-67.5 < Tangent) && (Tangent <= -22.5)) || ((112.5 < Tangent) && (Tangent <= 157.5)))
            {
                if ((sFiltered(i,j) < sFiltered(i+1,j+1)) || (sFiltered(i,j) < sFiltered(i-1,j-1)))
                    nonMaxSupped(i-1, j-1) = 0;

            }
            
            //45 Degree Edge
            if (((-157.5 < Tangent) && (Tangent <= -112.5)) || ((22.5 < Tangent) && (Tangent <= 67.5)))
            {
                if ((sFiltered(i,j) < sFiltered(i-1,j+1)) || (sFiltered(i,j) < sFiltered(i+1,j-1)))
                    nonMaxSupped(i-1, j-1) = 0;
            }
        }
        // cout << '\n';
    }

}

高斯滤波去噪对边缘检测的影响，以及双阙值检测和连接边缘

void canny::threshold(CImg<unsigned char> imgin,int low, int high)
{
    if(low > 255)
        low = 255;
    if(high > 255)
        high = 255;
    
    thres = CImg<unsigned char>(imgin._width, imgin._height);
    
    for (int i=0; i<imgin._width; i++) 
    {
        for (int j = 0; j<imgin._height; j++) 
        {
            thres(i,j) = imgin(i,j);
            if(thres(i,j) > high)
                thres(i,j) = 255;
            else if(thres(i,j) < low)
                thres(i,j) = 0;
            else
            {
                bool anyHigh = false;
                bool anyBetween = false;
                for (int x=i-1; x < i+2; x++) 
                {
                    for (int y = j-1; y<j+2; y++) 
                    {
                        //a missing "x" in Hasan's code.
                        if(x <= 0 || y <= 0 || x > thres._width || y > thres._height) //Out of bounds
                            continue;
                        else
                        {
                            if(thres(x,y) > high)
                            {
                                thres(i,j) = 255;
                                anyHigh = true;
                                break;
                            }
                            else if(thres(x,y) <= high && thres(x,y) >= low)
                                anyBetween = true;
                        }
                    }
                    if(anyHigh)
                        break;
                }
                if(!anyHigh && anyBetween)
                    for (int x=i-2; x < i+3; x++) 
                    {
                        for (int y = j-1; y<j+3; y++) 
                        {
                            if(x < 0 || y < 0 || x > thres._width || y > thres._height) //Out of bounds
                                continue;
                            else
                            {
                                if(thres(x,y) > high)
                                {
                                    thres(i,j) = 255;
                                    anyHigh = true;
                                    break;
                                }
                            }
                        }
                        if(anyHigh)
                            break;
                    }
                if(!anyHigh)
                    thres(i,j) = 0;
            }
        }
    }

}

最后关于将相邻边缘连成线条，同时也要注意删除长度小于20的线条。

CImg<int> canny::canny_line(CImg<int> picture, int distance) {
	CImg<int> pic = picture;
	//用于计算某一个像素点是否为边缘点
	//判断方法为查看以这个点为中心的八邻域，如果附近只有1个像素点为0, 其他7个为255则是边缘点
	bool isEdge[1000][1000];
	cimg_forXY(pic, x, y) {
		isEdge[x][y] = false;
		if (x != rows - 1 && x != 0 && y != cols - 1 && y != 0 && pic(x, y) == 0) {
			int linyu[8];
			int m = 0;
			for (int i = x - 1; i <= x + 1; i++) {
				for (int j = y - 1; j <= y + 1; j++) {
					if (!(i == x && j == y)) {
						linyu[m] = pic(i, j);
						m++;
					}
				}
			}
			sort(linyu, linyu + 8);
			if (linyu[0] == 0 && linyu[1] == 255)
				isEdge[x][y] = true;
		}
	}
	cimg_forXY(pic, x, y) {
		if (x >= distance && x <= rows - 1 - distance && y >= distance && y <= cols - 1 - distance && isEdge[x][y] == true) {
			for (int i = x - distance; i <= x + distance; i++) {
				for (int j = y - distance; j <= y + distance; j++) {
					if (isEdge[i][j] == true) {
						pic = Draw_line(pic, x, y, i, j);
						isEdge[i][j] = false;
						isEdge[x][y] = false;
					}
				}
			}
		}
	}
	return pic;
}

CImg<int> canny::delete_line(CImg<int> picture) {
	//用于计算某一个像素点是否为边缘点
	//判断方法为查看以这个点为中心的八邻域，如果附近只有1个像素点为0, 其他7个为255则是边缘点
	CImg<int> pic = picture;
	bool isEdge[1000][1000];
	cimg_forXY(pic, x, y) {
		isEdge[x][y] = false;
		if (x != rows - 1 && x != 0 && y != cols - 1 && y != 0 && pic(x, y) == 0) {
			int linyu[8];
			int m = 0;
			for (int i = x - 1; i <= x + 1; i++) {
				for (int j = y - 1; j <= y + 1; j++) {
					if (!(i == x && j == y)) {
						linyu[m] = pic(i, j);
						m++;
					}
				}
			}
			sort(linyu, linyu + 8);
			if (linyu[0] == 0 && linyu[1] == 255)
				isEdge[x][y] = true;
			//删除单个孤立的点
			if (linyu[0] == 255)
				pic(x, y) = 255;
		}
	}
	//删除长度少于20的连线
	//判断如果两个边界点的距离小于20，就删除这两个边界点组成的矩阵内所有黑点，这样的话即使两个边界点分别是两条直线的话也无所谓
	//反正是这样的话这两边界点之间都是白色区域，删除也无所谓
	cimg_forXY(pic, x, y) {
		int distance = 20;
		if (isEdge[x][y] == true) {
			int begin_x = x - distance > 0 ? x - distance : 0;
			int begin_y = y - distance > 0 ? y - distance : 0;
			int end_x = x + distance < rows - 1 ? x + distance : rows - 1;
			int end_y = y + distance < cols - 1 ? y + distance : cols - 1;
			for (int i = begin_x; i <= end_x; i++) {
				for (int j = begin_y; j <= end_y; j++) {
					if (isEdge[i][j] == true) {
						int max_x = x >= i ? x : i;
						int max_y = y >= j ? y : j;
						int min_x = max_x == x ? i : x;
						int min_y = max_y == y ? j : y;
						for (int ii = min_x; ii <= max_x; ii++) {
							for (int jj = min_y; jj <= max_y; jj++) {
								pic(ii, jj) = 255;
							}
						}
						isEdge[i][j] = false;
						isEdge[x][y] = false;
					}
				}
			}
		}
	}
	//删除经过上一步处理完可能存在的单个孤立的噪声点
	cimg_forXY(pic, x, y) {
		if (x != rows - 1 && x != 0 && y != cols - 1 && y != 0 && pic(x, y) == 0) {
			int linyu[8];
			int m = 0;
			for (int i = x - 1; i <= x + 1; i++) {
				for (int j = y - 1; j <= y + 1; j++) {
					if (!(i == x && j == y)) {
						linyu[m] = pic(i, j);
						m++;
					}
				}
			}
			sort(linyu, linyu + 8);
			if (linyu[0] == 255)
				pic(x, y) = 255;
		}
	}
	return pic;
}

CImg<int> Draw_line(CImg<int> tmp, int x, int y, int x1, int y1) {

	CImg <int> TempImg = tmp;
	int black[] = { 0,0,0 };
	TempImg.draw_line(x, y, x1, y1, black);
	return TempImg;
}

开始时调整参数的效果图（以lena为例）：
gsize = 3
gs = 3, g_sig = 1, threslo = 40, threshi = 60;
在这里插入图片描述
运行时界面：
在这里插入图片描述
gsize = 5
gs = 3, g_sig = 1, threslo = 40, threshi = 60;
在这里插入图片描述
gsize = 7
gs = 3, g_sig = 1, threslo = 40, threshi = 60;
在这里插入图片描述
运行时界面：
在这里插入图片描述
我们发现光改变sgize的值图像没有变化，我们改变阙值来进行观察。
sgize = 3
int gs = 3, g_sig = 1, threslo = 20, threshi = 40;
在这里插入图片描述
sgize = 3
int gs = 3, g_sig = 1, threslo = 4, threshi = 10;
在这里插入图片描述
明显可以看出当 threslo和threshi参数变小时，线条的密集程度更加复杂起来。
从这里我们可以得到以下结论：
高阈值减小，此时将会增加很多强边缘像素，因为大于选定这个阈值的
像素点都将被确定为边缘。
而高阈值增大，原来的强边缘像素大部分会转化为弱边缘像素，丢失一部分边缘像素点。这是因为被划分为强边缘的像素点已经被确定为边缘，因为它们是从图像中的真实边缘中提取出来的。

参考目录：
[1]https://github.com/isVoid/CImg_Canny
[2]https://github.com/WangPerryWPY/Computer-Version
[3]https://github.com/hasanakg/Canny-Edge-Detector

hkiller1999
关注
专栏目录
python计算机视觉作业1
qq_37772863的博客
03-06 498
开始学python计算机视觉这本教材，博主写这篇博文记录下本书第一章的例程 1、 2、
计算机视觉作业1
cyh_first的博客
03-22 376
实验1 计算机视觉图像处理基础操作直方图原理代码opencvPIL结果直方图均衡化原理代码opencvPIL结果高斯滤波原理代码opencvPIL结果 直方图 原理 正常的图片使用RGB三个通道的，分别对每一个像素在这三个通道上的数值进行统计可得直方图。可以研究亮度分布直方图来验证直方图的性质 直方图反映了图像的动态范围，也就是对比度 若图像质量较高，则其灰度分布应该较为均匀。 一幅图像的部分直方图合并之后与整体直方图相同 直方图并不能反映图像像素的灰度位置分布 代码 opencv img = cv.i
计算机视觉（三）图像拼接
热门推荐
qq_45749702的博客
04-13 1万+
文章目录一、映射与拼接流程二、算法2.1 全景拼接2.2 RANSAC算法 一、映射与拼接流程 要拼接多张图像，就一定要找到他们之间的映射关系，流程如下： 得到映射关系，就能进行拼接： 简而言之，拼接两张图像，就是找到他们的特征点，根据这些特征点： 找到两张图像的像素点对应关系，然后把第二张图像映射到在第一张图像的坐标系下，二者合成新的图像，若是有多张图，就重复这个步骤。 下面给出了不同映射需要的特征点数： 二、算法 2.1 全景拼接 将SIFT应用到图像拼接上，根据特征点匹配的方式，则利用这些匹
计算机视觉作业
weixin_38907184的博客
12-21 1285
https://blog.csdn.net/Accelerato/article/details/105627078
吴恩达机器学习作业ex2
02-25
【标题】"吴恩达机器学习作业ex2"主要涵盖了机器学习的基础概念，特别是线性回归和正则化的应用。这个作业是针对吴恩达在Coursera上开设的“机器学习”课程中的第二部分，旨在帮助学生深入理解并实践线性模型的训练...
（全）2020吴恩达机器学习MachineLearning第三周编程作业ex2
05-04
在本压缩包“（全）2020吴恩达机器学习MachineLearning第三周编程作业ex2”中，包含了吴恩达教授的《Machine Learning》课程第三周编程作业ex2的完整解决方案。作业主要涉及了机器学习的基础概念，特别是线性回归...
计算机视觉课程作业
weixin_44264994的博客
01-02 1222
计算机视觉课程（Win10+OpenCV+Qt） 说明 为记录研一计算机视觉课程作业代码而写，工程名为week1_qt，算是图像处理的入门，代码里可能有一些错误（原理或代码编写） week1_qt.h #ifndef WEEK1_QT_H #define WEEK1_QT_H #include <QtWidgets/QMainWindow> #include "ui_week1_qt...
【计算机视觉】作业一
joezarlove88的博客
03-12 4659
直方图定义 横坐标:图像中各个像素点的灰度级 纵坐标:就有该灰度级的像素个数 原图： 彩色图像直方图： 代码： #coding=utf-8 import cv2 import numpy as np img = cv2.imread('1.jpg') h = np.zeros((256,256,3)) #创建用于绘制直方图的全0图像 bins = np.arange(256).reshape(256,1) #直方...
计算机视觉大作业
05-28
在用户界面上实现计算机视觉的图像处理，哈哈镜，假彩色，锐化滤波
电子科技大-计算机视觉第一次作业(2017最新版)
09-26
电子科技大，计算机视觉作业，2017最新版，根据原版网站答案进行修改得到，疏漏之处，还请多多见谅。 材料网址：http://pages.cs.wisc.edu/~dyer/cs766/hw/hw1/
人脸识别-计算机视觉大作业
04-26
人脸识别作业，主要结合主成分分析(Principal Components Analysis, PCA)与线性判别分析(Linear Discriminant Analysis, LDA)的特点，提出PCA+LDA算法，并与LDA比价
计算机视觉 第一次试验
01-04
计算机视觉第一次大作业主要代码，实验一 :混合图像实验目标是编写一个图像滤波函数，并用它基于Oliva、Torralba和Schyns在SIGGRAPH 2006发表的题为“Hybrid images”的论文的简化版本创建混合图像。混合图像是静态图像，其解释随着观看距离的变化而变化。其基本思想是，高频往往在感知中占主导地位，但在远处，只能看到信号的低频(平滑)部分。通过将一幅图像的高频部分与另一幅图像的低频部分混合，可以得到一幅混合图像，在不同的距离产生不同的解释。你将使用你自己的解决方案来创建你自己的混合图像。
计算机视觉作业（二）Local Feature Matching
sinat_41942180的博客
08-13 4844
一、实验原理 特征匹配是图像处理和计算机视觉的核心组成部分。在本次实验中，我们将创建一个局部特征匹配算法，并尝试匹配真实场景的多个视图。将实现一个简化版本的sift，用于解决局部特征匹配问题，使检测到的特征对遮挡和杂波具有鲁棒性。由于特性是本地的，可以在一张图像中生成数百或数千个特性，同时能够实现实时性能。我们使用Harris角点检测器和sift特征描述符来生成关键点,同时也使用了自适应非最大抑制来获得图像上的均匀分布的角。 二、实验目的 本实验要求实现图像的特征匹配，对于给定的两幅图像，均使用Har
计算机视觉作业-le02
kingcrimsons的博客
03-15 148
利用RGB格式显示图像，只保留R通道图像数据，G、B通道数据置零，观察显示效果。 import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt import numpy as np %matplotlib inline #读入图片 im = plt.imread('dog.jpg') print('the data demension of input image is:') print(im.shape) pl
计算机视觉 作业二
weixin_45775594的博客
04-05 3495
文章目录一、Harris角点1.角点2.角点检测算法3.Harris检测算法的数学表示4.角点计算流程5.Harris角点特征描述6.Harris角点检测的优缺点7.Harris角点检测的实现 一、Harris角点 1.角点 • 局部窗口沿各方向移动，均产生明显变化的点 • 图像局部曲率突变的点 不同类型的角点： 2.角点检测算法 好的角点检测算法满足： • 检测出图像中“真实的”角点 • 准确的定位性能 • 很高的稳定性 • 具有对噪声的鲁棒性 • 具有较高的计算效率 典型的角点检测算法： • Harr
计算机视觉第一次实验作业
cheny的博客
11-18 864
作业要求： 1、图像采集、输入与显示 2、软件界面搭建 3、在界面上实现 (1)原图像的显示 (2)处理结果的显示 (3)处理功能按钮 (4)功能包括：2D傅立叶变换、均值滤波、中值滤波、开运算、闭运算、图像均衡化 各功能的截图如下： 2D傅立叶变换： 均值滤波: 中值滤波: 开运算: 闭运算: 图像均衡化: ...
计算机视觉课后作业——编写程序以实现“感知器(感知准则)”算法:
m0_48093733的博客
06-05 491
计算机视觉课后作业——编写程序以实现“感知器(感知准则)”算法:
台达PLC编程指南：DVP-ES2/EX2系列
"台达PLC编程文档，涵盖了台达PLC EX2/ES2系列的编程基础知识、程序概念、指令集以及通讯方面的内容，旨在帮助用户进行编程查询和学习。" 在台达PLC编程中，了解梯形图的基本原理至关重要。PLC扫描方法是指PLC如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值