K-meansによる減色処理のステップ1と2を実装するために、以下のPythonコードを作成しました。ここでは、クラス数をK=5とし、画像データをreshapeして扱いやすくします。

まず、必要なライブラリをインポートします。

import numpy as np
import matplotlib.pyplot as plt

from skimage import io
# 画像を読み込み、HxWx3の形状にする
image = io.imread('your_image_path.jpg')
H, W, _ = image.shape
image_reshaped = image.reshape((H * W, 3))

# クラス数Kを設定
K = 5
# 乱数のシードを設定
np.random.seed(0)
# 画像からランダムにK個のRGB成分をサンプリング
random_indices = np.random.choice(np.arange(H * W), K, replace=False)
clusters = image_reshaped[random_indices]

# 各画素に対して色の距離が最小となるクラスのインデックスを割り振る関数
def assign_clusters(image_pixels, clusters):
    distances = np.linalg.norm(image_pixels[:, np.newaxis] - clusters, axis=2)
    return np.argmin(distances, axis=1)

# 各画素に対して最も近いクラスのインデックスを計算
assigned_clusters = assign_clusters(image_reshaped, clusters)

# クラスの割り当てを画像として表示
assigned_image = clusters[assigned_clusters].reshape((H, W, 3))

# 画像を表示
plt.imshow(assigned_image.astype(np.uint8))
plt.show()

このコードでは、次のステップを実装しています：

画像データを読み込み、(HxW, 3)にreshapeします。
クラス数をK=5と設定します。
np.random.seed(0)を設定し、画像からランダムに5つのRGB成分をサンプリングします。
各画素に対して色の距離が最小となるクラスのインデックスを計算する関数を定義します。
各画素に最も近いクラスのインデックスを割り振ります。
クラスの割り当て結果を元の画像形状にreshapeし、表示します。

import cv2
import numpy as np
import matplotlib.pyplot as plt
from glob import glob

# K-means step1
def k_means_step1(img, Class=5):
              #  get shape
              H, W, C = img.shape
              # initiate random seed
              np.random.seed(0)
              # reshape
              img = np.reshape(img, (H * W, -1))
              # select one index randomly
              i = np.random.choice(np.arange(H * W), Class, replace=False)
              Cs = img[i].copy()
              print(Cs)
              clss = np.zeros((H * W), dtype=int)
              # each pixel
              for i in range(H * W):
                            # get distance from base pixel
                            dis = np.sqrt(np.sum((Cs - img[i]) ** 2, axis=1))
                            # get argmin distance
                            clss[i] = np.argmin(dis)
              # show
              out = np.reshape(clss, (H, W)) * 50
              out = out.astype(np.uint8)
              return out
# read image
img = cv2.imread("imori.jpg").astype(np.float32)
# K-means step2
out = k_means_step1(img)
cv2.imwrite("out.jpg", out)
cv2.imshow("result", out)
cv2.waitKey(0)

import cv2
import numpy as np
import matplotlib.pyplot as plt

from glob import glob

 

