K-means 代碼

最新推荐文章于 2024-08-14 15:21:07 发布
最新推荐文章于 2024-08-14 15:21:07 发布
阅读量229 收藏
点赞数
文章标签： opencv 计算机视觉 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kelvin_HuangJin/article/details/108951931
版权

K-means 代碼。
將圖檔轉成黑白之後，分群。
K_GROUP = 設置的群組數量


#include<opencv2/opencv.hpp>
#include<iostream>
#include <cstdlib> /* 亂數相關函數 */
#include <ctime>   /* 時間相關函數 */
#include <math.h>
#include <stdio.h>
#include <stdlib.h>

using  namespace cv;
using namespace std;
#define K_GROUP 10
Mat srcImage, grayImage;
long long k_cnt = 0;
int max_x, min_x;
void K_Manes(Point *kp, int k_group);

int main()
{
	long timeStart, timeEnd; 
	timeStart = clock();
	char k_first_Flag = 0;
	Point K_center[K_GROUP];
	//unsigned long long k_min_data, k_max_data;
	//unsigned long long k_center[K_GROUP] = {0,0,0};

	srcImage = imread("D:\\download\\2.Result.bmp");
	//grayImage = imread("C:\\Users\\User\\Downloads\\Image2\\3.Left.bmp");
	cvtColor(srcImage, grayImage, CV_RGB2GRAY);


	//for (int x = 0; x < grayImage.rows; x++)
	//{
	//	for (int y = 0; y < grayImage.cols; y++)
	//	{
	//		if (grayImage.ptr<uchar>(x)[y] >= 180)
	//			grayImage.ptr<uchar>(x)[y] = 0;
	//		else if (grayImage.ptr<uchar>(x)[y] <= 20)
	//			grayImage.ptr<uchar>(x)[y] = 0;
	//	}
	//}

	//get point range
	for (int x = 0; x < grayImage.rows; x++)
	{
		for (int y = 0; y < grayImage.cols; y++)
		{
			if (grayImage.ptr<uchar>(x)[y] != 0)
						{
				if (k_first_Flag == 0)
				{
					k_first_Flag = 1;
					min_x = x;
				}
				max_x = x;
				k_cnt++;//get total point
			}
			//else if (grayImage.at<Vec3b>(x, y)[0] == 0 && grayImage.at<Vec3b>(x, y)[1] == 0 && grayImage.at<Vec3b>(x, y)[2] == 0)
			//{
				//grayImage.ptr<uchar>(x)[y] = 255;
			//	grayImage.at<Vec3b>(x, y)[0] = 255;//b
			//	grayImage.at<Vec3b>(x, y)[1] = 255;//g
			//	grayImage.at<Vec3b>(x, y)[2] = 255;//r
			//}
		}
	}

	//printf("min_x=%d\n", min_x);
	//printf("max_x=%d\n", max_x);

	//printf("k_min_data=%ld\n", k_min_data);
	//printf("k_max_data=%ld\n", k_max_data);

	//get rand point
	int lx, ly;
	srand(time(NULL));
	for (int i = 0; i < K_GROUP; i++)
	{
		lx = rand() % (max_x - min_x + 1) + min_x;
		//printf("lx=%d\n", lx);
		ly = (rand() % grayImage.cols) + 1;
		K_center[i].x = lx;
		K_center[i].y = ly;
		//printf("ly=%d\n", ly);
		//k_center[i] = lx*grayImage.rows + ly;
		//printf("k_center[%d]=%ld\n", i, k_center[i]);
	}


	//k_manes calculate
	K_Manes(K_center, K_GROUP);

	imshow("show",grayImage);

	timeEnd = clock();
	double times;
	times = (double)(timeEnd - timeStart) / 1000;
	printf("times=%f\n", times);
	waitKey();
	return 0;

}

