def iteratePixels(self, matrix):
arm = ("left_arm", "right_arm")
print(matrix)
split = self.width / 2
hashMap = {}
counter = 0
for x in range(self.width / 2, self.width):
for y in range(100, self.height - 100):
narray = matrix[x][y]
red = narray[0]
green = narray[1]
blue = narray[2]
rgb = (red, green, blue)
if webcolors.rgb_to_name(
rgb) in colorOfBlocks and colorOfBlocks not in hashMap:
if x < split:
tup = (counter, arm[0])
hashMap[colorOfBlocks] = tup
counter += 1
else:
tup = (counter, arm[1])
hashMap[colorOfBlocks] = tup
counter += 1
return hashMap
def get_colour_name(requested_colour):
try:
closest_name = actual_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = closest_colour(requested_colour)
actual_name = None
return actual_name, closest_name
def get_colour_name(requested_colour):
new = webcolors.hex_to_rgb(requested_colour)
try:
closest_name = webcolors.rgb_to_name(new, spec='html4')
except ValueError:
closest_name = closest_colour(requested_colour)
return closest_name
def get_colour_name(requested_colour):
try:
closest_name = actual_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = closest_colour(requested_colour)
actual_name = None
return actual_name, closest_name
def _format_color(self, rgb_value, color_format: str):
"""
Get the correct color format as specified
:return:
"""
if color_format == "hsv":
# list(np.around(v))
return str(mcolors.rgb_to_hsv(rgb_value).tolist())
elif color_format == "hex":
rgb_value = np.divide(rgb_value, 255) # give a scale from 0-1
return mcolors.to_hex(rgb_value)
elif color_format == "human_readable":
r0, g0, b0 = int(rgb_value[0]), int(rgb_value[1]), int(
rgb_value[2])
try:
nearest = webcolors.rgb_to_name((r0, g0, b0))
except ValueError: # Calculate distances between rgb value and CSS3 rgb colours to determine the closest
distances = {}
for k, v in webcolors.CSS3_HEX_TO_NAMES.items():
r1, g1, b1 = webcolors.hex_to_rgb(k)
distances[(
(r0 - r1)**2 + (g0 - g1)**2 + (b0 - b1)**
2)] = v # Ignore sqrt as it has no significant effect
nearest = distances[min(distances.keys())]
return nearest
def get_color_name(requested_color):
"""Get the exact or closest color name of an 8 bit RGB tuple."""
try:
color_name = webcolors.rgb_to_name(requested_color)
except ValueError:
color_name = closest_color(requested_color)
return color_name
def get_colour_name(requested_colour):
try:
actual_name = webcolors.rgb_to_name(requested_colour)
return actual_name
except ValueError:
closest_name = closest_colour(requested_colour)
return closest_name
def get_name(cls, value):
try:
closest_name = actual_name = webcolors.rgb_to_name(value)
except ValueError:
closest_name = cls.closest_color(value)
actual_name = None
return actual_name, closest_name
def getColorName(requestedColor):
try:
closestName = actualName = webcolors.rgb_to_name(requestedColor)
except ValueError:
closestName = closestColor(requestedColor)
actualName = None
return actualName, closestName
def get_colour_name(self):
try:
closest_name = actual_name = webcolors.rgb_to_name(self.rgb)
except ValueError:
closest_name = self.closest_colour()
actual_name = None
return actual_name, closest_name
def get_color(color):
try:
closest_name = actual_name = webcolors.rgb_to_name(color)
except:
closest_name = closest_color(color)
actual_name = None
return actual_name, closest_name
def color_naming(center):
try:
actual_color=webcolors.rgb_to_name(tuple(center))
color_names=str(actual_color)
except ValueError:
d={}
for (key,name_color) in webcolors.css3_hex_to_names.items():
r_w,g_w,b_w=webcolors.hex_to_rgb(key)
r,g,b=(int(center[0]),int(center[1]),int(center[2]))
#calculates hsv values
lib_lab=np.uint8(np.asarray([[list((r_w,g_w,b_w))]]))
lib_lab=cv2.cvtColor(lib_lab,cv2.COLOR_RGB2Lab)
given_lab=np.uint8(np.asarray([[list((r,g,b))]]))
given_lab=cv2.cvtColor(given_lab,cv2.COLOR_RGB2Lab)
#Extracting individual l,a,b values
r_w,g_w,b_w=((lib_lab[0][0])[0],(lib_lab[0][0])[1],(lib_lab[0][0])[2])
r,g,b=((given_lab[0][0])[0],(given_lab[0][0])[1],(given_lab[0][0])[2])
#r,g,b=colorsys.rgb_to_hsv(center[0]/255.0,center[1]/255.0,center[2]/255.0)
#calculate mean squared error
#r=(int(r_w)-int(r))**2
g=(int(g_w)-int(g))**2
b=(int(b_w)-int(b))**2
d[r+g+b]=name_color
#print(d)
color_names=d[min(d.keys())]
return color_names
def get_color(color):
try:
closestname = actualname = webcolors.rgb_to_name(color)
except ValueError:
closestname = closest_colors(color)
actualname = None
return actualname, closestname
def get_colour_name(requested_colour):
try:
colour_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
colour_name = closest_colour(requested_colour)
return colour_name
def get_colour_name(self):
try:
closest_name = actual_name = webcolors.rgb_to_name(self.rgb)
except ValueError:
closest_name = self.closest_colour()
actual_name = None
return actual_name, closest_name
def detect_properties(self, path):
"""Detects image properties in the file."""
from google.cloud import vision
client = vision.ImageAnnotatorClient()
with io.open(path, 'rb') as image_file:
content = image_file.read()
image = vision.types.Image(content=content)
response = client.image_properties(image=image)
props = response.image_properties_annotation
#print('Properties:')
for color in props.dominant_colors.colors:
#print('fraction: {}'.format(color.pixel_fraction))
#print('\tr: {}'.format(color.color.red))
#print('\tg: {}'.format(color.color.green))
#print('\tb: {}'.format(color.color.blue))
#print('\ta: {}'.format(color.color.alpha))
try:
closest_name = actual_name = webcolors.rgb_to_name(
(int(color.color.red), int(
color.color.green), int(color.color.blue)),
spec=u'html4')
actual_name = self.get_basic_colors(actual_name)
self.colors.append(actual_name)
except ValueError:
closest_name = self.closest_colour(
(int(color.color.red), int(color.color.green),
int(color.color.blue)))
closest_name = self.get_basic_colors(closest_name)
self.colors.append(closest_name)
return self.colors
def getColorName(self, pixel):
try:
closest_name = actual_name = webcolors.rgb_to_name(pixel)
except ValueError:
closest_name = self.closestColor(pixel)
actual_name = None
return actual_name, closest_name
def get_colour_name(requested_colour):
"""Outputs closest english color name to input RGB"""
try:
closest_name = actual_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = closest_colour(requested_colour)
actual_name = None
return actual_name, closest_name
def get_color_name(requested_color):
""" Renvoyer le nom de la couleur CSS la plus proche """
try:
closest_name = actual_name = webcolors.rgb_to_name(requested_color)
except ValueError:
closest_name = closest_color(requested_color)
actual_name = None
return actual_name or "≈{}".format(closest_name)
def get_colour_name(requested_colour):
try:
closest_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = closest_colour(requested_colour)
print "Color name not found for", requested_colour, ". Closest found: ", closest_name
return closest_name
def get_colour_name(requested_colour):
"""Given tuple (r,g,b) returns nearest CSS 2.1 color name"""
try:
actual_name = webcolors.rgb_to_name(requested_colour, spec="css21")
return actual_name
except ValueError:
closest_name = closest_colour(requested_colour)
return closest_name
def get_colour_name(self,requested_colour):
try:
closest_name = actual_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = self.closest_colour(requested_colour)
actual_name = None
# print("get_colour_name")
return actual_name, closest_name
def get_colour_name(requested_colour):
try:
closest_name = actual_name = wb.rgb_to_name(requested_colour,
spec=u'html4')
except ValueError:
closest_name = closest_colour(requested_colour)
actual_name = None
return actual_name, closest_name
def get_colour_name(requested_colour):
"""Given tuple (r,g,b) returns nearest CSS 2.1 color name"""
try:
actual_name = webcolors.rgb_to_name(requested_colour,spec='css21')
return actual_name
except ValueError:
closest_name = closest_colour(requested_colour)
return closest_name
def get_colour_name(dominant_color):
try:
actual_name = webcolors.rgb_to_name(dominant_color, spec='css3')
closest_name = None
except ValueError:
closest_name = closest_colour(dominant_color)
actual_name = None
return actual_name, closest_name
def color_tuple_to_string(rgb): # try to convert to an english name try: return webcolors.rgb_to_name(rgb) except Exception as e: #print e pass return str(rgb)
def get_colour_name(self, requested_colour):
""" get a name match for the closest colour"""
try:
closest_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = self.closest_colour(requested_colour)
return closest_name
def rgb_to_css_color(rgb):
# rgb to css color uses webcolor to see if there is a named
# css color equivilent to the rgb color passed in, and if not
# returns a string in the form "rgb(1,2,3)"
try:
return webcolors.rgb_to_name(rgb)
except ValueError:
return "rgb" + str(rgb)
def color_tuple_to_string(rgb): # try to convert to an english name try: return webcolors.rgb_to_name(rgb) except Exception as e: #print e pass return str(rgb)
def get_colour_name(requested_colour):
requested_colour = [int(s) for s in requested_colour]
#print("$$$$$$$$$",requested_colour)
try:
closest_name = actual_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = closest_colour(requested_colour)
actual_name = None
return closest_name
def test_rgb_to_name(self):
"""
Test conversion from integer RGB triplet to color name.
"""
test_pairs = (((255, 255, 255), u'white'), ((0, 0, 128), u'navy'),
((218, 165, 32), u'goldenrod'))
for triplet, name in test_pairs:
self.assertEqual(name, webcolors.rgb_to_name(triplet))
def get_color_name(requested_color):
''' Get the name of a color (either according to CSS3 or CSS2.1). If exact color cannot be mapped, this method finds the closest color. '''
try:
closest_name = actual_name = webcolors.rgb_to_name(requested_color)
except ValueError:
closest_name = closest_color(requested_color)
actual_name = None
return closest_name
def get_colour_name(requested_colour):
try:
closest_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
try:
closest_name = closest_colour(requested_colour)
except:
closest_name = np.nan
return closest_name
def get_colour_name(requested_colour):
"""
Return the name of the color
"""
try:
closest_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = closest_colour(requested_colour)
return closest_name
def get_colour_name(rgb):
requested_colour = (rgb.r, rgb.g, rgb.b)
hex_code = rgb2hex(rgb.r, rgb.g, rgb.b)
try:
closest_name = actual_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = closest_colour(requested_colour)
actual_name = None
return actual_name, closest_name, hex_code
def get_colour_name(requested_colour):
"""
docstring
"""
try:
closest_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
closest_name = closest_colour(requested_colour)
return closest_name
def get_color_name(requested_color):
''' Get the name of a color (either according to CSS3 or CSS2.1). If exact color cannot be mapped, this method finds the closest color. '''
try:
closest_name = actual_name = webcolors.rgb_to_name(requested_color)
except ValueError:
closest_name = closest_color(requested_color)
actual_name = None
return closest_name
def get_colour_name(requested_colour):
try:
#print("We are trying")
closest_name = actual_name = webcolors.rgb_to_name(requested_colour)
except ValueError:
#print("We are in the exception")
closest_name = closest_colour(requested_colour)
# print(closest_name)
actual_name = None
return actual_name, closest_name
def get_colour_name(colour):
'''Translate given RGB colour into it's name.
If name cannot be found, return closest known colour.
'''
try:
name = webcolors.rgb_to_name(colour)
except ValueError:
name = get_closest_colour(colour)
return name
def get_colour_name(requested_colour): ''' function that finds the colour that matches input RGB code. If no matching colour is found, call function closest_colour ''' try: closest_name = actual_name = webcolors.rgb_to_name(requested_colour) except ValueError: closest_name = closest_colour(requested_colour) actual_name = None return actual_name, closest_name
def test_rgb_to_name(self):
"""
Test conversion from integer RGB triplet to color name.
"""
test_pairs = (((255, 255, 255), u'white'),
((0, 0, 128), u'navy'),
((218, 165, 32), u'goldenrod'))
for triplet, name in test_pairs:
self.assertEqual(name,
webcolors.rgb_to_name(triplet))
def _get_color_names(array):
"""Use webcolors to get the closest named color for rgb values"""
import webcolors as wb
array = np.atleast_2d(array)
color_names = []
for rgb in array:
try:
i_name = wb.rgb_to_name(rgb)
except ValueError:
i_name = _closest_color_from_rgb(rgb)
color_names.append(i_name)
return color_names
def paint_picture(x, y):
while y < self.img.size[1]:
pixel = pixor[x,y]
color = webcolors.rgb_to_name(pixel)
space = get_space(x,y, color)
string = check_fit(space, color)
drawn = self.texter.render(string, True, pixel)
self.synpic.blit(drawn, (x * letWidth, y * letHeight))
x += (len(string))
if x >= self.img.size[0]:
y += 1
x = 0
def BGRname(bgrcolor):
print "rgb = ", bgrcolor[2], bgrcolor[1], bgrcolor[0]
try:
closest_name = webcolors.rgb_to_name((bgrcolor[2], bgrcolor[1], bgrcolor[0]))
except ValueError:
min_colors = {}
for key, name in webcolors.css21_hex_to_names.items():
r_c, g_c, b_c = webcolors.hex_to_rgb(key)
bd = (b_c - bgrcolor[0]) ** 2
gd = (g_c - bgrcolor[1]) ** 2
rd = (r_c - bgrcolor[2]) ** 2
min_colors[(rd + gd + bd)] = name
closest_name = min_colors[min(min_colors.keys())]
return closest_name
def test_rgb_to_name_specs(self):
"""
Using one of the supported specifications succeeds; an
unsupported specification raises ValueError.
"""
for supported_spec in (u'html4', u'css2', u'css21', u'css3'):
self.assertEqual(u'white',
webcolors.rgb_to_name((255, 255, 255),
spec=supported_spec))
for unsupported_spec in (u'css1', u'css4', u'html5'):
self.assertRaises(ValueError,
webcolors.rgb_to_name,
(255, 255, 255), spec=unsupported_spec)
def get_closest(hex):
rgb = webcolors.hex_to_rgb(hex)
try:
closest_name = actual_name = webcolors.rgb_to_name(rgb)
except ValueError:
closest_name = closest_colour(rgb)
actual_name = None
if actual_name:
actual = webcolors.name_to_hex(actual_name)
else:
actual = None
closest = webcolors.name_to_hex(closest_name)
return actual, closest
def test_rgb_to_name_specs(self):
"""
Using one of the supported specifications succeeds; an
unsupported specification raises ValueError.
"""
for supported_spec in webcolors.SUPPORTED_SPECIFICATIONS:
result = webcolors.rgb_to_name(
(255, 255, 255), spec=supported_spec
)
assert u'white' == result
for unsupported_spec in (u'css1', u'css4', u'html5'):
self.assertRaises(
ValueError,
webcolors.rgb_to_name,
(255, 255, 255),
spec=unsupported_spec
)
def get_space(x,y, color):
x1 = x
while x < self.img.size[0] and webcolors.rgb_to_name(pixor[x,y]) is color:
x += 1
return x - x1
def loop():
#img=s.Image(r"C:\Users\Abhas_2\Desktop\untitled.png").scale(.25)
img=cam.getImage()
#clock1=time.clock()
#print("0: "+str(1/(time.clock()-clock1)))
img2=img.toGray()
#print("1: "+str(1/(time.clock()-clock1)))
img_black=img2.stretch(50,50)
#img_black=img2.threshold(10)
#print("2: "+str(1/(time.clock()-clock1)))
bot_blobs=img_black.invert().findBlobs()
if bot_blobs:
bot=bot_blobs[-1:][0]
#print("3: "+str(1/(time.clock()-clock1)))
bot_hole=(img2.crop(bot)-bot.hullMask().invert()).morphOpen()
#print("4: "+str(1/(time.clock()-clock1)))
hole_blobs=bot_hole.findBlobs()
if hole_blobs:
hole=hole_blobs[-1:][0]
hole_center=[bot.topLeftCorner()[0]+hole.x, bot.topLeftCorner()[1]+hole.y]
#print("5: "+str(1/(time.clock()-clock1)))
bot_center=bot.centroid()
bot_radius=bot.radius()
bot_angle=ball_angle=degrees(atan2(-(hole_center[1]-bot_center[1]),hole_center[0]-bot_center[0]))
img3=(img2-img)+(img-img2)
#img3.show()
#f[0].show()
#print("6: "+str(1/(time.clock()-clock1)))
img_=img-img3.threshold(5).invert()
#print("7: "+str(1/(time.clock()-clock1)))
f=img_.findBlobs()
#print("8: "+str(1/(time.clock()-clock1)))
if f:
f=f[-1:]
c_match=f[0].meanColor()
ball_centre=[f[0].x,f[0].y]
ball_angle=degrees(atan2(-(ball_centre[1]-bot_center[1]),ball_centre[0]-bot_center[0]))
#print(ball_angle)
img.drawLine(ball_centre,bot_center,s.Color.YELLOW,5)
#img_.drawLine(bot_center,[bot_center[0]+cos(radians( bot_angle))*bot_radius,bot_center[1]-sin(radians(bot_angle))*bot_radius],s.Color.BLUE,5)
#img_.show()
#c=f[0].centroid()
#out=img_.crop(c[0],c[1],f[0].width(),f[0].height(),True)
#img_in=out.crop(out.width/2,out.height/2,out.width/sqrt(2),out.height/sqrt(2),True)
#c_match=img_in.toRGB().meanColor()
#print(c_match)
c_match=s.Color.getHueFromRGB(c_match)
#print(c_match)
least=255*3
color=None
list_check=s.Color.colorlist
#list_check=[s.Color.getHueFromRGB(s.Color.YELLOW),s.Color.getHueFromRGB(s.Color.RED),s.Color.getHueFromRGB(s.Color.BLUE),s.Color.getHueFromRGB(s.Color.GREEN),s.Color.getHueFromRGB(s.Color.HOTPINK)]
for c in list_check:
c_=s.Color.getHueFromRGB(c)
diff=abs(c_match-c_)
if diff<least:
#print(diff)
#print(c_)
color=c_
least=diff
#print(color)
color=s.Color.hueToRGB(color)
#print(color)
color_name=w.rgb_to_name(color)
#print(color_name)
#print("9: "+str(1/(time.clock()-clock1)))
img.drawLine([bot.x,bot.y],hole_center,s.Color.AQUAMARINE,thickness=5)
#minimum angle between ball_angle and bot_angle
# returns positive angle for anti-clockwise rotation and else negative angle
diff_angle = ball_angle-bot_angle
diff_angle = (diff_angle + 180) % 360 - 180
print(diff_angle)
#send_signal(diff_angle)
#print("10: "+str(1/(time.clock()-clock1)))
img.show()
def rgb_to_name_or_hex(rgb):
try:
return webcolors.rgb_to_name(rgb)
except ValueError as e:
pass
return webcolors.rgb_to_hex(rgb)
def convert_color(bgr):
try:
b, g, r = bgr
return webcolors.rgb_to_name((r, g, b))
except ValueError:
return closest_color(bgr)
def get_colour_name(rgb, palette="css3"):
try:
colorname = rgb_to_name(rgb, spec=palette)
return colorname
except:
return "Undefined"
