QT+VS实现Kmeans++

news2024/11/19 1:53:51

1、Kmeans++的原理如下：

（1）首先选取样本中任一数据点作为第一个聚类中心；

（2）计算样本每一个数据点至现所有聚类中心的最近距离，并记录下来；

（3）逐一挑选所有数据点最近距离之中的最大值，即最远距离，最大值对应的数据点为待求聚类中心；

（4）剔除已选为聚类中心的样本点，重新计算（2）、（3）步骤，得到指定的最终的聚类中心点数。

2、实现结果如下：

 

 

3、原始数据读入格式如下：

点号-X坐标-Y坐标（非此格式的数据无法正常读入，程序会报错）

4、根据Kmeans++选择k个初始聚类中心的Kmeans聚类算法整体代码如下：

//Kmeans.cpp文件
#include "Kmeans.h"

Kmeans::Kmeans(QWidget *parent)
    : QWidget(parent)
{
    start = false;
    //dd = blank;
    dd = to2K;
    ui.setupUi(this);
    connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(onBtReadData()));
    connect(ui.pushButton_2, SIGNAL(clicked()), this, SLOT(onBtCalKmeans()));
    connect(ui.pushButton_3, SIGNAL(clicked()), this, SLOT(onBtReadK()));
}

void Kmeans::onBtReadData()
{
    K = ui.lineEdit->text().toInt();
    p.clear();

    //打开文件对话框
    QString fileName = QFileDialog::getOpenFileName(this, tr("打开"));
    QFile file(fileName);
    bool isOpen = 1;
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        isOpen = 0;
        QMessageBox::StandardButton btnValue = QMessageBox::information(this, tr("提示"), tr("打开失败！"));
    }

    //逐行读取文本文件
    QTextStream stream(&file);
    while (!stream.atEnd())
    {
        Pointp pt;
        QString str = stream.readLine();
        QStringList list = str.split(",");
        pt.no = list.at(0);
        pt.x = list.at(1).toDouble();
        pt.y = list.at(2).toDouble();
        p.push_back(pt);
    }

    file.close();

    //判断是否读取完毕
    if (stream.atEnd()&&isOpen)
    {
        QMessageBox box;
        box.setText("数据读取完毕");
        box.exec();
    }
}

void Kmeans::onBtReadK()
{
    QString fileName = QFileDialog::getOpenFileName(this, tr("打开"));
    QFile file(fileName);
    bool isOpen = 1;
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        isOpen = 0;
        QMessageBox::StandardButton btnValue = QMessageBox::information(this, tr("提示"), tr("打开失败！"));
    }
    QTextStream stream(&file);
    while (!stream.atEnd())
    {
        QString str = stream.readLine();
        QStringList list = str.split(",");
        Pointp k1;
        k1.no = list.at(0);
        k1.x = list.at(1).toDouble();
        k1.y = list.at(2).toDouble();
        k.push_back(k1);
    }

    //判断是否读取完毕
    if (stream.atEnd() && isOpen)
    {
        QMessageBox box;
        box.setText("数据读取完毕");
        box.exec();
    }
    dd = readK;
}

void Kmeans::toK()
{
    //随机选取k个初始聚类中心
    for (int i = 0; i < K; i++)
    {
        Pointp k1;
        k1.no = i + 1;
        k1.x = p.at(i).x;
        k1.y = p.at(i).y;
        k.push_back(k1);
    }
}