def k_means(img, Class=5):
    # get shape
    H, W, C = img.shape

 

    # initiate random seed
    np.random.seed(0)

    # reshape image
    img = np.reshape(img, (H * W, -1))


    # get index randomly
    i = np.random.choice(np.arange(H * W), Class, replace=False)
    Cs = img[i].copy()

    while True:
        # prepare pixel class label
        clss = np.zeros((H * W), dtype=int)
        # each pixel
        for i in range(H * W):
            # get distance from index pixel
            dis = np.sqrt(np.sum((Cs - img[i])**2, axis=1)
            # get argmin distance
            clss[i] = np.argmin(dis)

 

        # selected pixel values
        Cs_tmp = np.zeros((Class, 3))
     
        # each class label
        for i in range(Class):
            Cs_tmp[i] = np.mean(img[clss == i], axis=0)

        # if not any change
        if (Cs == Cs_tmp).all():

            break

        else:
            Cs = Cs_tmp.copy()

    # prepare out image
    out = np.zeros((H * W, 3), dtype=np.float32)

 
    # assign selected pixel values 
    for i in range(Class):
        out[clss == i] = Cs[i]


    print(Cs)

       

    out = np.clip(out, 0, 255)


    # reshape out image
    out = np.reshape(out, (H, W, 3))
    out = out.astype(np.uint8)
    return out

 

# read image
img = cv2.imread("imori.jpg").astype(np.float32)

 
# K-means
out = k_means(img)
cv2.imwrite("out.jpg", out)
cv2.imshow("result", out)
cv2.waitKey(0)

import numpy as np
import cv2
import matplotlib.pyplot as plt

# Load the image
image = cv2.imread('imori.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # Convert to RGB
h, w, c = image.shape

# Reshape the image to (HxW, 3)
pixels = image.reshape(-1, 3)

# Number of clusters
k = 5

# Initialize random seed
np.random.seed(0)

# Randomly choose 5 pixels as initial cluster centers
initial_centers_indices = np.random.choice(np.arange(h * w), k, replace=False)
centers = pixels[initial_centers_indices]

# Function to calculate color distance
def color_distance(c1, c2):
return np.sqrt(np.sum((c1 - c2) ** 2, axis=1))

# Step 2: Assign each pixel to the nearest cluster center
def assign_clusters(pixels, centers):
clusters = np.zeros((pixels.shape[0],), dtype=int)
for i, pixel in enumerate(pixels):
distances = color_distance(pixel, centers)
clusters[i] = np.argmin(distances)
return clusters

# Step 3: Recalculate the new cluster centers
def update_centers(pixels, clusters, k):
new_centers = np.zeros((k, 3), dtype=float)
for i in range(k):
cluster_pixels = pixels[clusters == i]
if len(cluster_pixels) > 0:
new_centers[i] = np.mean(cluster_pixels, axis=0)
return new_centers

# K-means clustering algorithm
max_iter = 100
for _ in range(max_iter):
clusters = assign_clusters(pixels, centers)
new_centers = update_centers(pixels, clusters, k)
# Check for convergence
if np.all(centers == new_centers):
break
centers = new_centers

# Assign the final cluster colors to each pixel
final_pixels = np.zeros_like(pixels)
for i in range(k):
final_pixels[clusters == i] = centers[i]

# Reshape the result back to the original image shape
result_image = final_pixels.reshape(h, w, c)

# Convert to uint8 for display
result_image = result_image.astype(np.uint8)

# Display the original and result images side by side
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image)
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('K-means Color Reduced Image')
plt.imshow(result_image)
plt.axis('off')

plt.show()

# Save the result
result_image_bgr = cv2.cvtColor(result_image, cv2.COLOR_RGB2BGR) # Convert back to BGR for saving
cv2.imwrite('imori_kmeans.jpg', result_image_bgr)

print("Final cluster centers:", centers)

K-meansによる減色処理のステップ1と2を実装するために、以下のPythonコードを作成しました。
ここでは、クラス数をK=5とし、画像データをreshapeして扱いやすくします。
まず、必要なライブラリをインポートします。
import numpy as np
import matplotlib.pyplot as plt
from skimage import io

# 画像を読み込み、HxWx3の形状にする
image = io.imread('your_image_path.jpg')
H, W, _ = image.shape
image_reshaped = image.reshape((H * W, 3))

# クラス数Kを設定
K = 5

# 乱数のシードを設定

np.random.seed(0)




# 画像からランダムにK個のRGB成分をサンプリング

random_indices = np.random.choice(np.arange(H * W), K, replace=False)
clusters = image_reshaped[random_indices]


# 各画素に対して色の距離が最小となるクラスのインデックスを割り振る関数

def assign_clusters(image_pixels, clusters):
    distances = np.linalg.norm(image_pixels[:, np.newaxis] - clusters, axis=2)
    return np.argmin(distances, axis=1)

# 各画素に対して最も近いクラスのインデックスを計算

assigned_clusters = assign_clusters(image_reshaped, clusters)

# クラスの割り当てを画像として表示

assigned_image = clusters[assigned_clusters].reshape((H, W, 3))

# 画像を表示

plt.imshow(assigned_image.astype(np.uint8))
plt.show()

このコードでは、次のステップを実装しています：
画像データを読み込み、(HxW, 3)にreshapeします。
クラス数をK=5と設定します。
np.random.seed(0)を設定し、画像からランダムに5つのRGB成分をサンプリングします。
各画素に対して色の距離が最小となるクラスのインデックスを計算する関数を定義します。
各画素に最も近いクラスのインデックスを割り振ります。
クラスの割り当て結果を元の画像形状にreshapeし、表示します。