import matplotlib.pyplot as plt

from sklearn import datasets

from sklearn.cluster import DBSCAN

from sklearn.cluster import KMeans

import numpy as np

import pandas as pd

from sklearn.metrics import silhouette_score

from sklearn.metrics import calinski_harabasz_score

from sklearn.metrics import adjusted_rand_score

def print_data(want_print, print_iris):

    """

    展示iris的数据

    :return: None

    """

    print("iris{0}为:\n{1}".format(want_print, print_iris))

    print("=" * 85)

def blob():

    color_list = ['#4daf4a', '#984ea3', '#dede00']

    # blobs = datasets.make_moons(n_samples=200, noise=0.05,  random_state=42)

    blobs = np.loadtxt(r'C:\Users\86158\Desktop\blobs.txt')

    # 打印整个blob数据

    print("Blob的数据如下所示：")

    for row in blobs:

        print(row)

    X = blobs[:,:2]

    y = blobs[:,-1].astype(int)

    color_y = [color_list[y[i]] for i in range(len(X))]

    # 调用Scikit-learn函数库中的DBSCAN模块进行聚类

    dbscan = DBSCAN(eps=0.3, min_samples=10)

    # 使用Blobs.txt数据（也可以使用上次的文本和图片数据）

    dbscan_labels = dbscan.fit_predict(X)

    # 绘出聚类前后的图

    plt.figure(figsize=(12, 5))

    """before clustering"""

    plt.subplot(1, 2, 1)

    plt.scatter(X[:, 0], X[:, 1], c=color_y, marker='o', edgecolor='k', s=40, label='True Labels')

    plt.title('True Labels')

    plt.legend()

    """after clustering"""

    plt.subplot(1, 2, 2)

    plt.scatter(X[:, 0], X[:, 1], c=dbscan_labels, marker='o', edgecolor='k', s=40, cmap=plt.cm.Paired)

    plt.title('DBSCAN Clustering')

    plt.show()

    """

    相同的数据集，与K-means进行比较

    即比较两个聚类方法在非球形聚集的数据集上的表现

    """

    # 调用Scikit-learn函数库中的kmeans模块进行聚类

    kmeans = KMeans(n_clusters=2)

    # 使用Blobs.txt数据（也可以使用上次的文本和图片数据）

    kmeans.fit(X)

    kmeans_labels = kmeans.labels_

    # 绘出聚类前后的图

    plt.figure(figsize=(12, 5))

    """before clustering"""

    plt.subplot(1, 2, 1)

    plt.scatter(X[:, 0], X[:, 1], c=color_y, marker='o', edgecolor='k', s=40, label='True Labels')

    plt.title('True Labels')

    plt.legend()

    """after clustering"""

    plt.subplot(1, 2, 2)

    plt.scatter(X[:, 0], X[:, 1], c=kmeans_labels, marker='o', edgecolor='k', s=40, cmap=plt.cm.Paired)

    plt.title('KMeans Clustering')

    plt.show()

    """

    对二者的metrics进行对比

        1：轮廓系数

            度量了样本与其所分配的簇之间的相似性和不相似性。

            对于每个样本，它计算了与同一簇中其他样本的相似性与与最接近的其他簇中的样本的不相似性之间的差异。

            轮廓系数的取值范围在[-1, 1]之间，值越接近1表示聚类效果越好。

        2：Calinski-Harabasz指数（方差比准则）

            度量了簇内的差异性与簇间的相似性之间的比率。

            较高的指数值表示聚类效果较好。

        3：ARI（Adjusted Rand Index）

            考虑了聚类结果与真实标签之间的一致性。

    """

    print()

    # 对KMeans和DBSCAN的聚类结果计算轮廓系数

    silhouette_kmeans = silhouette_score(X, kmeans_labels)

    silhouette_dbscan = silhouette_score(X, dbscan_labels)

    print("轮廓系数比较（Silhouette Score）")

    print("KMeans:", silhouette_kmeans)

    print("DBSCAN:", silhouette_dbscan)

    print()

    # 对KMeans和DBSCAN的聚类结果计算Calinski-Harabasz指数

    calinski_kmeans = calinski_harabasz_score(X, kmeans_labels)

    calinski_dbscan = calinski_harabasz_score(X, dbscan_labels)

    print("Calinski-Harabasz指数比较（Calinski-Harabasz Index）")

    print("KMeans:", calinski_kmeans)

    print("DBSCAN:", calinski_dbscan)

    print()

    # 计算KMeans和DBSCAN的ARI

    ari_kmeans = adjusted_rand_score(y, kmeans_labels)

    ari_dbscan = adjusted_rand_score(y, dbscan_labels)

    print("ARI指数比较（Adjusted Rand Index）")

    print("KMeans:", ari_kmeans)

    print("DBSCAN:", ari_dbscan)

    print()