int Kmeans::onBtCalKmeans()
{
    K = ui.lineEdit->text().toInt();
    if (S.size()&&p.size()==S.size())
    {
        QMessageBox box;
        box.setText("已经计算完成");
        box.exec();
        return 0;
    }

    //if (dd == to2K)
    //{
    //    toK();
    //}

    CalK();

    CalDis();//S
    Calcentroid();//用到S,得dis
    //CKmeans();//用到dis，得new k.

    int iCount = 0;
    while (iCount < K)
    {
        if (dis.size())
        {
            for (int i = 0; i < k.size(); i++)
            {
                for (int j = 0; j < dis.size(); j++)
                {
                    if (k.at(i).no == dis.at(j).noK)
                    {
                        //qDebug() <<"k:" <<k.at(i).no<< k.at(i).x << k.at(i).y;
                        //qDebug() <<"dis:" <<dis.at(i).noK.toInt()<< dis.at(j).sx << dis.at(j).sy<<endl;
                        double detaX = k.at(i).x - dis.at(j).sx;
                        double detaY = k.at(i).y - dis.at(j).sy;
                        double sk = sqrt(detaX * detaX + detaY * detaY);
                        //qDebug() << sk;
                        if (sk == 0)
                        {
                            iCount++;
                        }
                        else
                        {
                            CKmeans();
                        }
                    }
                }
            }
        }

        dis.clear();
        S.clear();
        CalDis();
        Calcentroid();
    }

    start = true;
    qDebug() << "S" << S.size();
    drawPoint();
    //drawK();
    QMessageBox box;
    box.setText("计算完成");
    box.exec();
    qDebug() << "k" << k.size();
    //for (int i = 0; i < S.size(); i++)
    //{
    //    qDebug() << "S:" <<S.at(i).no<< S.at(i).noK;
    //}
    return 1;
}

Kmeans::~Kmeans()
{}

//计算质心
void Kmeans::Calcentroid()
{
    centroid s;
    for (int i = 0; i < k.size(); i++)
    {
        s.sx = 0; s.sy = 0; int iCt = 0;
        for (int j = 0; j < S.size(); j++)
        {
            if (k.at(i).no == S.at(j).noK)
            {
                s.sx = s.sx + S.at(j).x;
                s.sy = s.sy + S.at(j).y;
                iCt++;
            }
        }
        s.noK = k.at(i).no;
        s.sx = s.sx / iCt;
        s.sy = s.sy / iCt;
        dis.push_back(s);
    }
}

//计算每个对象至聚类中心的距离
void Kmeans::CalDis()
{
    for (int i = 0; i < p.size(); i++)
    {
        double s0 = 0; QString no; Dis ss; int t = 0;
        double x1 = p.at(i).x;
        double y1 = p.at(i).y;
        //double x = k.at(0).x;
        //double y = k.at(0).y;
        //s0 = sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y));
        for (int j = 0; j < k.size(); j++)
        {
            double x2 = k.at(j).x;
            double y2 = k.at(j).y;
            double s1 = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
            t++;
            if (t == 1)
            {
                s0 = s1;
                no = k.at(j).no;
            }
            if (s1 < s0)
            {
                s0 = s1;
                no = k.at(j).no;
            }
        }
        ss.s = s0;
        ss.no = p.at(i).no;
        ss.x = p.at(i).x;
        ss.y = p.at(i).y;
        ss.noK = no;
        S.push_back(ss);
    }


}

//将新的质心坐标赋值给k
void Kmeans::CKmeans()
{
    for (int i = 0; i < k.size(); i++)
    {
        for (int j = 0; j < dis.size(); j++)
        {
            if (k.at(i).no == dis.at(j).noK)
            {
                k.at(i).x = dis.at(j).sx;
                k.at(i).y = dis.at(j).sy;
            }
        }
    }
}

//绘图函数
void Kmeans::drawPoint()
{
    QPicture pp;
    pp.setBoundingRect(ui.label_2->rect());


    QPainter painterP(&pp);
    QPen pen;
    painterP.setRenderHint(QPainter::Antialiasing, true);

    Pointp p1;
    p1.no = p.at(0).no;
    p1.x = p.at(0).x;
    p1.y = p.at(0).y;
    for (int i = 1; i < p.size(); i++)
    {
        if (p1.x > p.at(i).x)
        {
            p1.x = p.at(i).x;
        }
        if (p1.y > p.at(i).y)
        {
            p1.y = p.at(i).y;
        }
    }
    double xmin = p1.x;
    double ymin = p1.y;

    for (int i = 1; i < p.size(); i++)
    {
        if (p1.x < p.at(i).x)
        {
            p1.x = p.at(i).x;
        }
        if (p1.y < p.at(i).y)
        {
            p1.y = p.at(i).y;
        }
    }
    double xmax = p1.x;
    double ymax = p1.y;

    int w=ui.label_2->width();
    int h=ui.label_2->height();

    double a = w/(xmax -xmin);
    double b1 = h/(ymax -ymin);

    for (int i = 0; i < k.size(); i++)
    {
        int r = qrand() % 256;
        int g = qrand() % 256;
        int b = qrand() % 256;
        QColor color = QColor(r, g, b);

        for (int j = 0; j < S.size(); j++)
        {
            if (k.at(i).no == S.at(j).noK)
            {
                pen.setColor(color);
                painterP.setPen(pen);
                int radius = 5;
                double x = S.at(j).x;
                double y = S.at(j).y;
                x = (x - xmin)*a;
                y = (y - ymin)*b1;
                painterP.drawEllipse(x - radius, y - radius, radius * 2, radius * 2);
            }
        }
    }

    ui.label_2->setPicture(pp);
}