void K_Manes(Point *kp, int k_group)
{
	Point p2;
	int d[K_GROUP];

	Point **data;
	unsigned long **dataD;
	unsigned long *loc_cnt;
	long loc_g = 0;
	//char rand_flag[K_GROUP];
	int lx, ly;
	int t = 100, stop_cnt = 0;
	Point last_p[K_GROUP];

	data = new Point*[K_GROUP]; 
	dataD = new unsigned long*[K_GROUP];
	loc_cnt = new unsigned long[K_GROUP];
	srand(time(NULL));

	for (int i = 0; i < K_GROUP; i++){
		data[i] = new Point[k_cnt];
		dataD[i] = new unsigned long[k_cnt];
		//rand_flag[i] = 0;
		last_p[i].x = 0;
		last_p[i].y = 0;
	}	

	for (int i = 0; i < K_GROUP; i++)
	{
		for (int j = 0; j < k_cnt; j++){
			data[i][j].x = 0;
			data[i][j].y = 0;
			dataD[i][j] = 0;
		}
	}

	//show point
	Mat show = Mat::zeros(grayImage.rows, grayImage.cols, grayImage.type());
	for (int x = 0; x < grayImage.rows; x++)
	{
		for (int y = 0; y < grayImage.cols; y++)
		{
			for (int i = 0; i < K_GROUP; i++)
				if (x == kp[i].x && y == kp[i].y){
					show.ptr<uchar>(x)[y] = 255;
					for (int j = 0; j < 10; j++){
						if (x - j > 0 && x + j < grayImage.rows && y + j < grayImage.cols && y - j>0){
							show.ptr<uchar>(x - j)[y] = 255;
							show.ptr<uchar>(x + j)[y] = 255;
							show.ptr<uchar>(x)[y - j] = 255;
							show.ptr<uchar>(x)[y + j] = 255;
						}
					}

				}

		}

	}
	//imshow("show point", show);
	
	while (t--)
	{
		//no any point and rand kp again
		//for (int i = 0; i < K_GROUP; i++)
		//{
		//	if (rand_flag[i])
		//	{
		//		lx = rand() % (max_x - min_x + 1) + min_x;
		//		//printf("lx=%d\n", lx);
		//		ly = (rand() % grayImage.cols) + 1;
		//		//printf("ly=%d\n", ly);
		//		kp[i].x = lx;
		//		kp[i].y = ly;
		//		rand_flag[i] = 0;
		//	}

		//}

		//clear loc_cnt
		for (int i = 0; i < K_GROUP; i++)
		{
			loc_cnt[i] = 0;
			for (int j = 0; j < k_cnt; j++)
			{
				data[i][j].x = 0;
				data[i][j].y = 0;
				dataD[i][j] = 0;
			}
		}

		int samll_d= 0;
		//find group
		for (int x = 0; x < grayImage.rows; x++)
		{
			for (int y = 0; y < grayImage.cols; y++)
			{
				if (grayImage.ptr<uchar>(x)[y] != 0)
				{
					p2.x = x;
					p2.y = y;
					//find distance
					loc_g = 0;
					samll_d = d[0];
					for (int i = 0; i < K_GROUP; i++)
					{
							
						d[i] = sqrt(pow(p2.x - kp[i].x, 2) + pow(p2.y - kp[i].y, 2));
						if (samll_d > d[i]){
							loc_g = i;
							samll_d = d[i];
							
						}

						//printf("d[%d]=%d  min value =%d  loc_g=%d \n", i, d[i], d[loc_g], loc_g);
					}

					//save data
					data[loc_g][loc_cnt[loc_g]].x = p2.x;
					data[loc_g][loc_cnt[loc_g]].y = p2.y;
					dataD[loc_g][loc_cnt[loc_g]] = samll_d;
					//printf("dataD[%d][%d] = %ld  ", loc_g, loc_cnt[loc_g], dataD[loc_g][loc_cnt[loc_g]]);

					loc_cnt[loc_g]++;
					data[loc_g][loc_cnt[loc_g]].x = 0;
					data[loc_g][loc_cnt[loc_g]].y = 0;
					dataD[loc_g][loc_cnt[loc_g]] = 0;
					//printf("loc_cnt[%d]=%d\n",loc_g ,loc_cnt[loc_g]);


				}

			}
		}



		//count max point
		int s = loc_cnt[0];
		int sl = 0;
		for (int i = 0; i < K_GROUP; i++){
			if (s < loc_cnt[i]){
				s = loc_cnt[i];
				sl = i;
				//printf("sl=%d\n", sl);
			}
		}

		//draw center point
		char p = 5;
		Mat show2 = Mat::zeros(show.rows, show.cols, show.type());
		for (int x = 0; x < show.rows; x++)
		{
			for (int y = 0; y < show.cols; y++)
			{
				for (int i = 0; i < K_GROUP; i++)
				{
					if (x == kp[i].x && y == kp[i].y){
						if (loc_cnt[i] > 1500){//0
							show2.ptr<uchar>(x)[y] = 255;
							i == sl ? p = 10 : p = 5;
							for (int j = 0; j < p; j++){
								if (x - j > 0 && x + j < grayImage.rows && y + j < grayImage.cols && y - j>0){
									show2.ptr<uchar>(x - j)[y] = 255;
									show2.ptr<uchar>(x + j)[y] = 255;
									show2.ptr<uchar>(x)[y - j] = 255;
									show2.ptr<uchar>(x)[y + j] = 255;
								}
							}
						}
						//printf("i=%d\n",i);
					}
				}

			}
		}


		//return loop 
		Mat show3 = Mat::zeros(show2.rows, show2.cols, show2.type());
		for (int i = 0; i < K_GROUP; i++)
		{
			if (stop_cnt > 3 || t == 0)
			{
				printf("t=%d\n", 100 - t);
				//for (int x = 0; x < K_GROUP; x++)
				//{
				//	for (int j = 0; j < loc_cnt[x]; j++)
				//	{
				//		//if (dataD[x][j] != 0)
				//		if (data[x][j].x != 0 && data[x][j].y != 0)
				//		{
				//			line(show3, Point(kp[x].y, kp[x].x), Point(data[x][j].y, data[x][j].x), Scalar(255, 255, 255));
				//		}

				//	}
				//}

				//for (int x = 0; x < grayImage.rows; x++)
				//{
				//	for (int y = 0; y < grayImage.cols; y++)
				//	{
				//		if (grayImage.ptr<uchar>(x)[y] != 0)
				//		{
				//			show2.ptr<uchar>(x)[y] = 255;
				//		}
				//	}
				//}

				for (int x = 0; x < K_GROUP; x++){
					//printf("loc_cnt[%d]=%ld\n", x, loc_cnt[x]);
					//printf("kp[%d].x=%d  kp[%d].y=%d \n", x, kp[x].x, x, kp[x].y);
				}
				imshow("show2 point", show2);
				//imshow("show3 point", show3);
				return;
			}

			if (last_p[i].x == kp[i].x && last_p[i].y == kp[i].y && loc_cnt[i]>0)
				stop_cnt++;
			else if (sqrt(pow(last_p[i].x - kp[i].x, 2) + pow(last_p[i].y - kp[i].y, 2))<5)
				stop_cnt++;

		}

		//calcuate K-group center again
		Point max_loc[K_GROUP], min_loc[K_GROUP];
		unsigned long long max_p, min_p;
		unsigned long long  new_point_X[K_GROUP];
		unsigned long long  new_point_Y[K_GROUP];
		for (int i = 0; i < K_GROUP; i++)
		{
			new_point_X[i] = 0;
			new_point_Y[i] = 0;
			max_p = dataD[i][0];
			min_p = dataD[i][0];
			max_loc[i].x = data[i][0].x;
			min_loc[i].y = data[i][0].y;

			for (int j = 0; j < loc_cnt[i]; j++)
			{
				if (data[i][j].x != 0 && data[i][j].y != 0)
				{

					if (loc_cnt[i] > 0){
						//get max & min point
						//if (min_p>dataD[i][j])
						//{
						//	min_p = dataD[i][j];
						//	min_loc[i].x = data[i][j].x;
						//	min_loc[i].y = data[i][j].y;
						//}

						//if (max_p < dataD[i][j])
						//{
						//	max_p = dataD[i][j];
						//	max_loc[i].x = data[i][j].x;
						//	max_loc[i].y = data[i][j].y;
						//}

						///average point
						new_point_X[i] += data[i][j].x;
						new_point_Y[i] += data[i][j].y;
					}
				}
			}

			//printf("new_point_X[%d]=%ld\n", i, new_point_X[i]);
			//printf("new_point_Y[%d]=%ld\n", i, new_point_Y[i]);

		}
		//update group center
		for (int i = 0; i < K_GROUP; i++)
		{
			if (loc_cnt[i] > 0){
				//max point & min point average
				//new_point_X[i] = (min_loc[i].x + max_loc[i].x) / 2;
				//new_point_Y[i] = (min_loc[i].y + max_loc[i].y) / 2;

				//average point
				new_point_X[i] /= loc_cnt[i];
				new_point_Y[i] /= loc_cnt[i];

				last_p[i].x = kp[i].x;
				last_p[i].y = kp[i].y;

				kp[i].x = new_point_X[i];
				kp[i].y = new_point_Y[i];
				//printf("kp[%d].x=%d  kp[%d].y=%d \n", i, kp[i].x, i, kp[i].y);
			}
			//else{
			//	rand_flag[i] = 1;
			//	//printf("2 kp[%d].x=%d  kp[%d].y=%d \n", i, kp[i].x, i, kp[i].y);
			//}


			//printf("loc_cnt[%d]=%ld\n", i, loc_cnt[i]);
			//printf("new_point_X[%d]=%ld\n", i, new_point_X[i]);
			//printf("new_point_Y[%d]=%ld\n", i, new_point_Y[i]);
		}

	}
}
Kelvin_HuangJin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
K-means聚类算法原理及python实现
Flaneur-yz的博客
07-26 24万+
文章目录一.聚类算法二.K-means聚类算法三.K-means算法步骤详解Step1.K值的选择Step2.距离度量2.1.欧式距离2.2.曼哈顿距离2.3.余弦相似度Step3.新质心的计算Step4.是否停止K-means四.K-means算法代码实现1.其伪代码如下2.python实现五.K-means算法补充六.小结 一.聚类算法     &nbs...
K-Means 代码实现
dfly_zx的博客
02-25 1362
我们自己产生模拟数据，看一下k-means运行情况，主要目的是熟悉一下API接口。基于scikit包中的创建模拟数据的API创建聚类数据，使用K-means算法对数据进行分类操作，并获得聚类中心点以及总的样本簇中心点距离和值。 接口介绍 1）make_blobs 这是产生数据的API接口 （产生团状的，或者说是服从高斯分布的数据） 参数 n_samples : int or array-like, optional (default=100)，样本数 n_features : int, opt..
K-Means++代码实现
树下一朵云的博客
12-06 1372
数据集 https://download.csdn.net/download/qq_43629083/87246495
【机器学习-14】K-means聚类算法：原理、应用与优化
热门推荐
qq_38614074的博客
04-07 4万+
在众多聚类算法中，K-means算法因其简单高效而备受青睐。K-means算法的基本思想是：通过迭代的方式，将数据划分为K个不同的簇，并使得每个数据点与其所属簇的质心（或称为中心点、均值点）之间的距离之和最小。具体来说，K-means算法的执行过程通常包括以下几个步骤：首先，随机选择K个数据点作为初始的簇质心；然后，根据每个数据点与各个簇质心的距离，将其分配给最近的簇；接着，重新计算每个簇的质心，即取簇内所有数据点的平均值作为新的质心；
K-means聚类算法代码
m0_51441869的博客
05-02 4672
k-means算法代码实现
K-Means代码
03-22
以下是一个简单的自定义K-Means算法的MATLAB代码示例： ```matlab function [clusters, centroids] = kmeans_custom(X, K, maxIter) % 初始化聚类中心 centroids = X(randperm(size(X,1), K), :); for iter = ...
k_means_K-means算法代码_
09-29
`K-means算法代码.txt`文件可能是对算法的解释或代码注释，有助于理解算法的工作原理。 ### 应用场景 K-means在多个领域都有应用，如市场细分、图像分割、文档分类等。它的优点在于简单高效，适用于大数据集。但也...
k-means实现
10-16
k-means算法是一种广泛应用的无监督机器学习方法，主要用于数据聚类。它的核心目标是将数据集中的样本点分配到K个不同的簇中，使得每个簇...提供的压缩包文件可能包含了k-means算法的实现代码，可供学习者参考和研究。
聚类 k-means k-medoids代码实现
01-06
"k-means" 和 "k-medoids" 是两种常见的无监督学习算法，用于将数据集分割成多个互不重叠的类别，其中每个类别由其内部成员的相似性定义。这两种方法在处理大数据集时尤其有用，因为它们可以有效地对大量观测值进行...
K-means实现广告聚类分析.zip
11-19
项目包含广告渠道90天内额日均UV，平均注册率、平均搜索率、访问深度、平均停留时长、订单转化率、投放时间、素材类型、广告类型、合作方式、广告尺寸和广告卖点等特征，将渠道分类，找出...项目包含原始数据集和源代码
Python OpenCV 影像处理：边缘检测
wpgddt的博客
08-08 1082
上篇介绍使用OpenCV Python findContours() 函数用于在二值化影像中寻找连通的白色区域，并返回一系列点的集合来表示找到的轮廓。本篇将介绍基于计算影像的梯度，通过在影像中找到梯度值的变化来识别边缘，边缘检测通常用于预处理步骤，以帮助后续的物体侦测、分割或其他影像处理任务。透过程式码的说明，让各位了解OpenCV Python于图像处理上的基本操作。
三、OpenCVSharp 中图像的基本属性和操作
仰望星空的博客
08-09 264
在图像处理中，了解和操作图像的基本属性是至关重要的。OpenCVSharp 提供了丰富的功能来实现这些操作，让我们能够更灵活地处理图像。
图像识别，图片线条检测
最新发布
u012121721的博客
08-14 455
opencv、图像线条检测
【OpenCV C++20 学习笔记】直方图计算-split, calcHist, normalize
TeamLee的博客
08-09 972
简要介绍OpenCV中使用calcHist进行直方图计算的方法和原理，并绘制计算结果
二、OpenCVSharp 中的图像读取、显示与保存
仰望星空的博客
08-09 107
在图像处理中，图像的读取、显示和保存是基础且关键的操作。OpenCVSharp 为这些操作提供了丰富而便捷的功能。可以通过 NamedWindow 方法来创建自定义的窗口，并设置其属性。// 创建自适应大小的窗口// 设置窗口位置。
嵌入式人工智能（OpenCV-图像的基本操作）
u010152658的博客
08-08 1286
计算机视觉包括底层的图像处理、中层的图像分析以及高层的视觉技术，OpenCV已经延伸到计算机视觉的每个领域，其功能涵盖每个研究方向。应用领域包括人机互动、物体识别、图像分割、人脸识别、动作识别、运动跟踪、机器人、运动分析、机器视觉、结构分析、汽车安全驾驶。
opencv 深度图视差图可视化案例
weixin_42357472的博客
08-11 265
深度视差图 参考：https://www.cnblogs.com/zyly/p/9373991.html（图片这里面下载的）
240808opencv中反向投影
qq_37269626的博客
08-08 70
OpenCV 提供的函数 cv2.calcBackProject() 可以用来做直方图反向。将我们对图像感兴趣部分归一化后对照原图像直方图进行投影，生成概率图像，最后阈值化处理。它的参数与函数 cv2.calcHist 的参数基本相同。们要查找目标的直方图。同样再使用目标的直方图做反向投影之前我们应该先。返回的结果是一个概率图像，我们再使用一个圆盘形卷积。核对其做卷操作，最后使用阈值进行二值化。
OpenCV图像滤波(9)getGaussianKernel()函数的使用
jndingxin的专栏
08-09 986
cv::getGaussianKernel() 是 OpenCV 中的一个函数，用于生成一维高斯核。这种核通常用于实现高斯模糊滤波器
k-means 代码
05-28
以下是 Python 中实现 k-means 算法的代码： ```python import numpy as np from sklearn.cluster import KMeans # 生成数据 data = np.random.rand(100, 2) # 创建 k-means 模型 kmeans = KMeans(n_clusters=3) # 训练模型 kmeans.fit(data) # 输出聚类结果 labels = kmeans.labels_ # 每个数据点对应的簇标签 centers = kmeans.cluster_centers_ # 每个簇的中心点 print(labels) print(centers) ``` 以上代码中，我们首先生成了一个 100 行 2 列的随机数据集，然后使用 `KMeans` 类创建了一个 k-means 模型。在训练模型之后，我们可以通过 `labels_` 属性获得每个数据点对应的簇标签，通过 `cluster_centers_` 属性获得每个簇的中心点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值