def iris():

    # 导入iris数据

    iris = datasets.load_iris()

    # 展示iris真实数据

    print_data(want_print="数据", print_iris=iris.data)

    # 展示iris特征名字

    print_data(want_print="特征名字", print_iris=iris.feature_names)

    # 展示目标值

    print_data(want_print="目标值", print_iris=iris.target)

    # 展示目标值的名字

    print_data(want_print="目标值的名字", print_iris=iris.target_names)

    # 为了便于使用，将iris数据转换为pandas库数据结构，并设立列的名字

    # 将iris数据转为pandas数据结构

    x = pd.DataFrame(iris.data)

    # 将iris数据的名字设为‘Sepal_Length’，‘Sepal_Width’，‘Sepal_Width’，‘Petal_Width’

    x.columns = ['Sepal_Length', 'Sepal_Width', 'Petal_Length', 'Petal_Width']

    # 将iris目标值也转为pandas数据结构

    y = pd.DataFrame(iris.target)

    # 将iris目标值得名字设为‘Targets’

    y.columns = ['Targets']

    # dbscan for iris

    # 创建一个DBSCAN模型并进行花萼聚类

    dbscan_sepal = DBSCAN(eps=0.5, min_samples=3)

    dbscan_sepal.fit(x[['Sepal_Length', 'Sepal_Width']])

    x['Sepal_DBSCAN_Cluster'] = dbscan_sepal.labels_

    # 创建一个DBSCAN模型并进行花瓣聚类

    dbscan_petal = DBSCAN(eps=0.5, min_samples=3)

    dbscan_petal.fit(x[['Petal_Length', 'Petal_Width']])

    x['Petal_DBSCAN_Cluster'] = dbscan_petal.labels_

    # 绘制DBSCAN花萼聚类结果

    plt.figure(figsize=(16, 7))

    plt.subplot(2, 2, 1)

    plt.scatter(x['Sepal_Length'], x['Sepal_Width'], c=colormap[y['Targets']], s=40, label='Original Data')

    plt.title('Original Sepal Data')

    plt.subplot(2, 2, 2)

    for cluster in np.unique(x['Sepal_DBSCAN_Cluster']):

        if cluster == -1:  # -1 表示噪声点

            cluster_data = x[x['Sepal_DBSCAN_Cluster'] == cluster]

            plt.scatter(cluster_data['Sepal_Length'], cluster_data['Sepal_Width'], c='gray', s=40, label='Noise')

        else:

            cluster_data = x[x['Sepal_DBSCAN_Cluster'] == cluster]

            plt.scatter(cluster_data['Sepal_Length'], cluster_data['Sepal_Width'], c=colormap[cluster], s=40, label=f'Cluster { cluster}')

    plt.title('Sepal DBSCAN Clustering Overlay')

    plt.legend()

    # 绘制DBSCAN花瓣聚类结果

    plt.subplot(2, 2, 3)

    plt.scatter(x['Petal_Length'], x['Petal_Width'], c=colormap[y['Targets']], s=40, label='Original Data')

    plt.title('Original Petal Data')

    plt.subplot(2, 2, 4)

    for cluster in np.unique(x['Petal_DBSCAN_Cluster']):

        if cluster == -1:  # -1 表示噪声点

            cluster_data = x[x['Petal_DBSCAN_Cluster'] == cluster]

            plt.scatter(cluster_data['Petal_Length'], cluster_data['Petal_Width'], c='gray', s=40, label='Noise')

        else:

            cluster_data = x[x['Petal_DBSCAN_Cluster'] == cluster]

            plt.scatter(cluster_data['Petal_Length'], cluster_data['Petal_Width'], c=colormap[cluster], s=40, label=f'Cluster { cluster}')

    plt.title('Petal DBSCAN Clustering Overlay')

    plt.legend()

    plt.tight_layout()

    plt.show()

    # 计算轮廓系数

    print()

    print("Iris数据集采用DBSCAN算法聚类的轮廓系数：")

    # 计算花萼聚类的轮廓系数

    silhouette_sepal_dbscan = silhouette_score(x[['Sepal_Length', 'Sepal_Width']], x['Sepal_DBSCAN_Cluster'])

    print("Sepal:", silhouette_sepal_dbscan)

    # 计算花瓣聚类的轮廓系数

    silhouette_petal_dbscan = silhouette_score(x[['Petal_Length', 'Petal_Width']], x['Petal_DBSCAN_Cluster'])

    print("Petal:", silhouette_petal_dbscan)

    # 计算调整兰德系数

    print()

    print("Iris数据集采用DBSCAN算法聚类的ARI：")

    # 计算花萼聚类的ARI

    ari_sepal_dbscan = adjusted_rand_score(iris.target, x['Sepal_DBSCAN_Cluster'])

    print("Sepal:", ari_sepal_dbscan)

    # 计算花瓣聚类的ARI

    ari_petal_dbscan = adjusted_rand_score(iris.target, x['Petal_DBSCAN_Cluster'])

    print("Petal:", ari_petal_dbscan)

    print()

