def find_color(img_path):
# load the image and convert it from BGR to RGB so that
# we can dispaly it with matplotlib
image = cv2.imread(img_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# show our image
#plt.figure()
#plt.axis("off")
#plt.imshow(image)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters = 3)
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
#print(clt.cluster_centers_)
bar = utils.plot_colors(hist, clt.cluster_centers_)
#print("color centroids",clt.cluster_centers_)
# show our color bart
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
def color_quantization(image, mask, save_path, num_clusters):
#grab image width and height
(h, w) = image.shape[:2]
#change the color storage order
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
#apply the mask to get the segmentation of plant
masked_image = cv2.bitwise_and(image, image, mask = mask)
# reshape the image to be a list of pixels
pixels = masked_image.reshape((masked_image.shape[0] * masked_image.shape[1], 3))
############################################################
#Clustering process
###############################################################
# cluster the pixel intensities
clt = MiniBatchKMeans(n_clusters = num_clusters)
#clt = KMeans(n_clusters = args["clusters"])
clt.fit(pixels)
#assign labels to each cluster
labels = clt.fit_predict(pixels)
#obtain the quantized clusters using each label
quant = clt.cluster_centers_.astype("uint8")[labels]
# reshape the feature vectors to images
quant = quant.reshape((h, w, 3))
image_rec = pixels.reshape((h, w, 3))
# convert from L*a*b* to RGB
quant = cv2.cvtColor(quant, cv2.COLOR_RGB2BGR)
image_rec = cv2.cvtColor(image_rec, cv2.COLOR_RGB2BGR)
# display the images and wait for a keypress
#cv2.imshow("image", np.hstack([image_rec, quant]))
#cv2.waitKey(0)
#define result path for labeled images
result_img_path = save_path + 'cluster_out.png'
# save color_quantization results
cv2.imwrite(result_img_path,quant)
# build a histogram of clusters and then create a figure representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
# remove the background color cluster
clt.cluster_centers_ = clt.cluster_centers_[1: len(clt.cluster_centers_)]
#build a histogram of clusters using center lables
numLabels = utils.plot_centroid_histogram(save_path,clt)
#create a figure representing the distribution of each color
bar = utils.plot_colors(hist, clt.cluster_centers_)
#save a figure of color bar
utils.plot_color_bar(save_path, bar)
def colourAuto(imPath):
image = cv2.imread(imPath)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=5)
clt.fit(image)
# build a histogram of clusters and then create a figure representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
bar, sorted_D, colorAlpha, colorShape = utils.plot_colors(
hist, clt.cluster_centers_)
#cv2.imshow("bar", cv2.cvtColor(bar, cv2.COLOR_BGR2RGB))
print "RETURNED LIST - -------------------------------"
print "color of the alphabet is %s" % (colorAlpha)
print "color of the shape is %s" % (colorShape)
z = easygui.ynbox('Color Detection done', 'Title',
('Continue with Shape', 'Go to manual'))
print z
if z == True:
print "hello"
else:
(colorAlpha, colorShape) = colourManual()
print "---------------------Manual-------------------------"
print 'colour of alphanumeral is' + colorAlpha, '\ncolor of shape is' + colorShape #TODO write to .csv file inst
return colorAlpha, colorShape
def get_top_n_colors(image_path, n_cluster):
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# show original image
# show_image(image)
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=n_cluster)
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
# RGB
#bar = utils.plot_colors(hist, clt.cluster_centers_)
# show our color bar
# show_image(bar)
# show both images
# plt.show()
Cluster_center = [[int(elem) for elem in myList]
for myList in clt.cluster_centers_]
Proportion = [round(elem * 100, 2) for elem in hist]
return zip(Cluster_center, Proportion)
def RunPro(self):
myimage = self.path
mycluster = int((self.spin).get())
# load the image and convert it from BGR to RGB so that
# we can dispaly it with matplotlib
image = cv2.imread(myimage)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=mycluster)
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
bar = utils.plot_colors(hist, clt.cluster_centers_)
# show our color bart
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
def classifyColor(image_color):
image_color = cv2.cvtColor(image_color, cv2.COLOR_BGR2RGB)
image_color = image_color.reshape(
(image_color.shape[0] * image_color.shape[1], 3))
clt = KMeans(n_clusters=3)
clt.fit(image_color)
hist = utils.centroid_histogram(clt)
d = {}
for (percent, color) in zip(hist, clt.cluster_centers_):
p = round(percent, 2)
colors = [int(color[0]), int(color[1]),
int(color[2])] # R: color[0], G: color[1], B: color[2]
d[p] = colors
od = collections.OrderedDict(sorted(d.items(), reverse=True))
# print(od)
count = 1
for percent in od:
if count > 2: break
color = od[percent]
# suppose white or black is background
if (color[0] < 5 and color[1] < 5
and color[2] < 5) or (color[0] > 250 and color[1] > 250
and color[2] > 250):
# print("background")
continue
count += 1
return color
def cluster(self):
ap = argparse.ArgumentParser()
image = cv2.imread("photo/final.jpg")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
plt.figure()
plt.axis("off")
plt.imshow(image)
image = image.reshape((image.shape[0] * image.shape[1], 3))
clt = KMeans(n_clusters=5)
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
bar = utils.plot_colors(hist, clt.cluster_centers_)
# show our color bart
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
def colorPicker(num):
_img = request.files.get('img', None)
#: load the image and convert it from BGR to RGB so that
#: we can dispaly it with matplotlib
image = np.asarray(bytearray(_img.read()), dtype='uint8')
image = cv2.imdecode(image, cv2.IMREAD_COLOR)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
#: reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
#: cluster the pixel intensities
clt = KMeans(n_clusters=num)
clt.fit(image)
#: build a histogram of clusters and then create a figure
#: representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
colors, bar = utils.plot_colors(hist, clt.cluster_centers_)
result = []
for color in colors:
temp = {}
temp['rgb'] = color
hexcolor = '#{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2])
temp['hex'] = hexcolor
result.append(temp)
return make_response(jsonify(colors=result))
def kmeans(image, clusters):
# load the image and convert it from BGR to RGB so that
# we can dispaly it with matplotlib
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# convert to LAB format
#image = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
# show our image
if False:
plt.figure()
plt.axis("off")
plt.imshow(image)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=clusters)
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
def sorted_idx(array):
return sorted(range(len(array)), key=lambda k: array[k])
s_hist = []
s_clusters = []
discarded = 0.0
s_discarded = []
for idx in sorted_idx(hist):
# Discard any bin that is > 50%
if hist[idx] > 0.5:
# Assume top discarded is the background
if not s_discarded:
discarded = hist[idx]
s_discarded = clt.cluster_centers_[idx]
continue
s_hist.append(hist[idx])
s_clusters.append(clt.cluster_centers_[idx])
# Rescale
if discarded:
for i, _ in enumerate(s_hist):
s_hist[i] /= (1 - discarded)
#bar = utils.plot_colors(hist, clt.cluster_centers_)
bar = utils.plot_colors(s_hist, s_clusters)
# show our color bart
if False:
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
# Returns: [(percentage, RGB), ...], top discarded RGB
return OrderedDict(zip(s_hist, s_clusters)), s_discarded
def calcKMeans(im):
#print("Calculating k-means clusters...")
clt = KMeans(n_clusters=3)
#print(clt)
imReshaped = im.reshape((im.shape[0] * im.shape[1], 3))
clt.fit(imReshaped)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
bar = utils.plot_colors(hist, clt.cluster_centers_)
return bar
def dominantColor(image):
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = image.reshape((image.shape[0] * image.shape[1], 3))
clt = KMeans(n_clusters=5)
clt.fit(image)
hist = utils.centroid_histogram(clt)
bar = utils.plot_colors(hist, clt.cluster_centers_)
# show our color bart
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
def get_kmeans_color(img, count, x, y):
#t0 = time.time()
img = img.reshape((img.shape[0] * img.shape[1], 3))
clt = KMeans(n_clusters = count)
clt.fit(img)
hist = utils.centroid_histogram(clt)
colors = clt.cluster_centers_.astype("uint8").tolist()
if hist[0] > hist[1]:
return [(hist[0], colors[0]),
(hist[1], colors[1])]
else:
return [(hist[1], colors[1]),
(hist[0], colors[0])]
def select_image():
# grab a reference to the image panels
global panelA, panelB
path = filedialog.askopenfilename()
n_clusters = int(e.get())
if len(path) > 0:
# load the image from disk, convert it to grayscale, and detect
# edges in it
image = cv2.imread(path)
image2 = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
#dinh dang hinh anh thanh 1 danh sach pixel ma tran Mxn,voi 3 mau RGB
image1 = image2.reshape((image2.shape[0] * image2.shape[1], 3))
#chinh kich thuoc anh ve 640x380
image = cv2.resize(image, (640, 380))
image3 = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
km = Kmeans(n_clusters)
km.fit(image1)
labels = km.labels
centroids = km.centroids
#init_centers=kmeans.kmeans_init_centers(image1,n_clusters)
#init_labels=np.zeros(image1.shape[0])
#centroids,labels=kmeans.kmeans(init_centers,init_labels,image1,n_clusters)
#sap xep danh sach cac pixel
hist = utils.centroid_histogram(labels)
edged = utils.plot_colors(hist, centroids)
#tao hinh anh dung de ve tren plt
image = Image.fromarray(image3)
edged = Image.fromarray(edged)
image = ImageTk.PhotoImage(image)
edged = ImageTk.PhotoImage(edged)
if panelA is None or panelB is None:
panelA = Label(image=image)
panelA.image = image
panelA.pack(side="left", padx=10, pady=10)
panelB = Label(image=edged)
panelB.image = edged
panelB.pack(side="right", padx=10, pady=10)
else:
panelA.configure(image=image)
panelB.configure(image=edged)
panelA.image = image
panelB.image = edged
def km(path):
img = cv2.imread(path)
# reshape the image to be a list of pixels
image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
image = img.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=args["clusters"])
clt.fit(image)
#count the number of pixels that are assigned to each cluster
hist = utils.centroid_histogram(clt)
# the figure that visualizes the number of pixels assigned to each cluster
bar = utils.plot_colors(hist, clt.cluster_centers_)
return bar
def kmeans_image(image_path, clt):
image = cv2.imread(image_path)
# TODO CHECK IF OK TO REMOVE? Matlab needs rbg. but order might be different
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
percentage_color_list = utils.get_colors_and_percentages(hist, clt.cluster_centers_)
return percentage_color_list
def colourAutoSubProcess(imagePath):
# load the image and convert it from BGR to RGB so that we can dispaly it with matplotlib
image = cv2.imread(imagePath)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=5)
clt.fit(image)
# build a histogram of clusters and then create a figure representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
#print clt.cluster_centers_
bar, sorted_D, l1, l2 = utils.plot_colors(hist, clt.cluster_centers_)
return (bar, sorted_D, l1, l2)
def get_dominant_colors(image, path):
# load the image and convert it from BGR to RGB so that
# we can dispaly it with matplotlib
image = cv2.imread(path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# # show our image
# plt.figure()
# plt.axis("off")
# plt.imshow(image)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters = 3) # RGB values of HSV picture
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
bar = utils.plot_colors(hist, clt.cluster_centers_)
max_color = hist.max()
histogram_size = hist.__len__()
for i in range(0,histogram_size):
if hist[i] >= max_color:
dominant_color_index = i
h, s, v = clt.cluster_centers_[dominant_color_index]
# h, s, v = rgb_to_hsv(r, g, b)
# # show our color bart
# plt.figure()
# plt.axis("off")
# plt.imshow(bar)
# plt.show()
return h, s, v
def coulor_Kmeans(xmin,ymin,xmax,ymax,image,clusters):
image_new=image[xmin:xmax,ymin:ymax,:]
image_new = image_new.reshape((image_new.shape[0] * image_new.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters = clusters)
clt.fit(image_new)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
bar = utils.plot_colors(hist, clt.cluster_centers_)
# show our color bart
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
return clt.cluster_centers_
def bounding_box_dominant_colour(img, x1, y1, w, h):
# given a bounding box definitions and an image, return the dominant colour for that box via
# k-means clustering
roi = img[int(y1):int(y1 + h), int(x1):int(x1 + w)]
# reshape the image to be a list of pixels
roi = roi.reshape((roi.shape[0] * roi.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=5)
clt.fit(roi)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = centroid_histogram(clt)
max_cluster = np.argmax(hist)
rgb = clt.cluster_centers_[max_cluster].astype(int)
return get_colour_name(rgb)
def kmeans_image_show(image_path, clusters=3):
pass
# construct the argument parser and parse the arguments
# ap = argparse.ArgumentParser()
# ap.add_argument("-i", "--image", required = True, help = "Path to the image")
# ap.add_argument("-c", "--clusters", required = True, type = int, help = "# of clusters")
# args = vars(ap.parse_args())
#
# load the image and convert it from BGR to RGB so that
# we can display it with matplotlib
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# show our image
plt.figure()
plt.axis("off")
plt.imshow(image)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters = clusters)
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
percentage_color_list = utils.get_colors_and_percentages(hist, clt.cluster_centers_)
print percentage_color_list
print percentage_color_list[0][1][0]
bar = utils.plot_colors(hist, clt.cluster_centers_)
# show our color bart
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
def color_kmeans(src_bg_im, n_colors=3):
"""
compute k-means color clustering
:param src_bg_im:
:param n_colors: number of object's color
:return: histogram, colors and colors' stddev
"""
src_bg_im = resize_if_necessary(src_bg_im, MAX_SAMPLE_COLS)
rows, cols, channels = src_bg_im.shape
img_lab = cv2.cvtColor(src_bg_im, cv2.COLOR_BGR2LAB)
img_lab = img_lab.reshape((rows * cols, channels))
# print 'src_im:', rows, cols, src_im.dtype
# print 'img_lab:', img_lab.shape, img_lab.dtype
# Define criteria = ( type, max_iter = 10 , epsilon = 1.0 )
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 8, 1.0)
# Set flags (Just to avoid line break in the code)
flags = cv2.KMEANS_RANDOM_CENTERS
clusters = n_colors + 2
compactness, labels, centroids = cv2.kmeans(np.float32(img_lab), clusters,
None, criteria, 10, flags)
hist = utils.centroid_histogram(labels)
hist_colors = [(p, c) for (p, c) in zip(hist, centroids)]
hist_colors = sorted(hist_colors, key=lambda pc: pc[0], reverse=True)
stddev = np.sqrt(compactness / (rows * cols))
filtered_colors = [
pc for pc in hist_colors
if pc[1][0] > MIN_LIGHT_VALUE and pc[1][0] < MAX_LIGHT_VALUE
]
if len(filtered_colors) < n_colors:
filtered_colors = hist_colors
return [colors[0] for colors in filtered_colors
], [colors[1] for colors in filtered_colors], stddev
def colorCluster(img, k, v_threshold):
# load the image and convert it from BGR to RGB so that
# we can dispaly it with matplotlib
image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=k)
clt.fit(image)
hist = utils.centroid_histogram(clt)
zipped = zip(hist, clt.cluster_centers_)
max_var_color = None
max_var = None
hasblack = None
for percent, color in zipped:
variance = np.var(color)
if variance < v_threshold:
variance = 0
if max_var is None or max_var < variance:
max_var = variance
max_var_color = color
luma = 0.2126 * color[0] + 0.7152 * color[1] + 0.0722 * color[2]
# using luma values to find white and black
if luma < 20:
hasblack = color
if max_var_color is not None and max_var != 0:
return max_var_color
return hasblack
def getDominantColor(image):
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=3)
clt.fit(image)
hist = utils.centroid_histogram(clt)
dominantColorRGB = clt.cluster_centers_[np.argmax(hist)]
print 'dominant color rgb: ', dominantColorRGB
dominantColorRGB = dominantColorRGB.astype('uint8')
dominantColorRGB = np.reshape(dominantColorRGB, (1, 1, 3))
dominantColorLAB = cv2.cvtColor(dominantColorRGB, cv2.COLOR_RGB2LAB)
dominantColorLAB = dominantColorLAB[0][0].astype('float64')
dominantColorLAB[0] *= 100 / 255.0
dominantColorLAB[1] -= 128
dominantColorLAB[2] -= 128
return dominantColorLAB
def predict_color(image):
print("predict_color")
# extract color
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = image.reshape((image.shape[0] * image.shape[1], 3))
clt.fit(image)
hist = utils.centroid_histogram(clt)
d = {}
for (percent, color) in zip(hist, clt.cluster_centers_):
p = round(percent, 2)
colors = [int(color[0]), int(color[1]), int(color[2])] # R: color[0], G: color[1], B: color[2]
d[p] = colors
od = collections.OrderedDict(sorted(d.items(), reverse=True))
# print(od)
R = 0
G = 0
B = 0
count = 1 # 주석?
for percent in od:
if count > 2: break # 주석?
color = od[percent]
# suppose pure white or pure black is background
if (color[0] < 5 and color[1] < 5 and color[2] < 5) or (color[0] > 250 and color[1] > 250 and color[2] > 250):
# print("background")
continue
# print(str(count) + ": " + "R ("+str(color[0])+"), G ("+str(color[1])+"), B ("+str(color[2])+")")
else:
R = color[0]
G = color[1]
B = color[2]
break
count+=1 # 주석?
print("R: " + str(R) + ", "+"G: " + str(G) + ", "+"B: " + str(B))
return R,G,B
import utils as ut
import cv2
img = '/home/brito/Documentos/Dev/tcc/img/f1.jpeg'
img = cv2.imread(img)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
rect = (430, 196, 800, 310)
img = ut.black_back(img, rect)
img = img.reshape((img.shape[0] * img.shape[1], 3))
# k means determine k
distortions = []
hist_all = []
K = range(1, 10)
for k in K:
kmeanModel = KMeans(n_clusters=k).fit(img)
kmeanModel.fit(img)
hist_all.append(ut.centroid_histogram(kmeanModel))
distortions.append(
sum(
np.min(cdist(img, kmeanModel.cluster_centers_, 'euclidean'),
axis=1)) / img.shape[0])
# Plot the elbow
plt.plot(K, distortions, 'bx-')
plt.xlabel('k')
plt.ylabel('Distortion')
plt.title('The Elbow Method showing the optimal k')
plt.show()
# we can dispaly it with matplotlib
image = cv2.imread(args["image"])
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# show our image
plt.figure()
plt.axis("off")
plt.imshow(image)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters=args["clusters"])
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
bar = utils.plot_colors(hist, clt.cluster_centers_)
bar[0][0][1] = 255
domColor = bar[0][0]
print(domColor)
# show our color bart
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
help = "# of clusters")
args = vars(ap.parse_args())
# load the image and convert it from BGR to RGB so that
# we can dispaly it with matplotlib
image = cv2.imread(args["image"])
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# show our image
plt.figure()
plt.axis("off")
plt.imshow(image)
# reshape the image to be a list of pixels
image = image.reshape((image.shape[0] * image.shape[1], 3))
# cluster the pixel intensities
clt = KMeans(n_clusters = args["clusters"])
clt.fit(image)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
bar = utils.plot_colors(hist, clt.cluster_centers_)
# show our color bart
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
def color_quantization(image, mask, save_path, num_clusters):
#grab image width and height
(h, w) = image.shape[:2]
#change the color storage order
#image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
#image = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
#apply the mask to get the segmentation of plant
masked_image_BGR = cv2.bitwise_and(image, image, mask = mask)
#define result path for labeled images
result_img_path = save_path + 'masked.png'
cv2.imwrite(result_img_path, masked_image_BGR)
# convert the image from the RGB color space to the L*a*b*
# color space -- since we will be clustering using k-means
# which is based on the euclidean distance, we'll use the
# L*a*b* color space where the euclidean distance implies
# perceptual meaning
#masked_image = cv2.cvtColor(masked_image_BGR, cv2.COLOR_BGR2LAB)
masked_image = cv2.cvtColor(masked_image_BGR, cv2.COLOR_BGR2RGB)
#reshape the image to be a list of pixels
pixels = masked_image.reshape((masked_image.shape[0] * masked_image.shape[1], 3))
############################################################
#Clustering process
###############################################################
# cluster the pixel intensities
clt = MiniBatchKMeans(n_clusters = num_clusters)
#clt = KMeans(n_clusters = args["clusters"])
clt.fit(pixels)
#assign labels to each cluster
labels = clt.fit_predict(pixels)
#obtain the quantized clusters using each label
quant = clt.cluster_centers_.astype("uint8")[labels]
#reshape the feature vectors to images
quant = quant.reshape((h, w, 3))
image_rec = pixels.reshape((h, w, 3))
#convert from L*a*b* to RGB
quant = cv2.cvtColor(quant, cv2.COLOR_RGB2BGR)
#quant = cv2.cvtColor(quant, cv2.COLOR_LAB2BGR)
#define result path for labeled images
result_img_path = save_path + 'cluster_out.png'
# save color_quantization results
cv2.imwrite(result_img_path, quant)
counts = Counter(labels)
# sort to ensure correct color percentage
counts = dict(sorted(counts.items()))
center_colors = clt.cluster_centers_
# We get ordered colors by iterating through the keys
ordered_colors = [center_colors[i] for i in counts.keys()]
hex_colors = [RGB2HEX(ordered_colors[i]) for i in counts.keys()]
rgb_colors = [ordered_colors[i] for i in counts.keys()]
#print(hex_colors)
index_bkg = [index for index in range(len(hex_colors)) if hex_colors[index] == '#000000']
#print(index_bkg[0])
#print(counts)
#remove background color
del hex_colors[index_bkg[0]]
del rgb_colors[index_bkg[0]]
# Using dictionary comprehension to find list
# keys having value .
delete = [key for key in counts if key == index_bkg[0]]
# delete the key
for key in delete: del counts[key]
fig = plt.figure(figsize = (6, 6))
plt.pie(counts.values(), labels = hex_colors, colors = hex_colors)
#define result path for labeled images
result_img_path = save_path + 'pie_color.png'
plt.savefig(result_img_path)
#build a histogram of clusters and then create a figure representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clt)
#remove the background color cluster
clt.cluster_centers_ = np.delete(clt.cluster_centers_, index_bkg[0], axis=0)
#build a histogram of clusters using center lables
numLabels = utils.plot_centroid_histogram(save_path,clt)
#create a figure representing the distribution of each color
bar = utils.plot_colors(hist, clt.cluster_centers_)
#save a figure of color bar
utils.plot_color_bar(save_path, bar)
return rgb_colors
clusters = KMeans(n_clusters=num)
clusters.fit(image_pixels)
# After the call to fit, the key information is contained
# in clusters.cluster_centers_ :
# count = 0
# for center in clusters.cluster_centers_:
# print("Center #", count, " == ", center)
# # note that the center's values are floats, not ints!
# center_integers = [int(p) for p in center]
# print(" and as ints:", center_integers)
# count += 1
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(clusters)
bar = utils.plot_colors(hist, clusters.cluster_centers_)
bars.append(bar)
title = str(num) + " means"
titles.append(title)
# in the first figure window, show our image
# plt.figure()
# plt.axis("off")
# plt.imshow(image)
# in the second figure window, show the pixel histograms
# this starter code has a single value of k for each
# your task is to vary k and show the resulting histograms
# this also illustrates one way to display multiple images
# in a 2d layout (fig == figure, ax == axes)
image_data = cv2.imread(image)
# image_data = cv2.cvtColor(image_data, cv2.COLOR_BGR2RGB)
image_data = cv2.cvtColor(image_data, cv2.COLOR_BGR2RGB)
# reshape the image to be a list of pixels
image_data = image_data.reshape(
(image_data.shape[0] * image_data.shape[1], 3))
# cluster the pixel intensities
db = KMeans(n_clusters=cluster)
db.fit(image_data)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(db)
#bar = utils.plot_colors(hist, db.cluster_centers_)
# reorganize colors
hist_color = zip(hist, db.cluster_centers_)
hist_out, color = zip(*hist_color)
# print hist_out, color
# set up dictionary and list to sort colors
intensity_dict = {}
color_sorted_by_int = []
# convert RGB to intensity
for hist, col in hist_color:
# get intensity values
intensity = (0.299 * col[0] + 0.587 * col[1] + 0.114 * col[2])
cv2.imshow('ycrcb', image);
cv2.waitKey(0);
# reshape image to metrix N x 3
imageReshaped = image.reshape((-1, 3))
# change data in array from uint8 to float32
imageReshaped = np.float32(imageReshaped)
# rule the iteration termination
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
# number of cluster
K = 8
ret, label, center = cv2.kmeans(imageReshaped, K, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
# find mean color range and percent of color in image
hist = utils.centroid_histogram(center, label)
bar = utils.plot_colors(hist, center)
# convert back to uint8 and reshape image
center = np.uint8(center)
res = center[label.flatten()]
res2 = res.reshape((image.shape))
# print color and percent in image
for(percent, color) in zip(hist, center):
print "color(", color, ") = ", percent*100, "%"
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()
print 'image.ndim:{}, img_lab.ndim:{}'.format(image.ndim, img_lab.ndim)
# show our image
plt.figure()
plt.axis("off")
plt.imshow(image)
# reshape the image to be a list of pixels
# image = image.reshape((image.shape[0] * image.shape[1], 3))
img_lab = img_lab.reshape((image.shape[0] * image.shape[1], 3))
# Define criteria = ( type, max_iter = 10 , epsilon = 1.0 )
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
# Set flags (Just to avoid line break in the code)
flags = cv2.KMEANS_RANDOM_CENTERS
n_clusters = args.clusters
compactness, labels, centers = cv2.kmeans(np.float32(img_lab), n_clusters,
None, criteria, 10, flags)
# build a histogram of clusters and then create a figure
# representing the number of pixels labeled to each color
hist = utils.centroid_histogram(labels)
bar = utils.plot_colors_lab(hist, centers)
# show our color bart
plt.figure()
plt.axis("off")
plt.imshow(bar)
plt.show()