void Kmeans::CalK()
{
    k.push_back(p.at(0));
    CalDistance();

    while (k.size() != K)
    {
        qDebug() << k.size() << k.at(k.size() - 1).no;
        S.clear();
        CalDistance();

        for (auto& val : k)
        {
            qDebug() << "CalK.k1" << val.no << val.x << val.y;
        }
        std::vector<Pointp> vk; int t3 = k.size();
        while (vk.size() != t3)
        {
            Pointp p9 = k.at(0); int t2 = 0;
            for (int i = 1; i < k.size(); i++)
            {
                Pointp p2 = k.at(i);
                if (p9.no.toInt() < k.at(i).no.toInt())
                {
                    p9 = k.at(i);
                    t2 = i;
                }
            }
            k.erase(k.begin() + t2);//删除下标为t2的元素;
            vk.push_back(p9);
        }

        for (int i = vk.size() - 1; i >= 0; i--)
        {
            k.push_back(vk.at(i));
        }

        for (auto& val : k)
        {
            qDebug() <<"CalK.k" << val.no << val.x << val.y;
        }


        int cv = 1;
        for (auto& val : k)
        {
            S.erase(S.begin() + (val.no.toInt() - cv));//删除下标为val.number的元素;
            cv++;
        }

        double s0 = 0;
        Pointp kk;
        kk = { 0,0,0 };
        for (auto& valS : S)
        {
            if (s0 <= valS.s)
            {
                s0 = valS.s;
                kk.no = valS.no;
                kk.x = valS.x;
                kk.y = valS.y;
            }
        }
        k.push_back(kk);
    }

    int count = 1;
    for (auto& val : k)
    {
        val.no = count;
        count++;
        //qDebug() << val.no << val.x << val.y;
    }
}

void Kmeans::drawK()
{
    QPicture pp;
    pp.setBoundingRect(ui.label_2->rect());


    QPainter painterP(&pp);
    QPen pen;
    painterP.setRenderHint(QPainter::Antialiasing, true);

    Pointp p1;
    p1.no = p.at(0).no;
    p1.x = p.at(0).x;
    p1.y = p.at(0).y;
    for (int i = 1; i < p.size(); i++)
    {
        if (p1.x > p.at(i).x)
        {
            p1.x = p.at(i).x;
        }
        if (p1.y > p.at(i).y)
        {
            p1.y = p.at(i).y;
        }
    }
    double xmin = p1.x;
    double ymin = p1.y;

    for (int i = 1; i < p.size(); i++)
    {
        if (p1.x < p.at(i).x)
        {
            p1.x = p.at(i).x;
        }
        if (p1.y < p.at(i).y)
        {
            p1.y = p.at(i).y;
        }
    }
    double xmax = p1.x;
    double ymax = p1.y;

    int w = ui.label_2->width();
    int h = ui.label_2->height();

    double a = w / (xmax - xmin);
    double b1 = h / (ymax - ymin);

    QColor color = QColor(123,223,46);

    for (int i = 0; i < k.size(); i++)
    {
        pen.setColor(color);
        pen.setWidth(3);
        painterP.setPen(pen);
        int radius = 10;
        double x = k.at(i).x;
        double y = k.at(i).y;
        x = (x - xmin) * a;
        y = (y - ymin) * b1;
        painterP.drawEllipse(x - radius, y - radius, radius * 2, radius * 2);
    }

    ui.label_2->setPicture(pp);
}