def menu():

    while 1:

        print("请根据提示输入这次实验时所调入的数据")

        print("输入1：可调用blob数据")

        print("输入2：可调用iris数据")

        print("输入3：退出DBSCAN实验")

        number = input("请输入：")

        if number == '1':

            # blob数据使用dbscan

            blob()

        elif number == '2':

            # iris数据使用dbscan

            iris()

        elif number == '3':

            # 退出系统

            break

        else:

            print("输入数字错误，请重新输入")

            print()

    print("谢谢使用")

    print()

if __name__ == '__main__':

    # 创建色板图

    colormap = np.array(['red', 'lime', 'black'])

    menu()

import numpy as np

import cv2

from sklearn.cluster import DBSCAN, KMeans

from sklearn.decomposition import PCA

import matplotlib.pyplot as plt

import os

# 1. 准备数据和图像

dataset_path = r'C:\Users\86158\Desktop\flower_photos'  # 数据集目录路径

image_list = []  # 用于存储图像的列表

labels = []      # 用于存储标签的列表

for root, dirs, files in os.walk(dataset_path):

    for filename in files:

        if filename.endswith('.jpg'):  # 仅处理.jpg文件

            image_path = os.path.join(root, filename)

            label = os.path.basename(root)  # 获取类别标签

            image = cv2.imread(image_path)  # 读取图像

            if image is not None:

                image_list.append(image)

                labels.append(label)

# 2. 提取图像特征

# 使用色彩直方图作为特征

def extract_color_histogram(image, bins=(8, 8, 8)):

    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

    hist = cv2.calcHist([hsv_image], [0, 1, 2], None, bins, [0, 180, 0, 256, 0, 256])

    hist = cv2.normalize(hist, hist).flatten()

    return hist

# 提取特征向量

features = []

for img in image_list:

    hist = extract_color_histogram(img)

    features.append(hist)

# 3. 数据标准化

X = np.array(features)

# 4. 使用PCA降维

n_components = 2  # 设置PCA降维后的维度

pca = PCA(n_components=n_components)

X_pca = pca.fit_transform(X)

# 5. 聚类前的散点图按照标签画出

# 创建一个标签到颜色的映射

label_to_color = { label: np.random.rand(3,) for label in set(labels)}

# 使用映射将标签转换为颜色

label_colors = [label_to_color[label] for label in labels]

plt.figure(figsize=(12, 5))

plt.subplot(1, 3, 1)

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=label_colors, cmap='rainbow', marker='o', s=25)

plt.title('Scatter Plot Before Clustering (PCA)')

# 6. 选择K均值聚类算法并进行聚类

kmeans = KMeans(n_clusters=5)

kmeans.fit(X_pca)

cluster_labels_kmeans = kmeans.labels_

# 7. 聚类后的散点图按照标签画出

plt.subplot(1, 3, 2)

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=cluster_labels_kmeans, cmap='rainbow', marker='o', s=25)

plt.title('K-means Clustering (PCA)')

# 8. 使用DBSCAN聚类算法

dbscan = DBSCAN(eps=0.1, min_samples=50)

cluster_labels_dbscan = dbscan.fit_predict(X_pca)

# 9. 聚类后的散点图按照标签画出

plt.subplot(1, 3, 3)

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=cluster_labels_dbscan, cmap='rainbow', marker='o', s=25)

plt.title('DBSCAN Clustering (PCA)')

plt.tight_layout()

plt.show()