def draw_box(self, bbox, image):
out_boxes, out_scores, out_classes, num_boxes = bbox
print(num_boxes)
image_h, image_w, _ = image.shape
classes = util.read_class_names(
"./tensorflow-yolov4-tflite/data/classes/coco.names")
num_classes = len(classes)
hsv_tuples = [(1.0 * x / num_classes, 1., 1.)
for x in range(num_classes)]
colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
colors))
random.seed(0)
random.shuffle(colors)
random.seed(None)
for i in range(num_boxes):
# if int(out_classes[0][i]) < 0 or int(out_classes[0][i]) > num_classes: continue
coord = out_boxes[i]
score = out_scores[i]
class_ind = int(out_classes[i])
bbox_color = colors[class_ind]
bbox_thick = int(0.6 * (image_h + image_w) / 600)
bbox_mess = '%s: %.2f' % (classes[class_ind], score)
# print([coord[1], coord[0], coord[3], coord[2]])
self.canvas.create_rectangle(coord[0],
coord[1],
coord[2],
coord[3],
width=bbox_thick,
outline=util.rgb_to_hex(bbox_color))
self.draw_text(bbox_mess, [coord[0], coord[1], coord[2], coord[3]])
self.canvas.pack()
def _plot_gradient(self):
"""display the light dark domain."""
xmin, xmax = self._x_range
ymin, ymax = self._y_range
# Note that higher brightness has lower brightness value
hi_brightness = self._env.const
lo_brightness = max(
0.5 * (self._env.light - xmin)**2 + self._env.const,
0.5 * (self._env.light - xmax)**2 + self._env.const)
# Plot a bunch of rectangular strips along the x axis
# Check out: https://stackoverflow.com/questions/10550477
x = xmin
verts = []
colors = []
while x < xmax:
x_next = x + self._res
verts.append([(x, ymin), (x_next, ymin), (x_next, ymax),
(x, ymax)])
# compute brightness based on equation in the paper
brightness = 0.5 * (self._env.light - x)**2 + self._env.const
# map brightness to a grayscale color
grayscale = int(
round(
util.remap(brightness, hi_brightness, lo_brightness, 255,
0)))
grayscale_hex = util.rgb_to_hex((grayscale, grayscale, grayscale))
colors.append(grayscale_hex)
x = x_next
util.plot_polygons(verts, colors, ax=self._ax)
self._ax.set_xlim(xmin, xmax)
self._ax.set_ylim(ymin, ymax)
def main():
if len(sys.argv) != 4:
print('Usage: python search_color.py <r> <g> <b>')
return 1
color = list(map(int, sys.argv[1:4]))
print('Searching for {} - {}'.format(color, rgb_to_hex(color)))
for url, count in search_color(color).items():
print(url, count)
return 0
def update_color(self):
color = np.array([0, 0, 0])
for species_id, species_pheromones in enumerate(self.pheromones):
color += self.world.species[species_id].inv_color * \
len(species_pheromones)
color = np.clip(np.around(color / 100), 0, 255)
color = np.array([255 - val for val in color])
self.world.canvas.itemconfig(
self.canvas_id, fill=rgb_to_hex(color))
def update_color(self):
"""
Fonction qui met a jour la couleur de la cellule sur le canvas
"""
color = np.array([0, 0, 0])
for species_id, species_pheromones in enumerate(self.pheromones):
# intensifie la couleur en fonction du nombre de pheromones sur la
# case
color += self.world.species[species_id].inv_color * \
len(species_pheromones)
# couleur inversee (noir vers couleur inversee de l espece)
color = np.clip(np.around(color / 100), 0, 255)
# on reinverse la couleur( blanc vers couleur de l espece)
color = np.array([255 - val for val in color])
# on met a jour la couleur de la case
self.world.canvas.itemconfig(self.canvas_id, fill=rgb_to_hex(color))
def __init__(self, world, nest_id, x, y, species_id, nAnts):
self.world = world
self.pos = np.array([x, y])
self.species_id = species_id
self.scale = nAnts / 2
self.size = nAnts
self.nest_id = nest_id
self.food = 0
species = self.world.species[species_id]
species.set_active()
self.color = species.color
hex_color = rgb_to_hex(self.color)
self.canvas_id = create_circle(self.world.canvas, x, y, self.scale,
hex_color)
self.ants = [Ant(self.world, self, i, hex_color) for i in range(nAnts)]
def index(request, city=None, year=None, temperature_config=None):
'''
Renders the index page of the scarf application, which is the page that allows you to
define a city, year, and temperature / color ranges. This page can take parameters, in which case
it will pre-select options, or it can take no parameters, in which case all of the defaults
will be used.
Keyword Arguments:
city -> String. Name of a city. Can contain alphanumeric as well as ()., and <space>. Default None.
year -> String. Must match '^\d{4}$'. Default None.
temperature_config -> String. An alternating, '/' delimited list of colors and temperatures. See
scarf.util.parse_scarf_config for more information. Default None.
'''
# Define the object that we will pass to the templating engine. The contents of this will change depending on specifics
# of the request parameters and such.
template_dict = {}
# We always need the list of cities and years for populating selects..
template_dict['cities'] = map(lambda x: x.city, sorted(City.objects.all(), key=lambda x: x.city))
template_dict['years'] = range(DATA_START_YEAR, datetime.now().year + 1)[::-1]
# The template also always needs this information. Minimum and maximum number of colors, the factor to darken hex
# by (for the JS clientside darken function), the two classes for white and black text (for dynamic class switching
# in the client), the max and min valid temperature, and the golden ratio conjugate (for JS client-side random color
# generation).
template_dict['min_colors'] = MIN_COLORS
template_dict['max_colors'] = MAX_COLORS
template_dict['darken_factor'] = COLOR_DARKEN_FACTOR
template_dict['text_color_class_white'] = TCC_WHITE
template_dict['text_color_class_black'] = TCC_BLACK
template_dict['max_temperature'] = MAX_TEMPERATURE
template_dict['min_temperature'] = MIN_TEMPERATURE
template_dict['golden_ratio_conjugate'] = GOLDEN_RATIO_CONJUGATE
# Now, check for the presence of a city or year parameter in the request. If they do not exist, we will dummy
# them in as the first entry in the cities list and the first entry in the year list. We do this prior to parsing
# since these values are required.
if city == '' or city is None:
city = template_dict['cities'][0]
if year is None:
year = template_dict['years'][0]
template_dict['city_selected'] = city
try:
year = int(year)
except ValueError:
year = template_dict['years'][0]
template_dict['year_selected'] = year
# Now we will attempt to parse the passed parameters (with our bit of city / year magic included). If the parse succeeds,
# we can use the data we found. If it doesn't, we have to fake the colors and temperatures.
try:
city, year, colors, labels, temperatures = parse_scarf_config(city, year, temperature_config)
except ScarfConfigError:
# If we caught an error, the problem has to be in the temperature_config variable, because
# we forced city and year to be valid values prior to calling the parse_scarf_config routine.
# Therefore, we will now generate fake colors and temperatures to initially populate everything.
if temperature_config is not None:
template_dict['message'] = ('warning', 'Hey!', 'Something wasn\'t quite right with your request, and we weren\'t able to load your color or temperature selections. Please try again.')
colors = []
labels = []
h = random.random()
for _ in itertools.repeat(None, DEFAULT_NUM_COLORS):
h += GOLDEN_RATIO_CONJUGATE
h %= 1
new_color = hsv_to_rgb(h, HSV_S, HSV_V)
colors.append(rgb_to_hex(map(lambda x: int(x * 255), new_color)))
labels.append(None)
temperatures = map(lambda x: DEFAULT_COLDEST_TEMP + x* DEFAULT_COLOR_INTERVAL, range(0, DEFAULT_NUM_COLORS - 1))
# At this point, the color and temperature variables contain either the data from the request, or
# demonstration data that we have mocked up. Populate the darkened colors and the position list,
# and then render the template.
colors_dark = [darken_hex(color, COLOR_DARKEN_FACTOR) for color in colors]
text_color_classes = [get_text_color_class(color) for color in colors]
temperature_positions = [(100.0 / len(colors)) * x for x in range(1, len(temperatures) + 1)]
template_dict['colors'] = zip(colors, colors_dark, labels, text_color_classes)
template_dict['temps'] = zip(temperatures, temperature_positions)
template_dict['color_length'] = 100.0 / len(colors)
# Put it all together and render the template.
return render_to_response(TEMPLATE_INDEX,
template_dict,
context_instance = RequestContext(request))