void Kmeans::CalDistance()
{
    Dis ss;
    for (auto& valP : p)
    {
        double s0 = 0; int c = 1;
        double x1 = valP.x;
        double y1 = valP.y;
        for (auto& valK : k)
        {
            double x2 = valK.x;
            double y2 = valK.y;

            x2 = x2 - x1;
            y2 = y2 - y1;

            double s = sqrt(x2 * x2 + y2 * y2);

            if (c == 1)
            {
                s0 = s;
                ss.no = valP.no;
                ss.noK = valK.no;
                ss.x = valP.x;
                ss.y = valP.y;
                ss.s = s;
                c++;
            }

            if (s0 == 0)
            {
                ss.no = valP.no;
                ss.noK = valK.no;
                ss.x = valP.x;
                ss.y = valP.y;
                ss.s = s;
                break;
            }

            if (s < s0)
            {
                s0 = s;
                ss.no = valP.no;
                ss.noK = valK.no;
                ss.x = valP.x;
                ss.y = valP.y;
                ss.s = s;
            }
        }
        S.push_back(ss);
    }
}


#pragma once

#include <QtWidgets/QWidget>
#include "ui_Kmeans.h"
#include<QFileDialog>
#include<QFile>
#include<QMessageBox>
#include<QTextStream>
#include<vector>
#pragma execution_character_set("UTF-8")
#include<qDebug>
#include<QPainter>
#include<QColor>
#include<QColorDialog>
#include<QPicture>
#include <algorithm>

struct Pointp
{
    double x;
    double y;
    QString no;
};

struct Dis
{
    double x;
    double y;
    QString no;
    QString noK;
    double s;
};

struct centroid
{
    QString noK;
    double sx;
    double sy;
};

enum Pd
{
    readK,
    to2K,
    blank
};

