I need your help because I'm stuck at a stage of my project. First of all I use deep learning algorithms to detect elements in an image. Once these elements are detected I try to recover two colours in this image.
Here is an example of the images I process:
To make it easier I contrast the image to improve the colours here is an example:
My goal is to find in this image the blue and red colour, it is at this precise moment that I block. When the image is of good quality I manage to find the colours but on other images of less good quality it is very difficult to get good results.
Knowing that the colours that I would like to find are the following: red, green, blue, yellow, grey, brown, violet, turquoise, orange, pink
Do you know of any image processing methods or machine learning models that could solve my problem?
Thank you in advance for your time
More images for exemple :
And the code i used :
import cv2
import copy
from sklearn import multioutput
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import numpy as np
from collections import Counter
from skimage.color import rgb2lab, deltaE_cie76
import os
from PIL import Image, ImageEnhance
class ImageColorDetection(object):
origineFrame : list = []
imageFrame : list = []
hsvFrame : list = []
colorList : dict = {}
def __init__(self, array=None, path=None, rotated=0):
self.colorList = {}
if path is not None:
self.origineFrame = Image.open(path).convert('RGB').rotate(rotated)
im_output = Image.open(path).convert('RGB').rotate(rotated)
elif array is not None:
self.origineFrame = Image.fromarray(array).convert('RGB').rotate(rotated)
im_output = Image.fromarray(array).convert('RGB').rotate(rotated)
else:
raise Exception('Aucune image n\'est renseigner dans le constructeur')
#im_output = im_output.filter(ImageFilter.BLUR)
#im_output = im_output.filter(ImageFilter.EDGE_ENHANCE_MORE)
#im_output = ImageOps.autocontrast(im_output, cutoff = 5, ignore = 5)
enhancer = ImageEnhance.Color(im_output)
im_output = enhancer.enhance(3)
enhancer = ImageEnhance.Contrast(im_output)
im_output = enhancer.enhance(0.9)
enhancer = ImageEnhance.Sharpness(im_output)
im_output = enhancer.enhance(2)
enhancer = ImageEnhance.Brightness(im_output)
im_output = enhancer.enhance(1.6)
im_output = np.array(im_output)
self.imageFrame = cv2.cvtColor(im_output, cv2.COLOR_RGB2BGR)
self.hsvFrame = cv2.cvtColor(self.imageFrame, cv2.COLOR_BGR2HSV)
def findColor(self, color_rgb, color_title, color_upper, color_lower):
kernal = np.ones((5, 5), "uint8")
color_mask = cv2.inRange(self.hsvFrame, color_lower, color_upper)
color_mask = cv2.dilate(color_mask, kernal)
res_red = cv2.bitwise_and(self.imageFrame, self.imageFrame,
mask = color_mask)
current_area = 0
x, y, w, h, (r,g,b) = 0, 0, 0, 0, color_rgb
# Creating contour to track blue color
im, contours, hierarchy = cv2.findContours(color_mask,
cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
for pic, contour in enumerate(contours):
area = cv2.contourArea(contour)
if(area > 1000 and current_area < area):
x, y, w, h = cv2.boundingRect(contour)
self.colorList[color_title] = x, y, w, h, color_rgb
current_area = area
return color_title in self.colorList.keys()
def ShowImage(self):
tmp_img = np.asarray(copy.copy(self.origineFrame))
for color in self.colorList:
cv2.rectangle(
tmp_img,
(self.colorList[color][0], self.colorList[color][1]),
((self.colorList[color][0] self.colorList[color][2]), (self.colorList[color][1] self.colorList[color][3])),
self.colorList[color][4], 2)
cv2.putText(
tmp_img,
color,
(self.colorList[color][0], self.colorList[color][1]),
cv2.FONT_HERSHEY_SIMPLEX,
1.0,
self.colorList[color][4])
#plt.imshow(tmp_img, multioutput=True)
return tmp_img
def ShowImageContrast(self):
tmp_img = copy.copy(self.imageFrame)
tmp_img = cv2.cvtColor(tmp_img, cv2.COLOR_BGR2RGB)
for color in self.colorList:
cv2.rectangle(
tmp_img,
(self.colorList[color][0], self.colorList[color][1]),
((self.colorList[color][0] self.colorList[color][2]), (self.colorList[color][1] self.colorList[color][3])),
self.colorList[color][4], 3)
cv2.putText(
tmp_img,
color,
(self.colorList[color][0], self.colorList[color][1]),
cv2.FONT_HERSHEY_SIMPLEX,
0.8,
self.colorList[color][4])
#plt.imshow(tmp_img, multioutput=True)
return tmp_img
def RGB2HEX(self, color):
return "#{:02x}{:02x}{:02x}".format(int(color[0]), int(color[1]), int(color[2]))
def get_colors(self, contrasted, number_of_colors, show_chart):
if contrasted:
modified_image = cv2.resize(np.asarray(self.imageFrame), (600, 400), interpolation = cv2.INTER_AREA)
else:
modified_image = cv2.resize(np.asarray(self.origineFrame), (600, 400), interpolation = cv2.INTER_AREA)
#modified_image = cv2.resize(np.asarray(self.origineFrame), (600, 400), interpolation = cv2.INTER_AREA)
modified_image = modified_image.reshape(modified_image.shape[0]*modified_image.shape[1], 3)
clf = KMeans(n_clusters = number_of_colors)
labels = clf.fit_predict(modified_image)
counts = Counter(labels)
# sort to ensure correct color percentage
counts = dict(sorted(counts.items()))
center_colors = clf.cluster_centers_
# We get ordered colors by iterating through the keys
ordered_colors = [center_colors[i] for i in counts.keys()]
hex_colors = [self.RGB2HEX(ordered_colors[i]) for i in counts.keys()]
rgb_colors = [ordered_colors[i] for i in counts.keys()]
print("Nombre de couleur : ", len(hex_colors))
if (show_chart):
plt.figure(figsize = (8, 6))
plt.pie(counts.values(), labels = hex_colors, colors = hex_colors)
return counts, hex_colors, rgb_colors
CodePudding user response：
Maybe OpenCV's inRange() might help?
import cv2
hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
lower_hsvcolorspace = np.array([hue_min, saturation_min, value_min])
upper_hsvcolorspace = np.array([hue_max, saturation_max, value_max])
mask = cv2.inRange(hsv_image, lower_hsvcolorspace, upper_hsvcolorspace)
You can look up your expected HSV values here for example. Just be aware that the ranges in OpenCV are different: 0-179 (hue) and 0-255 (saturation, value).
Can you post more images: good ones, bad ones and the expected output?
CodePudding user response：
Convert you image to HSV cv2.cvtColor(image, cv2.COLOR_BGR2HSV), than create threshold vectors like
lower_green = np.array([30, 0, 0])
upper_green = np.array([90, 255, 255])
Using this thresholds you can filter different colors, read more about HSV
mask = cv2.inRange(hsv_image, lower_green, upper_green)