Question

用python K值聚类识别图片主要颜色的程序，算法python代码已经有了

算法代码：http://blog.zeevgilovitz.com/detecting-dominant-colours-in-python/

需求：
现在C盘底下有一个pic的文件夹，里面有很多图片
需要写一个程序，分析每一张图片的主要颜色（选出一个最能代表整个图片的颜色，算法自定，随便百度看看吧）
结果就是每张图片得出3个rgb值，写在一个记事本里面。。。

其实很简单啦，主要就是加个输入、输出语句就好啦

Answer 1

难得被人求助一次, 这个必须回答一下. 不过你的需求确实没有写得太清楚. 根据k值算法出来的是主要颜色有三个, 所以我把三个颜色都打在记事本里了. 如果和你的需求有误, 请自行解决吧.

另外这里需要用到numpy的库, 希望你装了, 如果没装, 这个直接安装也比较麻烦, 可以看一下portablepython的绿色版。

代码如下：

# -*- coding: utf-8 -*-
import Image
import random
import numpy
class Cluster(object):
    def __init__(self):
        self.pixels = []
        self.centroid = None
    def addPoint(self, pixel):
        self.pixels.append(pixel)
    def setNewCentroid(self):
        R = [colour[0] for colour in self.pixels]
        G = [colour[1] for colour in self.pixels]
        B = [colour[2] for colour in self.pixels]
        R = sum(R) / len(R)
        G = sum(G) / len(G)
        B = sum(B) / len(B)
        self.centroid = (R, G, B)
        self.pixels = []
        return self.centroid
class Kmeans(object):
    def __init__(self, k=3, max_iterations=5, min_distance=5.0, size=200):
        self.k = k
        self.max_iterations = max_iterations
        self.min_distance = min_distance
        self.size = (size, size)
    def run(self, image):
        self.image = image
        self.image.thumbnail(self.size)
        self.pixels = numpy.array(image.getdata(), dtype=numpy.uint8)
        self.clusters = [None for i in range(self.k)]
        self.oldClusters = None
        randomPixels = random.sample(self.pixels, self.k)
        for idx in range(self.k):
            self.clusters[idx] = Cluster()
            self.clusters[idx].centroid = randomPixels[idx]
        iterations = 0
        while self.shouldExit(iterations) is False:
            self.oldClusters = [cluster.centroid for cluster in self.clusters]
            print iterations
            for pixel in self.pixels:
                self.assignClusters(pixel)
            for cluster in self.clusters:
                cluster.setNewCentroid()
            iterations += 1
        return [cluster.centroid for cluster in self.clusters]
    def assignClusters(self, pixel):
        shortest = float('Inf')
        for cluster in self.clusters:
            distance = self.calcDistance(cluster.centroid, pixel)
            if distance < shortest:
                shortest = distance
                nearest = cluster
        nearest.addPoint(pixel)
    def calcDistance(self, a, b):
        result = numpy.sqrt(sum((a - b) ** 2))
        return result
    def shouldExit(self, iterations):
        if self.oldClusters is None:
            return False
        for idx in range(self.k):
            dist = self.calcDistance(
                numpy.array(self.clusters[idx].centroid),
                numpy.array(self.oldClusters[idx])
            )
            if dist < self.min_distance:
                return True
        if iterations <= self.max_iterations:
            return False
        return True
    # ############################################
    # The remaining methods are used for debugging
    def showImage(self):
        self.image.show()
    def showCentroidColours(self):
        for cluster in self.clusters:
            image = Image.new("RGB", (200, 200), cluster.centroid)
            image.show()
    def showClustering(self):
        localPixels = [None] * len(self.image.getdata())
        for idx, pixel in enumerate(self.pixels):
                shortest = float('Inf')
                for cluster in self.clusters:
                    distance = self.calcDistance(
                        cluster.centroid,
                        pixel
                    )
                    if distance < shortest:
                        shortest = distance
                        nearest = cluster
                localPixels[idx] = nearest.centroid
        w, h = self.image.size
        localPixels = numpy.asarray(localPixels)\
            .astype('uint8')\
            .reshape((h, w, 3))
        colourMap = Image.fromarray(localPixels)
        colourMap.show()
    
if __name__=="__main__":
    from PIL import Image
    import os
    
    k_image=Kmeans()
    path = r'.\\pics\\'
    fp = open('file_color.txt','w')
    for filename in os.listdir(path):
        print path+filename
        try:
            color = k_image.run(Image.open(path+filename))
            fp.write('The color of '+filename+' is '+str(color)+'\n')
        except:
            print "This file format is not support"
    fp.close()

Answer 2

您好，这样的：
# -*- coding: utf-8 -*-

import colorsys

def get_dominant_color(image):

#颜色模式转换，以便输出rgb颜色值
image = image.convert('RGBA')

#生成缩略图，减少计算量，减小cpu压力
image.thumbnail((200, 200))

max_score = None
dominant_color = None

for count, (r, g, b, a) in image.getcolors(image.size[0] * image.size[1]):
# 跳过纯黑色
if a == 0:
continue

saturation = colorsys.rgb_to_hsv(r / 255.0, g / 255.0, b / 255.0)[1]

y = min(abs(r * 2104 + g * 4130 + b * 802 + 4096 + 131072) >> 13, 235)

y = (y - 16.0) / (235 - 16)

# 忽略高亮色
if y > 0.9:
continue

# Calculate the score, preferring highly saturated colors.
# Add 0.1 to the saturation so we don't completely ignore grayscale
# colors by multiplying the count by zero, but still give them a low
# weight.
score = (saturation + 0.1) * count

if score > max_score:
max_score = score
dominant_color = (r, g, b)

return dominant_color

if __name__=="__main__":
from PIL import Image
import os

path = r'.\\pics\\'
fp = open('file_color.txt','w')
for filename in os.listdir(path):
print path+filename
try:
color = get_dominant_color(Image.open(path+filename))
fp.write('The color of '+filename+' is '+str(color)+'\n')
except:
print "This file format is not support"
fp.close()

追问

醉了。。。你抄的这个答案就是我问的
没有发现需求不一样了嘛。。。