class Kmeans : public QWidget
{
    Q_OBJECT

public:
    Kmeans(QWidget *parent = nullptr);
    ~Kmeans();

public slots:
    void onBtReadData();
    int onBtCalKmeans();
    void onBtReadK();

public:
    std::vector<Pointp> p;//原始数据点
    std::vector<Pointp> k;//各簇质心坐标
    int K;
    std::vector<Dis> S;
    std::vector<centroid> dis;
    bool start;
    Pd dd;

public:
    void Calcentroid();
    void CKmeans();
    void CalDis();
    void drawPoint();
    void CalK();
    void drawK();
    void toK();
    void CalDistance();

private:
    Ui::KmeansClass ui;
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1417544.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

ATT汇编

ATT汇编

指令后缀 AT&T格式的汇编指令有不同的后缀 其中 b表示byte&#xff0c;字节 w表示word&#xff0c;字/两字节 l表示long&#xff0c;32位系统下的long是4字节 q表示quad&#xff0c;意味四重&#xff0c;表示4个字/8字节 寄存器用途 参见 AT&T的汇编世界 - Gemfield…
阅读更多...
备战蓝桥杯----数据结构及STL应用（基础2）

备战蓝桥杯----数据结构及STL应用（基础2）

上次我们讲了vector的大致内容&#xff0c;接下来让我们讲一下栈&#xff0c;队列吧&#xff01; 什么是栈呢&#xff1f; 很简单&#xff0c;我们用的羽毛球桶就是&#xff0c;我们取的球&#xff0c;是最后放的&#xff0c;栈是一种先进后出的数据结构。 方法函数 s.push(…
阅读更多...
Dubbo框架注册中心-Zookeeper搭建

Dubbo框架注册中心-Zookeeper搭建

Dubbo 是阿里巴巴公司开源的高性能、轻量级的Java RPC框架&#xff0c;致力于提供高性能。 Dubbo官网 本篇开始dubbo的第一篇&#xff0c;注册中心 ZooKeeper 环境搭建。 环境前置&#xff1a;由于Zookeeper是基于Java环境&#xff0c;必须安装有JDK。查看命令 java -version。…
阅读更多...
蓝桥杯---九数组分数

蓝桥杯---九数组分数

1,2,3 ... 9 这九个数字组成一个分数,其值恰好为1/3,如何组法? 下面的程序实现了该功能,请填写划线部分缺失的代码。 注意,只能填写缺少的部分,不要重复抄写已有代码。不要填写任何多余的文字。 代码 public class _05九数组分数 {public static void test(int[] x){int a …
阅读更多...
在WebSocket中使用Redis出现空指针异常解决方案

在WebSocket中使用Redis出现空指针异常解决方案

文章目录 在WebSocket中使用Redis1.问题描述2.原因3.解决步骤1.新建一个SpringUtil.java类&#xff0c;通过getBean的方法主动获取实例2.在WebSocketSingleServer.java中导入 在WebSocket中使用Redis 1.问题描述 在controller 和 service中都可以正常使用Redis&#xff0c;在…
阅读更多...
03_Opencv简单实例演示效果和基本介绍

03_Opencv简单实例演示效果和基本介绍

视频处理 视频分解图片 在后面我们要学习的机器学习中,我们需要大量的图片训练样本,这些图片训练样本如果我们全都使用相机拍照的方式去获取的话,工作量会非常巨大, 通常的做法是我们通过录制视频,然后提取视频中的每一帧即可! 接下来,我们就来学习如何从视频中获取信息 ubun…
阅读更多...
JVM工作原理与实战(三十)：堆内存状况的对比分析

JVM工作原理与实战(三十)：堆内存状况的对比分析

专栏导航 JVM工作原理与实战 RabbitMQ入门指南 从零开始了解大数据 目录 专栏导航 前言 一、堆内存状况的对比分析 1.正常情况 2.异常情况&#xff08;内存泄漏&#xff09; 二、产生内存溢出的原因 总结 前言 JVM作为Java程序的运行环境&#xff0c;其负责解释和执行字…
阅读更多...
【Linux 内核源码分析】多核调度分析

【Linux 内核源码分析】多核调度分析

多核调度 SMP&#xff08;Symmetric Multiprocessing&#xff0c;对称多处理&#xff09;是一种常见的多核处理器架构。它将多个处理器集成到一个计算机系统中&#xff0c;并通过共享系统总线和内存子系统来实现处理器之间的通信。 首先&#xff0c;SMP架构将一组处理器集中在…
阅读更多...
【Fooocus 深度学习】SDXL，AIGC生图，源码解读

【Fooocus 深度学习】SDXL，AIGC生图，源码解读

文章目录 使用通配符增加prompt多样性Fooocus的风格实现fooocus_expansionclip扩散采样参数 sigmasBrownianTreeNoiseSamplerPatchedjoint samplevae 使用通配符增加prompt多样性 prompt和negative_prompt都可以通过apply_wildcards函数来实现通配符替换&#xff0c;apply_wil…
阅读更多...
初识K8S（Kubernetes ）

初识K8S（Kubernetes ）

一、概述 Kubernetes 是一个可移植、可扩展的开源平台&#xff0c;用于管理容器化的工作负载和服务&#xff0c;可促进声明式配置和自动化。 Kubernetes 拥有一个庞大且快速增长的生态&#xff0c;其服务、支持和工具的使用范围相当广泛。&#xff08;官网&#xff09; Kuberne…
阅读更多...
Windows 7 x64 SP1 安装 Google Chrome 109.0.5414.120 (正式版本) （64 位）

Windows 7 x64 SP1 安装 Google Chrome 109.0.5414.120 (正式版本) （64 位）

1 使用 IE 浏览器 输入网址 Google Chrome 网络浏览器得益于 Google 智能工具&#xff0c;Chrome 现在更易用、更安全、更快速。https://www.google.cn/chrome/&#xff0c;点击下载 Chrome。 2 点击 接受并安装。 3 提示。 4 保存。 5 双击 运行 ChromeSetup.exe。 6 等待安…
阅读更多...
用于不对称卷积的验证参数的小程序

用于不对称卷积的验证参数的小程序

非对称卷积的特征图尺寸计算 此处只例举输入图像是正方形的情况。设输入图像尺寸为WxW&#xff0c;卷积核尺寸为ExF&#xff0c;步幅为S&#xff0c;Padding为P&#xff0c;卷积后的特征图尺寸为&#xff1a; 矩形卷积 如果输入图像是正方形&#xff0c;尺寸为WxW&#xff0c…
阅读更多...
WSL2 Debian系统添加支持SocketCAN

WSL2 Debian系统添加支持SocketCAN

本人最近在使用WSL2&#xff0c;Linux系统选择的是Debian&#xff0c;用起来很不错&#xff0c;感觉可以代替VMware Player虚拟机。 但是WSL2 Debian默认不支持SocketCAN&#xff0c;这就有点坑了&#xff0c;由于本人经常要使用SocketCAN功能&#xff0c;所以决定让Debian支持…
阅读更多...
switch语句详解及底层实现原理

switch语句详解及底层实现原理

目录 switch 与 if else switch语句用法 switch底层汇编实现分析 switch原理总结 switch 与 if else if else是人工优化的&#xff0c;而switch则是编译器进行优化的 使用场合&#xff1a;命中样本一致&#xff0c;每个case命中概率一样&#xff0c;case的数据必须是线性…
阅读更多...
内网安全：RDP WinRS WinRM SPN Kerberos 横向移动

内网安全：RDP WinRS WinRM SPN Kerberos 横向移动

目录 WinRM协议 RDP协议 域横向移动&#xff1a;RDP协议 RDP协议利用 一. 探针服务 二. 获取NTML Hash 明文密码 三. 连接执行 域横向移动&#xff1a;WinRM WinRS WinRM协议、WinRS命令利用 一. cs 内置端口扫描5985 二. 连接执行 三. 上线CS 四. CS插件横向移动…
阅读更多...
日常学习之：vue + django + docker + heroku 对后端项目 / 前后端整体项目进行部署

日常学习之：vue + django + docker + heroku 对后端项目 / 前后端整体项目进行部署

文章目录 使用 docker 在 heroku 上单独部署 vue 前端使用 docker 在 heroku 上单独部署 django 后端创建 heroku 项目构建 Dockerfile设置 settings.pydatabase静态文件管理安全设置applicaiton & 中间件配置 设置 requirements.txtheroku container 部署应用 前后端分别部…
阅读更多...
解读BEVFormer，新一代自动驾驶视觉工作的基石

解读BEVFormer，新一代自动驾驶视觉工作的基石

文章出处 BEVFormer这篇文章很有划时代的意义&#xff0c;改变了许多视觉领域工作的pipeline[2203.17270] BEVFormer: Learning Birds-Eye-View Representation from Multi-Camera Images via Spatiotemporal Transformers (arxiv.org)https://arxiv.org/abs/2203.17270 BEV …
阅读更多...
深入理解C语言(3)：自定义类型详解

深入理解C语言(3)：自定义类型详解

文章主题&#xff1a;结构体类型详解&#x1f30f;所属专栏&#xff1a;深入理解C语言&#x1f4d4;作者简介&#xff1a;更新有关深入理解C语言知识的博主一枚&#xff0c;记录分享自己对C语言的深入解读。&#x1f606;个人主页&#xff1a;[₽]的个人主页&#x1f3c4;&…
阅读更多...
使用毫米波雷达传感器的功能安全兼容系统设计指南1（TI文档）

使用毫米波雷达传感器的功能安全兼容系统设计指南1（TI文档）

摘要 功能安全标准规定了在系统中实施安全的要求&#xff0c;并有助于概括该系统要达到的安全目标。包括功能安全的系统设计不仅要降低操作不当的风险&#xff0c;还要检测故障并将其影响降到最低。随着汽车和工业系统的自主性越来越强&#xff0c;严格的功能安全要求被强制执行…
阅读更多...
docker中安装seata，以nacos为配置中心

docker中安装seata，以nacos为配置中心

docker中安装seata&#xff0c;以nacos为配置中心 一、环境二、拉取seata镜像1、查看seata有哪些镜像2、查看原来有没有seata镜像3、拉取最新版本4、拉取指定版本 三、配置seata1、创建seata相关的数据库2、创建seata配置文件目录3、启动seata容器4、复制seata容器下的配置文件…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023