harris角点检测(c++)

最新推荐文章于 2024-07-25 12:32:58 发布
最新推荐文章于 2024-07-25 12:32:58 发布
阅读量832 收藏 5
点赞数
分类专栏： 机器学习 c++ 文章标签： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixuefeng2305/article/details/116465003
版权

Harris角点检测 图像处理 Sobel算子 Harris响应 C++实现
关键词由CSDN通过智能技术生成

harris.h

#ifndef HARRIS_H_
#define HARRIS_H_
#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <string>
#include <conio.h>
#include <easyx.h>
#include <vector>
#include <algorithm>
#include <math.h>
using namespace std;
typedef unsigned char uchar;
typedef vector<vector<long> >  LONG_2DVEC;
typedef vector<vector<float> > FLOAT_2DVEC;
typedef vector<vector<uchar> > UCHAR_2DVEC;
typedef vector<vector<int> >   INT_2DVEC;

typedef vector<long>  LONG_VEC;
typedef vector<float> FLOAT_VEC;
typedef vector<int>   INT_VEC;

typedef vector<vector<int> >   CORNER_VEC;

void  ConvertStringToWchar(string sToMatch, wchar_t * lpwsz);
IMAGE ConvertBGRToGRAY(IMAGE srcImage);
IMAGE SobelGradintX(IMAGE grayImage);
IMAGE SobelGradintY(IMAGE grayImage);

INT_2DVEC SobelGradint2DVectorX(IMAGE grayImage);
INT_2DVEC SobelGradint2DVectorY(IMAGE grayImage);


LONG_2DVEC  SobelXX(IMAGE GXImage);
LONG_2DVEC  SobelXY(IMAGE GXImage, IMAGE GYImage);
LONG_2DVEC  SobelYY(IMAGE GYImage);

FLOAT_2DVEC HarrisResponse(LONG_2DVEC GradXX, LONG_2DVEC GradXY, LONG_2DVEC GradYY, float k);
UCHAR_2DVEC DataNormalize(FLOAT_2DVEC Response);
CORNER_VEC  LocalMaxValue(UCHAR_2DVEC Response);
CORNER_VEC  HarrisCornerDetection(IMAGE srcImage);
void PaintCorner(CORNER_VEC CORNER_VECTOR, IMAGE srcIMAGE);

#endif // !HARRIS_H_

harris.c

#include "harris.h"

void  ConvertStringToWchar(string sToMatch, wchar_t * lpwsz)
{
	// 计算转换后宽字符串的长度。（不包含字符串结束符） 
	int iWLen = MultiByteToWideChar(CP_ACP, 0, sToMatch.c_str(), sToMatch.size(), 0, 0); 
	MultiByteToWideChar(CP_ACP, 0, sToMatch.c_str(), sToMatch.size(), lpwsz, iWLen); // 正式转换。 
	lpwsz[iWLen] = L'\0';

}

IMAGE ConvertBGRToGRAY(IMAGE srcImage) {
	int rows = srcImage.getheight();
	int cols = srcImage.getwidth();
	IMAGE grayImage = srcImage;
	DWORD* GRAY_PTR = GetImageBuffer(&grayImage);
	vector<uchar> vec(cols, 0);
	vector<vector<uchar> > Vec(rows, vec);
	for (int i = 0; i < rows; i++)
	{
		for (int j = 0; j < cols; j++)
		{
			*GRAY_PTR = BGR(*GRAY_PTR);//显存是RGB，图像在内存存储为
			Vec.at(i).at(j) = (GetRValue(*GRAY_PTR) * 299 + GetGValue(*GRAY_PTR) * 587 + GetBValue(*GRAY_PTR) * 114  +500) / 1000;
			*GRAY_PTR = RGB(Vec.at(i).at(j), Vec.at(i).at(j), Vec.at(i).at(j));
			GRAY_PTR++;

		}
	}
	GRAY_PTR -= rows * cols;
	return grayImage;
}

IMAGE SobelGradintX(IMAGE srcImage) {
	
	int rows = srcImage.getheight();
	int cols = srcImage.getwidth();
	DWORD* PTR = GetImageBuffer(&srcImage);

	IMAGE GXImage = srcImage;
	DWORD* GX_PTR = GetImageBuffer(&GXImage);

	int Grad = 0;
	for (int i = 1; i < rows - 1; i++)
	{
		for (int j = 1; j < cols - 1; j++)
		{
			Grad = (GetRValue(*(PTR+(i-1)* cols+j-1)) + 2* GetRValue(*(PTR + (i-1)*cols + j))
				+ GetRValue(*(PTR+(i-1) * cols + j+1)))- (GetRValue(*(PTR+(i+1)* cols+j-1)) +
					2 * GetRValue(*(PTR+(i+1)* cols+j)) + GetRValue(*(PTR+(i+1)* cols+j +1)));
			*(GX_PTR + i * cols +j) = RGB(abs(Grad), abs(Grad), abs(Grad));
		}
	}

	return GXImage;
}
INT_2DVEC SobelGradint2DVectorX(IMAGE grayImage) {
	
	int rows = grayImage.getheight();
	int cols = grayImage.getwidth();
	INT_VEC vec(cols,0);
	INT_2DVEC Vec(rows,vec);
	DWORD* PTR = GetImageBuffer(&grayImage);


	int Grad = 0;
	for (int i = 1; i < rows - 1; i++)
	{
		for (int j = 1; j < cols - 1; j++)
		{
			Grad = (GetRValue(*(PTR + (i - 1)* cols + j - 1)) + 2 * GetRValue(*(PTR + (i - 1)*cols + j))
				+ GetRValue(*(PTR + (i - 1) * cols + j + 1))) - (GetRValue(*(PTR + (i + 1)* cols + j - 1)) +
					2 * GetRValue(*(PTR + (i + 1)* cols + j)) + GetRValue(*(PTR + (i + 1)* cols + j + 1)));
			Vec.at(i).at(j) = abs(Grad);
		}
	}
	return Vec;
}

IMAGE SobelGradintY(IMAGE srcImage) {
	int rows = srcImage.getheight();
	int cols = srcImage.getwidth();

	DWORD* PTR = GetImageBuffer(&srcImage);

	IMAGE GYImage = srcImage;
	DWORD* GY_PTR = GetImageBuffer(&GYImage);

	int Grad = 0;
	for (int i = 1; i < rows - 1; i++)
	{
		for (int j = 1; j < cols - 1; j++)
		{
			Grad = (GetRValue(*(PTR + (i - 1)* cols + j + 1)) + 2 * GetRValue(*(PTR + i * cols + j + 1)) 
			   + GetRValue (*(PTR + (i + 1)* cols + j + 1)))- (GetRValue(*(PTR + (i - 1)* cols + j - 1))
				+ 2 * GetRValue(*(PTR + i * cols + j - 1)) + GetRValue(*(PTR + (i + 1)* cols + j - 1)));
			*(GY_PTR + i * cols + j) = RGB(abs(Grad), abs(Grad), abs(Grad));
		}
	}

	return GYImage;
}
INT_2DVEC SobelGradint2DVectorY(IMAGE srcImage) {
	int rows = srcImage.getheight();
	int cols = srcImage.getwidth();
	INT_VEC vec(cols, 0);
	INT_2DVEC Vec(rows, vec);
	DWORD* PTR = GetImageBuffer(&srcImage);



	int Grad = 0;
	for (int i = 1; i < rows - 1; i++)
	{
		for (int j = 1; j < cols - 1; j++)
		{
			Grad = (GetRValue(*(PTR + (i - 1)* cols + j + 1)) + 2 * GetRValue(*(PTR + i * cols + j + 1))
				+ GetRValue(*(PTR + (i + 1)* cols + j + 1))) - (GetRValue(*(PTR + (i - 1)* cols + j - 1))
					+ 2 * GetRValue(*(PTR + i * cols + j - 1)) + GetRValue(*(PTR + (i + 1)* cols + j - 1)));
			Vec.at(i).at(j) = abs(Grad);
		}
	}

	return Vec;
}

LONG_2DVEC  SobelXX(IMAGE GXImage) {
	int rows = GXImage.getheight();
	int cols = GXImage.getwidth();
	DWORD* GX_PTR = GetImageBuffer(&GXImage);

	
	LONG_2DVEC Vec ;
	LONG_VEC vec;
	int GradX = 0;
	
	for (int i = 0; i < rows ; i++)
	{	
		for (int j = 0; j < cols; j++)
		{
			GradX = GetRValue(*(GX_PTR + i * cols + j));
			vec.push_back(GradX * GradX);
			
		}
		Vec.push_back(vec);
		vec.clear();
	}
	return Vec;
}

LONG_2DVEC  SobelXY(IMAGE GXImage, IMAGE GYImage) {
	int rows = GXImage.getheight();
	int cols = GXImage.getwidth();
	DWORD* GX_PTR = GetImageBuffer(&GXImage);
	DWORD* GY_PTR = GetImageBuffer(&GYImage);


	LONG_2DVEC Vec;
	LONG_VEC vec;
	int GradX = 0;
	int GradY = 0;

	for (int i = 0; i < rows; i++)
	{
		for (int j = 0; j < cols; j++)
		{
			GradX = GetRValue(*(GX_PTR + i * cols + j));
			GradY = GetRValue(*(GY_PTR + i * cols + j));
			vec.push_back(GradX * GradY);
		}
		Vec.push_back(vec);
		vec.clear();
	}
	return Vec;
}

LONG_2DVEC  SobelYY(IMAGE GYImage) {
	int rows = GYImage.getheight();
	int cols = GYImage.getwidth();
	DWORD* PTR = GetImageBuffer(&GYImage);


	LONG_2DVEC Vec;
	LONG_VEC vec;
	int Grad = 0;

	for (int i = 0; i < rows; i++)
	{
		for (int j = 0; j < cols; j++)
		{
			Grad = GetRValue(*(PTR + i * cols + j));
			vec.push_back(Grad * Grad);

		}
		Vec.push_back(vec);
		vec.clear();
	}
	return Vec;
}

FLOAT_2DVEC HarrisResponse(LONG_2DVEC GradXX, LONG_2DVEC GradXY, LONG_2DVEC GradYY,float k) {
	int rows = GradXX.size();
	int cols = GradXX.at(0).size();
	FLOAT_2DVEC Vec;
	FLOAT_VEC vec;
	float result = 0;

	for (int i = 0; i < rows; i++)
	{
		vec.clear();
		for (int j = 0; j <cols; j++)
		{
			long a = GradXX.at(i).at(j);
			long b = GradYY.at(i).at(j);
			long c = GradXY.at(i).at(j);
			result= abs(a * b - c * c - k * (a + b)*(a + b));
			vec.push_back(result);
		}
		Vec.push_back(vec);

	}
	return Vec;
}
UCHAR_2DVEC DataNormalize(FLOAT_2DVEC Response) {
	FLOAT_2DVEC::iterator It1;
	

	int max = 0;
	int min = 0;

	
	for (It1 = Response.begin(); It1 != Response.end(); It1++) {
		if (max < *max_element((*It1).begin(), (*It1).end() )) {
			max = *max_element((*It1).begin(), (*It1).end());
		}
		else {
			max = max;
		}
		if (min > *max_element((*It1).begin(), (*It1).end() )) {
			min = *max_element((*It1).begin(), (*It1).end());
		}
		else {
			min = min;
		}
	}
	UCHAR_2DVEC ResponseNorm;
	vector<uchar> vec;
	FLOAT_VEC::iterator It2;
	for (It1 = Response.begin(); It1 != Response.end(); It1++) {
		vec.clear();
		for (It2 = (*It1).begin(); It2 != (*It1).end(); It2++) {
			vec.push_back(ceil(((*It2) / (max - min))* 255));
		}
		ResponseNorm.push_back(vec);
	}

	return ResponseNorm;
}

CORNER_VEC LocalMaxValue(UCHAR_2DVEC ResponseNorm) {
	int rows = ResponseNorm.size();
	int cols = ResponseNorm.at(0).size();
	CORNER_VEC corner_vec;
	vector<int> vec;
	for (int i = 1; i < rows - 1; i++)
	{
		for (int j = 1; j <cols - 1; j++)
		{   
			
			if ( ResponseNorm.at(i).at(j)  > ResponseNorm.at(i - 1).at(j - 1) &&
				 ResponseNorm.at(i).at(j)  > ResponseNorm.at(i - 1).at(j) &&
				 ResponseNorm.at(i).at(j)  > ResponseNorm.at(i - 1).at(j + 1) &&
				 ResponseNorm.at(i).at(j)  > ResponseNorm.at(i).at(j - 1) &&
				 ResponseNorm.at(i).at(j)  > ResponseNorm.at(i).at(j + 1) &&
				 ResponseNorm.at(i).at(j)  > ResponseNorm.at(i + 1).at(j - 1) &&
				 ResponseNorm.at(i).at(j)  > ResponseNorm.at(i + 1).at(j) &&
				 ResponseNorm.at(i).at(j)  > ResponseNorm.at(i+1).at(j + 1)){
				if (ResponseNorm.at(i).at(j) > 200){
					vec.push_back(i);
					vec.push_back(j);
					corner_vec.push_back(vec);
					vec.clear();
				}
				
			}
			
		}
		
	}
	

	return corner_vec;
}


CORNER_VEC HarrisCornerDetection(IMAGE srcImage) {
	cout << endl;
	cout << "start detecting corners,please wait patiently..." << endl;
	int rows = srcImage.getheight();
	int cols = srcImage.getwidth();
	//DWORD* PTR = GetImageBuffer(&srcImage);
	//定义角点位置向量
	

	IMAGE grayImage = ConvertBGRToGRAY(srcImage);
	IMAGE GX = SobelGradintX(grayImage);
	IMAGE GY = SobelGradintY(grayImage);

	LONG_2DVEC GradXX = SobelXX(GX);
	LONG_2DVEC GradXY = SobelXY(GX,GY);
	LONG_2DVEC GradYY = SobelXX(GY);

	FLOAT_2DVEC Response = HarrisResponse(GradXX, GradXY, GradYY,0.05);
	
    UCHAR_2DVEC ResponseNorm	= DataNormalize( Response);
	CORNER_VEC CORNER_VECTOR = LocalMaxValue(ResponseNorm);
	cout << "detection end." << endl;
	cout << "The number of corners detected is: " << CORNER_VECTOR.size() << endl;
	
   return CORNER_VECTOR;
}

void PaintCorner(CORNER_VEC CORNER_VECTOR,IMAGE srcImage) {
	initgraph(srcImage.getwidth(), srcImage.getheight(), EW_SHOWCONSOLE | EW_NOCLOSE | EW_NOMINIMIZE);
	putimage(0, 0, &srcImage);
	setlinecolor(GREEN);
	for (int i = 0; i < CORNER_VECTOR.size(); i++) {
		circle(CORNER_VECTOR.at(i).at(0), CORNER_VECTOR.at(i).at(1), 10);
	}
	FlushBatchDraw();
}

main.c


#include "harris.h"




int main()
{
	cout << "***************** CORNERS DETECTION *****************" << endl;
	cout << endl;
	cout << endl;
	while (1) {
		cout << "Whether to use the default image(Y/N): ";
		char ch ;
		cin >> ch;
		string filename;
		if (ch == 'Y') {
			filename = "building.jpg";
		}
		else {
			cout << "Please enter a image name: ";
			cin >> filename;
		}
		cout << "The image name is: " << filename << endl;
		
		int length = filename.size();
		wchar_t *lpwsz = new wchar_t[length + 1];
		ConvertStringToWchar(filename, lpwsz);
		IMAGE srcImage;
		loadimage(&srcImage, lpwsz);
		delete[]lpwsz;
		DWORD* SRC_PTR = GetImageBuffer(&srcImage);
		//CORNER_VEC CORNER_VECTOR;
		if (SRC_PTR == NULL) {
			cout << "There are no the image named " << filename << endl;
			cout << "Click any key to continue." << endl;
			cout << endl;
		}
		else{
			int imageHight, imageWidth;
			imageHight = srcImage.getheight();
			imageWidth = srcImage.getwidth();
			IMAGE grayImage = ConvertBGRToGRAY(srcImage);
			initgraph(imageWidth, imageHight, EW_SHOWCONSOLE |EW_NOCLOSE | EW_NOMINIMIZE);
			putimage(0, 0, &srcImage);
			cout << "Click any key to start detecting corners." << endl;
			_getch();
	        CORNER_VEC CORNER_VECTOR = HarrisCornerDetection(srcImage);
			cout << endl;
			cout << "Click any key to paint  corners detected." << endl;
			_getch();
			closegraph();
			IMAGE img = srcImage;
			PaintCorner(CORNER_VECTOR, img);
			cout << endl;
			cout << "Click any key to close window." << endl;
			_getch();
			closegraph();
        }
		cout << endl;
		cout << "End detecting or not(Y/N): ";
		char end;
		cin >> end;
		if (end == 'Y') {
			exit(0);
		}
		cout << endl;
	}
	return 0;
}
lixuefeng2305
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Harris 角点检测c++源码实现
DU_YULIN的博客
06-12 1640
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习..
harris角点检测 C++
05-21
总结起来，哈里斯角点检测是通过分析图像局部像素灰度变化来检测图像的关键点，其C++实现涉及图像处理的基本操作和数学矩阵运算。在进行C++编程时，可以结合OpenCV等图像处理库来高效地完成角点检测任务。这种技术...
基于C++OpenCV实现的Harris角点特征检测
毕业作品网站
06-13 1380
读入摄像头，可以实时回放视频。键盘交互，空格键暂停，并对当前帧图像做一次 Harris Corner 检测，并将检测的结果叠加在原图上。C++ OpenCV 4.5.0开发平台：Visual Studio 2019 Debug x64摄像头读取利用 OpenCV 的 VideoCapture 类，初始化一个默认对象 capture(0) 即可调用系统摄像头。设置 delay 为 30ms，用 waitkey()函数来判断键盘交互。Harris Corner 算法在一个窗内计算期望 E(x,y)。对于期望大于
Harris角点检测
qq_41596730的博客
09-17 3101
Harris角点检测
opencv c++ Harris角点检测、shi-tomasi角点
lucust的博客
12-07 1582
应用：连续的图像移动或图像拼接场景中，确定图像中某一对象的位置。 在x方向和y方向都有最大梯度变化的像素点，衡量这个变化的计算式如下，为xx，xy，yx，yy四个方向的梯度sum值组成的2×2矩阵： a）在实际过程中，会在计算梯度时，乘以一个对应位置的权重 w(x, y)，u，v为沿着对应方向移动的距离。 b）在经过转换后得到新的E(u, v)式子： 其中： k = 0.04~0.6
Harris角点检测原理及C++实现
热门推荐
linqianbi的博客
12-29 2万+
1. 首先，我们不禁要问什么是harris角点？        对于角点，到目前为止还没有明确的数学定义。但是你可以认为角点就是极值点，即在某方面属性特别突出的点。一般的角点检测都是对有具体定义的、或者是能够具体检测出来的兴趣点的检测。这意味着兴趣点可以是角点，是在某些属性上强度最大或者最小的孤立点、线段的终点，或者是曲线上局部曲率最大的点。        通俗的来说，在一副图像中
OpenCV——Harris角点检测
点云侠的博客
10-10 1万+
OpenCV——harris角点检测算法的C++与python代码实现。
角点检测c语言,Harris角点检测原理及C++实现
weixin_36190719的博客
05-21 369
#include "my_harris.h"#define pi 3.14my_Harris::my_Harris(){}void my_Harris::RGB2GRAY(Mat rgb_img, Mat &gray_img){Mat img_src=rgb_img.clone();int rows =img_src.rows;int cols =img_src.cols;Mat img_...
c++视觉检测-----角点检测
qq_46107892的博客
10-12 603
c++视觉检测-----角点检测
Harris角点检测 及 Matlab实验
TechArtisan6的博客
04-25 1万+
目录 1 基础知识 1.1 图像变化的类型 1.2 提取点特征的作用 1.3 什么是好的角点检测算法？ 2Harris 角点检测 2.1 Harris角点检测基本思想 2.2 Harris角点检测：数学描述 3 总结 4 Matlab 实验 参考资料 角点是图像重要的特征，对图像图形的理解和分析有很重要的作用。角点在保留图像图重要特征的同时,可以有效地减少信息的数据量，...
harris角点检测 openCV
03-28
哈里斯角点检测是一种经典的图像特征检测方法，由Chris Harris和Mike Stephens于1988年提出。它在计算机视觉领域有着广泛的应用，如目标识别、图像拼接、3D重建等。在OpenCV库中，哈里斯角点检测被实现为一个便捷的...
【老生谈算法】Harris角点检测算法原理及其MATLAB编程实现.doc
07-02
【老生谈算法】Harris角点检测算法原理及其MATLAB编程实现.doc
harris角点检测和特征匹配
09-11
在压缩包中的"TestHarrisOperator"文件可能是一个包含示例代码的测试程序，用于演示如何使用C++和OpenCV实现Harris角点检测和特征匹配。分析并理解这段代码可以帮助你更好地掌握这些概念，并能够将其应用到自己的...
从零开始学习机器学习，掌握AI未来的关键！
qq_42538588的博客
07-25 1480
欢迎来到"人工智能-机器学习基础"！在本文中，我们将一起探索人工智能的奇妙世界。首先，让我们来介绍一下人工智能的概述。人工智能（Artificial Intelligence）是一门研究如何使机器具备智能能力的科学与技术。简单来说，它是能够像人类一样思考、学习和决策的机器。人工智能可以追溯到上个世纪50年代，当时科学家们就开始尝试模仿和理解人类的思维过程。然而，由于当时计算机技术的限制，人工智能的发展并不顺利。直到最近几年，随着计算能力的迅猛增长和大数据的普及，人工智能取得了巨大突破。
2024浙江省行政区划矢量图层-省市县乡镇四级行政区划数据下载-带python代码
最新发布
08-02
2024最新浙江省行政区划矢量图层数据，包含省、市、县、乡镇四级行政区划数据下载，附带shp转geojson的python代码
年度销售计划表.xlsx.xlsx
08-01
销售统计，调查问卷，库存明细，跟进表，业绩统计表，差异分析 ，产品清单 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
蓝牙BLE 4.0开发课程
08-01
蓝牙BLE 4.0课程
harris角点检测c++
03-25
Harris 角点检测是一种常用的计算机视觉算法，用于检测图像中的角点特征。在 C 语言中实现 Harris 角点检测的代码需要用到图像处理相关的库，如 OpenCV。具体实现详细过程可以参考相关的论文和文献。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值