def generate(self, phrase):
phrase_length = len(phrase)
# chars per color
cpc = ceil(phrase_length / self.color_count)
color_start = Color(self.start_color)
color_end = Color(self.end_color)
rainbow = list(color_start.range_to(color_end, self.color_count))
characters = list(phrase)
characters.reverse()
s = ''
for color in rainbow:
s += self.template['tag_open_before'] + color.hex + self.template['tag_open_after']
i = 0
while i < cpc and len(characters) > 0:
next_char = characters.pop()
s += next_char
i += 1
s += self.template['tag_close']
if len(characters) < 1:
break
return s
def build_sunburst(sequences):
from djangophylocore.models import TaxonomyReference
import networkx as nx
from networkx.readwrite import json_graph
scores = sequences.values_list("score", flat=True)
scores_min = min(scores) if scores else 0
scores_max = max(scores) if scores else 100
green = Color("#66c2a5")
red = Color("#fc8d62")
color_range = list(red.range_to(green, 100))
def get_color_for_taxa(taxon):
avg_score = taxon.children.filter(sequence__all_model_scores__used_for_classification=True).aggregate(score=Avg("sequence__all_model_scores__score"))["score"]
avg_score = avg_score if avg_score else scores_min
scaled = int(floor((float(avg_score-scores_min)/float(scores_max-scores_min))*100))
color_index = scaled if scaled <= 99 else 99
color_index = color_index if color_index >= 0 else 0
return str(color_range[color_index])
taxa = list(sequences.values_list("taxonomy__parent__parent__parent", flat=True).distinct())
allow_ranks = ["kingdom", "phylum", "order"]
tree = TaxonomyReference().get_filtered_reference_graph(taxa, allow_ranks=allow_ranks)
nx.set_node_attributes(tree, "colour", {n:get_color_for_taxa(Taxonomy.objects.get(name=n)) for n,d in tree.out_degree_iter() if d==0})
return json_graph.tree_data(tree, "root", attrs={'children': 'children', 'id': 'name'})
def search(request):
data = {"filter_form": AdvancedFilterForm()}
if request.method == "POST":
query = request.POST.copy()
else:
query = request.GET.copy()
result = HistoneSearch(query, navbar="search" in query.keys())
data["original_query"] = query
if len(result.errors) == 0:
data["result"] = True
else:
data["filter_errors"] = result.errors
if result.redirect:
return result.redirect
green = Color("#66c2a5")
red = Color("#fc8d62")
data["colors"] = map(str, red.range_to(green, 12))
data["score_min"], data["score_max"] = result.get_score_range()
return render(request, 'search.html', data)
def generate_tag_list(self):
memos = self.memos
if len(memos) <= 0:
return []
countHash = {}
for memo in memos:
tags = memo.tag.split(',')
for tag in tags:
s = tag.strip()
if countHash.has_key(s):
countHash[s] += 1
else:
countHash[s] = 1
tag_list = []
s = Color('#d16b16')
e = Color('#87ceed')
l = len(countHash) if len(countHash) > 1 else 2
color_list = list(s.range_to(e, l))
color_cnt = 0
max_val = max(countHash.values())
for key, val in sorted(countHash.items(),
key=lambda x:x[1],
reverse=True):
tag_dic = {}
tag_dic['name'] = key
tag_dic['size'] = (val / max_val) * 100
tag_dic['num'] = val
tag_dic['color'] = color_list[color_cnt]
color_cnt += 1
tag_list.append(tag_dic)
return tag_list
def plot_window_distribution_pie_chart(self):
"""
Plots a pie chart of how the windows used in the session.
"""
# Get data
win_distrib = self.get_time_by_active_window()
del win_distrib['total']
keys = win_distrib.keys()
values = win_distrib.values()
# Pick colors
start_color = Color("#CCE5FF")
colors = map(convert_to_hex, list(start_color.range_to(Color("#003366"), len(keys))))
# Plot pie chart
fig, ax = plt.subplots(figsize=(12,8))
ax.pie(values,
autopct='%1.0f%%',
pctdistance=1.1,
labeldistance=0.5,
shadow=True,
startangle=10,
colors=colors)
ax.set_title("Pie chart: Time spent by window")
plt.legend(keys, loc="best",shadow=True)
plt.show()
def pymodoro_main(self, i3s_output_list, i3s_config):
# Don't pass any arguments to pymodoro to avoid conflicts with
# py3status arguments
save_argv = sys.argv
sys.argv = [sys.argv[0]]
pymodoro = Pymodoro()
pymodoro.update_state()
# Get pymodoro output and remove newline
text = pymodoro.make_output().rstrip()
pymodoro.tick_sound()
# Restore argv
sys.argv = save_argv
try:
# If colour is installed, we will display a nice gradient
# from red to green depending on how many time is left
# in the current pomodoro
from colour import Color
start_c = Color(self.start_color)
end_c = Color(self.end_color)
break_c = Color(self.break_color)
if pymodoro.state == pymodoro.ACTIVE_STATE:
nb_minutes = int(
math.floor(pymodoro.config.session_duration_secs / 60)
)
colors = list(end_c.range_to(start_c, nb_minutes))
seconds_left = pymodoro.get_seconds_left()
if seconds_left is not None:
nb_minutes_left = int(math.floor(seconds_left / 60))
if nb_minutes_left >= len(colors):
nb_minutes_left = len(colors)-1
self.color = colors[nb_minutes_left].hex
else:
self.color = start_c.hex
else:
self.color = break_c.hex
except ImportError:
# If colour is not installed, use the default color
pass
response = {
'full_text': text,
'color': self.color,
# Don't cache anything
'cached_until': time.time()
}
return response
def generate_branding_style_secondary(self):
styles = dict();
if self.has_accent_color:
accent = Color(self.safe_accent_color)
accent.luminance = accent.luminance * 0.9 if accent.luminance * 0.9 >= 0 else 0;
accent.saturation = accent.saturation * 1.1 if accent.saturation * 1.1 <= 1 else 1
styles['background-color'] = accent.hex
return self.css_style(styles);
def generate_colors(num, from_color='#f7aabc', to_color='#404a58'):
"""
Generate `num` distinct Hexadecimal colors
"""
from_color = Color(from_color)
to_color = Color(to_color)
if num == 0:
return []
elif num == 1:
return [from_color.hex]
return list(c.hex for c in from_color.range_to(to_color, num))
def colourChanged(e, oldColour):
if type(e) == str:
return e
elif type(e) == Color:
nc = [e.red * 255, e.green * 255, e.blue * 255]
else:
nc = e.GetColour()
if type(oldColour) is not Color:
oldColour = Color()
oldColour.red = nc[0] / 255
oldColour.green = nc[1] / 255
oldColour.blue = nc[2] / 255
return oldColour
def color_byte_array(color_value):
"""
convert color into a 3 byte bytearray
:param color_value: 6-digit (e.g. #fa3b2c), 3-digit (e.g. #fbb),
fully spelled color (e.g. white)
"""
color = Color(color_value)
return bytearray([
int(round(color.get_red()*255)),
int(round(color.get_green()*255)),
int(round(color.get_blue()*255)),
])
def colors(items):
"""Create a generator which returns colors for each item in ``items``.
:param list items: The list to generate colors for.
:rtype: generator(`colour.Color <https://pypi.python.org/pypi/colour>`_)
"""
if len(items) < 2:
c = (c for c in (Color("red"),))
else:
color_from = Color("red")
color_to = Color("green")
c = (color_from.range_to(color_to, len(items)))
return c
def poster():
# randon backgorund color
rand_rgb = tuple([(randrange(97, 160) / 255.0) for i in range(3)])
bg = Color(rgb=rand_rgb)
# get foreground
fg = Color(bg.hex)
variation = randrange(15, 60)
fg.hue = choice([variation, variation * -1])
# random alpha
alpha = randrange(4, 7) / 10.0
# create image
svg = render_template('poster.svg', bg=bg.hex, fg=fg.hex, alpha=alpha)
return Response(svg2png(bytestring=svg), mimetype='image/png')
def get_rainbow(self, phrase):
phrase_length = len(phrase)
# chars per color
cpc = ceil(phrase_length / self.color_count)
color_start = Color(self.start_color)
color_end = Color(self.end_color)
rainbow = list(color_start.range_to(color_end, self.color_count))
self.rainbow = rainbow
self.cpc = cpc
# self.index = next(rainbow)
self.index = 0
return {'rainbow': rainbow, 'cpc': cpc}
def generate_background(self):
hue_offset = promap(int(self.hash[14:][:3], 16), 0, 4095, 0, 359)
sat_offset = int(self.hash[17:][:1], 16)
base_color = Color(hsl=(0, .42, .41))
base_color.hue = base_color.hue - hue_offset
if sat_offset % 2:
base_color.saturation = base_color.saturation + sat_offset / 100
else:
base_color.saturation = base_color.saturation - sat_offset / 100
rgb = base_color.rgb
r = int(round(rgb[0] * 255))
g = int(round(rgb[1] * 255))
b = int(round(rgb[2] * 255))
return self.svg.rect(0, 0, '100%', '100%', **{
'fill': 'rgb({}, {}, {})'.format(r, g, b)
})
def color(self, steps=100):
"""
Get a green -> red scoring color.
Args:
steps (int): The number of gradient steps.
Returns:
str: A hex color.
"""
r = Color('#f02424')
g = Color('#29b730')
gradient = list(r.range_to(g, steps))
idx = round(self.field('score')*(steps-1))
return gradient[idx].get_hex()
def _visualize_beacon(self, data, beacon):
if beacon == self.LEFT_BEACON:
prefix = 'left_'
else:
prefix = 'right_'
if not self.is_active_on_spectrum(data, prefix):
return self.layout.set_beacon(beacon, self.layout._off)
color = Color(rgb=self.container.get_conf(prefix + 'color'))
color.luminance = self.container.get_conf(prefix + 'lum') / 100.0
if self.config[beacon]['Luminance'] == 'Beat':
color = self.beat_lum(data, color, prefix, beacon)
elif self.config[beacon]['Luminance'] == 'Energy':
color = self.energy_lum(data, color, prefix, beacon)
elif self.config[beacon]['Luminance'] == 'Onset':
color = self.onset_lum(data, color, prefix, beacon)
if self.config[beacon]['Color'] == 'Beat':
color = self.beat_color(data, color, prefix, beacon)
elif self.config[beacon]['Color'] == 'Energy':
color = self.energy_color(data, color, prefix, beacon)
elif self.config[beacon]['Color'] == 'Onset':
color = self.onset_color(data, color, prefix, beacon)
if self.config[beacon]['Side'] == 'Beat':
self.beat_side(data, color, prefix, beacon)
elif self.config[beacon]['Side'] == 'Energy':
self.energy_side(data, color, prefix, beacon)
elif self.config[beacon]['Side'] == 'Onset':
self.onset_side(data, color, prefix, beacon)
elif self.config[beacon]['Row'] == 'Beat':
self.beat_row(data, color, prefix, beacon)
elif self.config[beacon]['Row'] == 'Energy':
self.energy_row(data, color, prefix, beacon)
elif self.config[beacon]['Row'] == 'Energy (R)':
self.energy_row(data, color, prefix, beacon, reverse=True)
elif self.config[beacon]['Row'] == 'Onset':
self.onset_row(data, color, prefix, beacon)
else:
self.layout.set_beacon(beacon, color)
def add_points(self, points, rgbs = None, color = None):
"""
points must be a Nx3 numpy array, as must rgbs if it is not None
"""
if not isinstance(points, np.ndarray):
points = np.array(points)
num_new_points = points.shape[0]
self.points = np.append(self.points, points, axis = 0)
if rgbs is None:
color = Color(color) if color else self.color
rgbs = np.array([color.get_rgb()] * num_new_points)
elif rgbs.shape != points.shape:
raise Exception("points and rgbs must have same shape")
self.rgbs = np.append(self.rgbs, rgbs, axis = 0)
if self.has_normals:
self.unit_normals = np.append(
self.unit_normals,
np.apply_along_axis(self.unit_normal, 1, points),
axis = 0
)
return self
def browse_variant(request, histone_type, variant):
try:
variant = Variant.objects.get(id=variant)
except:
return "404"
green = Color("#66c2a5")
red = Color("#fc8d62")
color_range = map(str, red.range_to(green, 12))
scores = Sequence.objects.filter(variant__id=variant).filter(all_model_scores__used_for_classifiation=True).annotate(score=Max("all_model_scores__score")).aggregate(max=Max("score"), min=Min("score"))
data = {
"core_type": variant.core_type.id,
"variant": variant.id,
"name": variant.id,
"sunburst_url": "browse/sunbursts/{}/{}.json".format(variant.core_type.id, variant.id),
"seed_file":"browse/seeds/{}/{}".format(variant.core_type.id, variant.id),
"colors":color_range,
"score_min":scores["min"],
"score_max":scores["max"],
"browse_section": "variant",
"description": variant.description,
"filter_form": AdvancedFilterForm(),
}
original_query = {"id_variant":variant.id}
if request.method == "POST":
query = request.POST.copy()
else:
query = original_query
result = HistoneSearch(request, query, reset=True)
data["original_query"] = original_query
if result.errors:
query = original_query
data["filter_errors"] = result.errors
data["current_query"] = query
return render(request, 'browse_variant.html', data)
def add_points(self, points, rgbs = None, color = None):
"""
points must be a Nx3 numpy array, as must rgbs if it is not None
"""
points = np.array(points)
num_new_points = points.shape[0]
self.points = np.append(self.points, points)
self.points = self.points.reshape((self.points.size / 3, 3))
if rgbs is None:
color = Color(color) if color else self.color
rgbs = np.array([color.get_rgb()] * num_new_points)
else:
if rgbs.shape != points.shape:
raise Exception("points and rgbs must have same shape")
self.rgbs = np.append(self.rgbs, rgbs)
self.rgbs = self.rgbs.reshape((self.rgbs.size / 3, 3))
if self.has_normals:
self.unit_normals = np.append(
self.unit_normals,
np.array([self.unit_normal(point) for point in points])
).reshape(self.points.shape)
return self
def add_line(self, x, y, name='plot', xerr=None, yerr=None, linewidth=0.5,
linestyle=None, linecolor='black', legend=True, axes=None):
if axes is None:
axes = self.ax
self.plotnum = self.plotnum + 1
if name is 'plot':
name = 'plot%d' % (self.plotnum)
if linestyle is None:
_ls = self.linestyle[self.plotnum % 4]
else:
_ls = linestyle
if xerr is None and yerr is None:
line = axes.plot(x, y, label=name, color=linecolor,
marker=self.marker[self.plotnum % 7],
ls=_ls, lw=linewidth, solid_capstyle='butt',
clip_on=True)
for i in range(0, len(line)):
self.lines[name + '%d' % (i)] = (line[i])
else:
if linecolor == 'black':
ecolor = '#A7A9AC'
else:
col = Color(linecolor)
col.saturation = 0.5
col.luminance = 0.75
ecolor = col.hex
line, caplines, barlinecols = axes.errorbar(x, y, label=name,
color=linecolor,
xerr=xerr,
yerr=yerr,
marker=self.marker[self.plotnum % 7],
ls=_ls,
ecolor=ecolor,
lw=linewidth,
clip_on=True)
self.lines[name] = (line)
self.markers_on()
self.lines_off()
def rgb_color_picker(obj, min_luminance=None, max_luminance=None):
"""Modified version of colour.RGB_color_picker"""
color_value = int.from_bytes(
hashlib.md5(str(obj).encode('utf-8')).digest(),
'little',
) % 0xffffff
color = Color(f'#{color_value:06x}')
if min_luminance and color.get_luminance() < min_luminance:
color.set_luminance(min_luminance)
elif max_luminance and color.get_luminance() > max_luminance:
color.set_luminance(max_luminance)
return color
def iterateoverList(distribution, time, location):
print time
red = Color("red")
blue = Color("blue")
colours = list(red.range_to(blue, 100))
client = MongoClient('localhost', 27017)
db = client.hadoopOuput
collection = db['13082013']
with open(time+".css", "a") as myfile:
for tweet in collection.find({"time": time }):
for i in range(0, 100):
if tweet["type"] == "hourly":
if tweet["location"] in location:
if tweet["score"] < scoreatpercentile(distribution, i):
myfile.write("#"+tweet["location"]+"{fill:"+str(colours[i])+"}\n")
break
print "Exiting"
print ""
def plotGraph(self, g, members, numOfClus):
"""
generating the graph of vertices and edges
:param g: graph file to be plotted
:param members: vector of membership (size = # of SKUs)
:param numOfClus: number of clusters
:return: None
"""
# Setting up the ends of the spectrum
lime = Color("lime")
red = Color("red")
cols = list(red.range_to(lime, numOfClus))
cols = [str(rang).split()[0] for rang in cols]
colDict = dict(zip(range(numOfClus), cols))
print colDict
# [colDict[m] for m in members]
visual_style = {}
visual_style["vertex_size"] = 80
visual_style["vertex_shape"] = "rectangle"
visual_style["vertex_color"] = [colDict[m] for m in members] #[color_dict[gender] for gender in g.vs["gender"]]
visual_style["vertex_label"] = g.vs['name']
visual_style["edge_width"] = [w/10 for w in g.es['weight']] #[1 + 2 * int(is_formal) for is_formal in g.es["is_formal"]]
# visual_style["layout"] = layout
visual_style["bbox"] = (5500, 4000)
# visual_style["margin"] = 120
visual_style["edge_curved"] = False
plot(g, **visual_style).save(fname= 'graphClus_' +
str(self.timeThresh) + '_' +
str(self.jointViewThresh) + '_' +
str(self.pmiPerc) + '_' +
str(self.method) + '_' +
str(self.sg_lambda)) # , target="diagram.svg" layout = layout,
from colour import Color
from flask import url_for
import numpy as np
from flask import Flask
from flask import render_template
from flask import request, redirect, jsonify
from flask_cors import CORS, cross_origin
from collections import OrderedDict
from pprint import pprint
from rule_matching import do_for_sent
from flask_sslify import SSLify
# pip3.6 install -U flask-cors
# pip3.6 install Flask-SSLify
white = Color("white")
yellow_colors = list(white.range_to(Color("yellow"), 101))
yellow_colors = [c.get_hex_l() for c in yellow_colors]
blue_colors = list(white.range_to(Color("blue"), 101))
blue_colors = [c.get_hex_l() for c in blue_colors]
green_colors = list(white.range_to(Color("green"), 101))
green_colors = [c.get_hex_l() for c in green_colors]
app = Flask(__name__)
sslify = SSLify(app)
cors = CORS(app)
app.config['CORS_HEADERS'] = 'Content-Type'
# CORS(app)
@app.route("/")
def get_news():
TODO: make it a chloropleth UK map, (at the moment this would be possible but the number of data points is too large to handle i think)
'''
geoDataLoc = open('wpc.json')
refjson = geoDataLoc.read()
json_data = geojson.loads(refjson)
x=[]
y=[]
location = raw_input('Search your consituency: ').replace(' ','').replace(' ','').lower()
maxValue, minValue = maxminValue('euReferendum.json')
currentVal = float(constitValue(location, 'euReferendum.json'))
colourNo = int(ceil((currentVal/maxValue)*632))
red = Color("red")
white = Color("white")
colouring = list(white.range_to(red, 632))
mapCol= str(colouring[colourNo])
currentValue = constitValue(location, 'euReferendum.json')
nameToCoords={}
for x in range(len(json_data['features'])):
if location == json_data['features'][x]['properties']['PCON13NM'].replace(',','').replace(' ','').lower():
nameToCoords[location]=json_data['features'][x]['geometry']['coordinates']
coords= nameToCoords[location]
x=[i for i,j in coords[0]]
y=[j for i,j in coords[0]]
fig = plt.figure()
ax = fig.gca()
def folium_mappd(idd, idPost=None, limit=0, price_ratio=0.5, radius=5000):
def get_df(idd=idd, distance_radius=5000):
client = pymongo.MongoClient(
"mongodb+srv://thuan:[email protected]/atomic?authSource=admin&replicaSet=atlas-1i0fgy-shard-0&w=majority&readPreference=primary&appname=MongoDB%20Compass&retryWrites=true&ssl=true"
)
db = client.atomicbds
collection = db.data_post3
df = pd.DataFrame(list(collection.find()))
df['id'] = df['id'].astype(int)
df['gglat'] = df['gglat'].astype(float)
df['gglong'] = df['gglong'].astype(float)
df['address_city'] = df['address_city'].astype(float).astype(int)
df['position_street'] = df['position_street'].astype(float).astype(int)
df = df[df['area_cal'].apply(float) > 1.0]
df = df[df["address_city"] == 1] # HCM
idPost = df[df["id"] == int(idd)].iloc[0]
center_latlong = [idPost.gglat, idPost.gglong]
distance_from_center = lambda row: geopy.distance.geodesic(
center_latlong, [row['gglat'], row['gglong']]).m
df['distance_from_center'] = df.apply(distance_from_center, axis=1)
return df[
df.distance_from_center < float(distance_radius)], idd, idPost
data_district = pd.read_csv("district.csv")
labeled = [
595347, 197574, 595347, 728022, 539702, 133762, 595347, 648824, 151611,
585779, 90505, 193579, 90505, 295901, 90505, 316913, 90505, 113096,
614411, 430301, 539702, 405019, 320512, 409878, 652053, 732480, 614411,
63428, 303680, 109919, 303680, 441339, 539702, 80248, 652053, 468045,
299557, 144908, 539702, 536729, 595347, 664312, 614411, 568236, 614411,
398661, 303680, 307731, 435447, 503553, 595347, 622751, 652053, 526136,
652053, 526136, 75320, 430195, 75320, 685946, 151611, 690287, 721528,
288939, 621291, 317757, 539702, 63818, 652053, 309152, 652053, 57550,
652053, 673630, 122845, 596146, 721528, 732288, 577544, 763033, 595347,
508729, 122845, 605561, 320512, 169733, 151611, 717646, 151611, 616848,
621291, 727332, 435447, 724328, 151611, 336802, 303680, 407222, 614411,
305266, 303680, 290332, 621291, 622003, 577544, 169279, 621291, 94057,
299557, 116847, 503553, 47888, 614411, 719986, 539702, 327366, 122845,
294564, 539702, 581740, 75320, 303817, 721528, 643041, 303680, 601918,
614411, 566384, 503553, 655052, 614411, 617461, 503553, 127978, 539702,
535122, 721528, 132468, 539702, 322154, 721528, 585622, 577544, 588940,
539702, 603657, 122845, 535670, 435447, 725757, 122845, 390904, 90505,
639116, 721528, 80300, 503553, 435447, 595347, 320682, 621291, 343055,
621291, 107399, 577544, 725366, 503553, 452345, 595347, 201498, 621291,
442576, 539702, 587892, 320512, 308147, 621291, 555167, 90505, 59078,
539702, 464764, 721528, 688220, 75320, 730348, 90505, 112705, 320512,
169733, 122845, 50954, 539702, 585667, 577544, 78046, 299557, 738857,
652053, 471501, 151611, 105324, 614411, 548107, 90505, 566362, 122845,
735541, 299557, 473644, 614411, 506172, 503553, 180465, 122845, 629412,
614411, 112692, 614411, 299384, 303680, 311072, 614411, 509482, 621291,
544250, 614411, 178290, 90505, 308169, 577544, 588940, 539702, 459370,
90505, 739050, 320512, 118873, 621291, 497351, 75320, 73580, 539702,
454142, 320512, 535680
]
construct_price = {
'Tiết Kiệm': 4500000.0,
'Cơ Bản': 5100000.0,
'Trung Bình': 5500000.0,
'Khá': 5850000.0,
'Cao Cấp': 8300000.0
}
def cal_land_price_per_m2(row, construct_type='Cơ Bản'):
try:
return (float(row.price_sell) - float(row.floor) *
construct_price[construct_type]) / float(row.area_cal)
except:
return 0.0
# return (float(row.price_sell) - float(row.floor)*construct_price[construct_type])/float(1.0)
def cal_house_price(row, land_price_per_m2=0.0, construct_type='Cơ Bản'):
# print('area_call:{},land_price_per_m2:{}'.format(str(row.area_cal),str(land_price_per_m2)))
try:
return float(row.floor) * construct_price[construct_type] + float(
land_price_per_m2) * float(row.area_cal)
except:
return float(row.floor) * construct_price[construct_type] + float(
land_price_per_m2) * float(1.0)
def get_price_ratio_of_a_point_with_deep(price_ratio, deep):
return 1 + price_ratio / math.pow(1.1, (int(deep) / 100))
def size_a_point(row):
return 3
def color_a_point(row):
color = "#0375B4" # blue
# if int(row['id']) == center_id:
# return color
try:
color = mapping_color[row['id']]
except:
pass
return color
def draw_folium_map(data_post):
i = j = k = 0
# generate a new map
folium_map = folium.Map(
location=[idPost['gglat'], idPost['gglong']],
zoom_start=15,
max_zoom=25,
tiles="CartoDB positron",
# tiles="CartoDB dark_matter",
width='50%')
folium.CircleMarker(location=(idPost['gglat'], idPost['gglong']),
radius=35,
color="#0000FF",
fill=False).add_to(folium_map)
# for each row in the data, add a cicle marker
if (limit == 0):
lim = len(data_post)
else:
lim = limit
pd_data = []
for index, row in data_post.iterrows():
# if(index > limit or limit = 0):
# if(index > lim):
# break
# else:
# # calculate net departures
# net_departures = (row["Departure Count"]-row["Arrival Count"])
# generate the popup message that is shown on click.
i = 0
# for i in range(0, len(arr)):
# if int(row['id']) in arr[i]:
# break
for i in arr_dist:
if int(row['id']) in arr_dist[i]:
break
ks = [
'ID', 'Address Street', 'Address Ward', 'Address District',
'Position Street', 'Area', 'Deep', 'Labeled', 'Old Price/m2',
'New Price/m2', 'Ratio', 'label'
]
popup_text = """
ID: {}<br>
Address Street: {}<br>
Address Ward: {}<br>
Address District: {}<br>
Position Street: {}<br>
Area: {}<br>
Deep: {}<br>
Labeled: {}<br>
Old Price/m2: {}<br>
New Price/m2: {}<br>
Ratio: {}<br>
"""
# new_price_m2 = get_price_m2_of_a_point_with_deep(price_m2,i)
new_ratio = get_price_ratio_of_a_point_with_deep(price_ratio, i)
new_price_m2 = cal_land_price_per_m2(row) * float(new_ratio)
pd_data.append([
row["id"],
unidecode(str(row["address_street"])),
unidecode(str(row["address_ward"])),
unidecode(str(row["district_name"])), row["position_street"],
row['area_cal'], i,
int(row["id"]) in labeled,
'{:,.2f}'.format(cal_land_price_per_m2(row)),
'{:,.2f}'.format(new_price_m2), new_ratio, ''
])
popup_text = popup_text.format(
row["id"],
unidecode(str(row["address_street"])),
unidecode(str(row["address_ward"])),
unidecode(str(row["district_name"])),
row["position_street"],
row['area_cal'],
i,
int(row["id"]) in labeled,
'{:,.2f}'.format(cal_land_price_per_m2(row)),
'{:,.2f}'.format(new_price_m2),
new_ratio,
)
# print(popup_text)
# # radius of circles
# radius = net_departures/20
# # choose the color of the marker
# if net_departures>0:
# # color="#FFCE00" # orange
# # color="#007849" # green
# color="#E37222" # tangerine
# else:
# # color="#0375B4" # blue
# # color="#FFCE00" # yellow
# color="#0A8A9F" # teal
# add marker to the map
if color_a_point(row) != "#0375B4":
folium.CircleMarker(location=(row["gglat"], row["gglong"]),
radius=size_a_point(row),
color=color_a_point(row),
popup=popup_text,
fill=True).add_to(folium_map)
if color_a_point(row) == "#007849":
i += 1
if color_a_point(row) == "#FFCE00":
j += 1
elif color_a_point(row) == "#0375B4":
folium.CircleMarker(location=(row["gglat"], row["gglong"]),
radius=1,
color=color_a_point(row),
popup=popup_text,
fill=True).add_to(folium_map)
k += 1
df_save = pd.DataFrame(pd_data, columns=ks)
# df_save.to_csv(str(center_id)+'_'+str(price_ratio)+'.csv')
if not os.path.exists('Results'):
os.makedirs('Results')
df_save = df_save.sort_values(by='Deep', axis=0)
df_save.to_csv('Results/ID_{}_{}_{}.csv'.format(
str(center_id), str(price_ratio), '{:,.2f}'.format(
float(idPost["price_m2_old"]) * float(new_ratio))))
print("green: %s, orange: %s, blue: %s" % (i, j, k))
return folium_map
def get_direction(deep):
if (deep == 0):
return [[0, 0]]
if (deep > 0):
lst = []
for x in range(-deep, deep + 1):
for y in range(-deep, deep + 1):
if x == deep or y == deep or x == -deep or y == -deep:
lst.append([x, y])
return lst
def getSurroundings(matrix, x, y, deep):
res = []
for direction in get_direction(deep):
cx = x + direction[0]
cy = y + direction[1]
if (cy >= 0 and cy < len(matrix)):
if (cx >= 0 and cx < len(matrix[cy])):
res.append(matrix[cy][cx])
return res
def closest_node(data, t, map, m_rows, m_cols):
# (row,col) of map node closest to data[t]
result = (0, 0)
small_dist = 1.0e20
for i in range(m_rows):
for j in range(m_cols):
# ed = euc_dist(map[i][j], data[t])
ed = latlong_posstreet(map[i][j], data[t])
if ed < small_dist:
small_dist = ed
result = (i, j)
return result
def latlong_posstreet(v1, v2):
# print(v1)
# print(v2)
distance_latlong = np.linalg.norm(
v1[:2] - v2[:2]) * 1000 # lấy 2 giá trị đầu tính latlong
delta = np.linalg.norm(v1[2] - v2[2])
distance_district_latlong = np.linalg.norm(v1[3:5] -
v2[3:5]) * 1000 / 2
# distance_street = np.linalg.norm(v1[5:7] - v2[5:7])
# distance = sigma + alpha * delta + abs(beta * distance_latlong) + gamma * distance_district_latlong + abs(omega * street)
distance = sigma + alpha * delta + abs(
beta * distance_latlong) + gamma * distance_district_latlong
return distance
def score_pos_street(id_pos_street): # convert id pos_street to score
id_pos_street = int(float(id_pos_street))
if id_pos_street == 1:
return c[0]
if id_pos_street == 2:
return c[1]
if id_pos_street == 3:
return c[2]
if id_pos_street == 4:
return c[3]
if id_pos_street == 5:
return c[4]
if id_pos_street == 6:
return c[5]
return id_pos_street
def euc_dist(v1, v2):
return np.linalg.norm(v1 - v2)
def manhattan_dist(r1, c1, r2, c2):
return np.abs(r1 - r2) + np.abs(c1 - c2)
def most_common(lst, n):
# lst is a list of values 0 . . n
if len(lst) == 0: return -1
counts = np.zeros(shape=n, dtype=np.int)
for i in range(len(lst)):
counts[lst[i]] += 1
return np.argmax(counts)
# Get datapost
data_post, center_id, idPost = get_df()
print(len(data_post))
price_m2 = cal_land_price_per_m2(idPost)
# Initial variables for model
# Initial variables for logic distance
# Initial data_x, data_y, name
[alpha, beta, gamma, omega, sigma, c] = [
3.12506638, -9.00115707, 4.35316446, -97.95369439, -6.64789365,
[
-16.16039254, -12.96374504, -21.42898834, -16.06295894,
-16.23441444, -18.69862314
]
]
nrows = len(data_post.index)
data_x = []
data_x_dictrict = []
data_x_street = []
for i in range(0, nrows):
data_x.append(data_post["latlongpos"].iloc[i])
data_x_dictrict.append([
data_post["district_lat"].iloc[i],
data_post["district_long"].iloc[i]
])
# data_x_street.append(data_post["latlong_street"].iloc[i])
data_x = [x[:2] + [score_pos_street(x[2])] for x in data_x]
for i in range(0, nrows):
data_x[i].extend(data_x_dictrict[i])
# data_x[i].extend(data_x_street[i])
# print(data_x)
data_y = []
for i in range(0, nrows):
data_y.append(data_post["id"].iloc[i])
name = []
for index, row in data_post.iterrows():
name.append((row.id))
np.random.seed(1)
Dim = len(data_x[0])
Rows = 100
Cols = 100
RangeMax = Rows + Cols
LearnMax = 0.5 # 0.5
StepsMax = 15000 # 20000
# Load K-SOM map
map = np.load('Ver.04/map_GAKSOM3.npy', allow_pickle=True)
mapping = np.load('Ver.04/mapping_GAKSOM3.npy', allow_pickle=True)
label_map = np.load('Ver.04/label_map_new_GAKSOM2.npy', allow_pickle=True)
label_map_new = np.load('Ver.04/label_map_new_GAKSOM3.npy',
allow_pickle=True)
label_map_district = np.load('Ver.04/label_map_district_new_GAKSOM2.npy',
allow_pickle=True)
# Find Closest Node
v1_x = data_x[data_y.index(idd)]
LOL = np.array([v1_x])
predict_idx = closest_node(LOL, 0, map, Rows, Cols)
arr_dist = {}
arr_dist[0] = [idd]
count = 0
for i in range(0, 100):
for index in getSurroundings(label_map_new, predict_idx[1],
predict_idx[0], i):
pred_idx = index
if (pred_idx != -1):
idPost_coordinate = np.array(
[idPost['gglat'], idPost['gglong']])
for idd in pred_idx:
try:
pred_idd = np.array([
data_post[data_post["id"] == idd].iloc[0]['gglat'],
data_post[data_post["id"] == idd].iloc[0]['gglong']
])
try:
arr_dist[i * 10 + (int(
euc_dist(pred_idd, idPost_coordinate) * 100) %
10)].append(idd)
except:
arr_dist[i * 10 + (int(
euc_dist(pred_idd, idPost_coordinate) * 100) %
10)] = [idd]
count += 1
except Exception as e:
# print(str(e) + ' id: ' + str(idd))
pass
mapping_color = {}
red = Color("#FE0000")
green = Color("#008000")
colors = list(red.range_to(green, 10000))
for i_x, x in enumerate(label_map_new):
for i_y, y in enumerate(x):
if isinstance(y, list):
# mapping_color[100*i_y+i_x]=y
for item in y:
mapping_color[item] = colors[100 * i_y + i_x].get_hex()
# draw_folium_map(data_post)
mymapp = draw_folium_map(data_post)
return mymapp
# folium_mapp(539702)
cells = dict(
values=[cols] + [l],
line_color='darkslategray',
)
header = dict(values=['Round', 'Points'], line_color='darkslategray')
fig = go.Figure(data=[go.Table(header=header, cells=cells)])
fig.update_layout(margin=dict(l=0, r=0, t=0, b=0))
file_name = f"Write_Up/img/{team.replace(' ', '_').replace(',','')}_Week_{week}_Breakdown.html"
fig.write_html(file_name)
weeks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
trivia = Trivia(weeks)
s_col = Color("#fa8575")
colors = list(s_col.range_to(Color("#009c50"), 10))
#Overall
make_standings_table(trivia) # -> to HTML
make_records(trivia) # -> local var
make_cats(trivia) # -> to HTML
#Individual
teams = trivia.teams
for team in teams:
print(f'Making Team: {team}')
print('.....Overall')
team_weeks = [x[0] for x in trivia.team_weeks[team]]
make_butterfly(trivia, team)
make_season_plots(trivia, team)
make_season_all(trivia, team)
## make_cats_team(trivia, team)
def temp(ctx, color, f):
if(color):
c = color_convert(Color(color).get_rgb())
ctx.obj['dev'].send(set_temp_color(c[0],c[1],c[2],0xff,f))
else:
ctx.obj['dev'].send(switch_view("temp"))
class VirtualLedModel:
"""
Simulates the LED cube in different configurations in OpenGL.
You have to provide a json dictionary at instantiation, this should refer to a json file.
You also have to provide a pointer to the array of led colors.
After this, use the refresh function to update the LEDs.
The current shader supports up to 300 LEDS, update the shader variable if more is needed.
"""
model = None
program = None
debug_program = None
visualizer_thread = None
led_colors = None
vao = None
led_enclosure_buffer = None
led_enclosure_buffer_id = None
attrib_position_id = None
attrib_normal_id = None
led_color_buffer = None
led_color_buffer_id = None
attrib_led_color_id = None
led_position_buffer = None
led_position_buffer_id = None
attrib_led_position_id = None
camera_horizontal_angle = pi / 4
camera_vertical_angle = pi / 4
attrib_cam_pos_id = None
cam_pos = [0.0, 0.0, 0.0]
zoom_factor = 0.0
zoom_start_distance = 1.0
zoom_last_distance = 1.0
zoom_animation_speed = 0.1
key_down_left_mouse = False
mouse_drag_speed = 0.01
mouse_scroll_speed = 0.1
mouse_last_x = -1.0
mouse_last_y = -1.0
refresh_queued = False
shutdown_requested = False
delta_time = None
last_time = None
n_leds = None
hdr = [1.0, 0.0]
hdr_goal = [1.0, 0.0]
hdr_change_rate = 0.05
attrib_hdr_id = None
clear_color = Color('gray')
debug = False
active_debug = False
fov = 45.0
close = 0.01
far = 1000
fps = 60
window_width = 800
window_height = 600
window_title = b'LED Visualizer'
def __init__(self, model):
self.model = model
self.n_leds = len(self.model['led-strip'])
self.last_time = time.time()
self.led_colors = [0] * (self.n_leds * 3)
def thread_func():
self._init_glut()
self._init_opengl()
glutMainLoop()
self.visualizer_thread = Thread(name='visualizer', target=thread_func)
self.visualizer_thread.start()
def _init_opengl(self):
glClearColor(self.clear_color.get_red(), self.clear_color.get_green(),
self.clear_color.get_blue(), 1.0)
glClearDepth(1.0)
glDepthFunc(GL_LEQUAL)
glShadeModel(GL_SMOOTH)
glEnable(GL_POLYGON_SMOOTH)
glEnable(GL_DEPTH_TEST)
glEnable(GL_CULL_FACE)
#glEnable(GL_VERTEX_ARRAY)
#glEnable(GL_BLEND)
#glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
if not glUseProgram:
raise EnvironmentError('Missing shader objects')
# Open shader files
vert_file = open('neural_presenters/virtual/shaders/enclosure.vert')
frag_file = open('neural_presenters/virtual/shaders/enclosure.frag')
# Compile
self.program = compileProgram(
compileShader(vert_file.read(), GL_VERTEX_SHADER),
compileShader(frag_file.read(), GL_FRAGMENT_SHADER))
# Close files
vert_file.close()
frag_file.close()
# Open shader files
vert_file = open('neural_presenters/virtual/shaders/debug.vert')
frag_file = open('neural_presenters/virtual/shaders/debug.frag')
self.debug_program = compileProgram(
compileShader(vert_file.read(), GL_VERTEX_SHADER),
compileShader(frag_file.read(), GL_FRAGMENT_SHADER))
# Close files
vert_file.close()
frag_file.close()
glUseProgram(self.program)
# Fill LED buffers
led_positions = self.model['led-strip']
self.led_color_buffer = (GLfloat *
(4 * self.n_leds))(*ones(4 * self.n_leds))
self.led_position_buffer = (GLfloat *
(4 * self.n_leds))(*ones(4 * self.n_leds))
for i in range(self.n_leds):
for j in range(3):
self.led_color_buffer[i * 4 + j] = 0.0
self.led_position_buffer[i * 4 + j] = led_positions[i][j]
# Fill enclosure buffer
led_enclosure = self.model['led-enclosure']
self.led_enclosure_buffer = (GLfloat * (3 * 8 * len(led_enclosure)))(
*ones(3 * 8 * len(led_enclosure)))
for i in range(len(led_enclosure)):
# Calculate normal for the next three vertices
v1 = array(led_enclosure[i][0])
v2 = array(led_enclosure[i][1])
v3 = array(led_enclosure[i][2])
edge1 = v2 - v1
edge2 = v3 - v1
normal = cross(edge1, edge2)
normal = normal / sqrt(normal[0]**2 + normal[1]**2 + normal[2]**2)
for j in range(3):
for k in range(3):
self.led_enclosure_buffer[i * 8 * 3 + j * 8 +
k] = led_enclosure[i][j][k]
for k in range(3):
self.led_enclosure_buffer[i * 8 * 3 + j * 8 + k +
4] = normal[k]
# Generate vertex array and bind
self.vao = glGenVertexArrays(1)
glBindVertexArray(self.vao)
# Not the best way, but works for now
self.attrib_led_color_id = glGetUniformLocation(
self.program, 'led_colors')
self.attrib_led_position_id = glGetUniformLocation(
self.program, 'led_positions')
self.attrib_hdr_id = glGetUniformLocation(self.program, 'hdr')
self.attrib_cam_pos_id = glGetUniformLocation(self.program, 'cam_pos')
self._bind_uniforms()
"""
# Setup LED color buffer
self.led_color_buffer_id = glGenBuffers(1)
glBindBuffer(GL_UNIFORM_BUFFER, self.led_color_buffer_id)
glBufferData(GL_UNIFORM_BUFFER, len(self.led_color_buffer) * sizeof(GLfloat),
self.led_color_buffer, GL_STREAM_DRAW)
self.attrib_led_color_id = glGetUniformLocation(self.program, 'led_colors')
glBindBufferRange(GL_UNIFORM_BUFFER, 0, self.led_color_buffer_id, 0, len(self.led_color_buffer_id))
# Setup LED position buffer
self.led_position_buffer_id = glGenBuffers(1)
glBindBuffer(GL_UNIFORM_BUFFER, self.led_position_buffer_id)
glBufferData(GL_UNIFORM_BUFFER, len(self.led_position_buffer) * sizeof(GLfloat),
self.led_position_buffer, GL_STATIC_DRAW)
self.attrib_led_position_id = glGetUniformLocation(self.program, 'led_positions')
glBindBufferBase(GL_UNIFORM_BUFFER, 1, self.led_position_buffer_id)
glUniformBlockBinding(self.program, self.attrib_led_position_id, 1)
glBindBuffer(GL_UNIFORM_BUFFER, 0)
"""
# Setup enclosure vertex buffer
self.led_enclosure_buffer_id = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.led_enclosure_buffer_id)
glBufferData(GL_ARRAY_BUFFER,
len(self.led_enclosure_buffer) * sizeof(GLfloat),
self.led_enclosure_buffer, GL_STATIC_DRAW)
self.attrib_position_id = glGetAttribLocation(self.program, 'position')
self.attrib_normal_id = glGetAttribLocation(self.program, 'normal')
glVertexAttribPointer(self.attrib_position_id, 4, GL_FLOAT, GL_FALSE,
8 * sizeof(GLfloat), GLvoid)
glEnableVertexAttribArray(self.attrib_position_id)
glVertexAttribPointer(self.attrib_normal_id, 4, GL_FLOAT,
GL_FALSE, 8 * sizeof(GLfloat),
GLvoidp(4 * sizeof(GLfloat)))
glEnableVertexAttribArray(self.attrib_normal_id)
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(0)
glUseProgram(0)
def _init_glut(self):
glutInit()
glutInitDisplayMode(GLUT_DEPTH | GLUT_SINGLE | GLUT_RGB)
glutInitWindowSize(self.window_width, self.window_height)
glutCreateWindow(self.window_title)
glutDisplayFunc(self._render)
glutIdleFunc(self._render)
glutMouseFunc(self._mouse_used)
glutMouseWheelFunc(self._mouse_scroll_used)
glutKeyboardFunc(self._keyboard_used)
glutMotionFunc(self._motion)
glutReshapeFunc(self._resize)
def _update_hdr(self):
for i in range(2):
if abs(self.hdr_goal[i] -
self.hdr[i]) <= self.hdr_change_rate * self.delta_time:
self.hdr[i] = self.hdr_goal[i]
else:
self.hdr[i] += self.hdr_change_rate * self.delta_time * sign(
self.hdr_goal[i] - self.hdr[i])
if not self.active_debug:
glClearColor(
self.clear_color.get_red() / self.hdr[0] - self.hdr[1],
self.clear_color.get_green() / self.hdr[0] - self.hdr[1],
self.clear_color.get_blue() / self.hdr[0] - self.hdr[1], 1.0)
glUniform2f(self.attrib_hdr_id, GLfloat(self.hdr[0]),
GLfloat(self.hdr[1]))
else:
glClearColor(self.clear_color.get_red(),
self.clear_color.get_green(),
self.clear_color.get_blue(), 1.0)
def _resize(self, width, height):
if height == 0:
height = 1
glViewport(0, 0, width, height)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(self.fov,
float(width) / float(height), self.close, self.far)
glMatrixMode(GL_MODELVIEW)
def _update_camera(self):
zoom_distance_goal = pow(2.0,
self.zoom_factor) * self.zoom_start_distance
self.zoom_last_distance += (
zoom_distance_goal -
self.zoom_last_distance) * self.zoom_animation_speed
self.cam_pos[0] = self.zoom_last_distance * cos(
self.camera_horizontal_angle) * sin(self.camera_vertical_angle)
self.cam_pos[1] = self.zoom_last_distance * sin(
self.camera_horizontal_angle) * sin(self.camera_vertical_angle)
self.cam_pos[2] = self.zoom_last_distance * cos(
self.camera_vertical_angle)
gluLookAt(self.cam_pos[0], self.cam_pos[1], self.cam_pos[2], 0, 0, 0,
0, 0, 1)
if not self.active_debug:
glUniform3f(self.attrib_cam_pos_id, GLfloat(self.cam_pos[0]),
GLfloat(self.cam_pos[1]), GLfloat(self.cam_pos[2]))
def _draw_model(self):
glBindVertexArray(self.vao)
glDrawArrays(GL_TRIANGLES, 0, len(self.led_enclosure_buffer))
glBindVertexArray(0)
def _draw_debug(self):
# This is horrible, mixing opengl versions, using fixed pipeline... Oh well, only for debug
# Grid
glBegin(GL_LINES)
glColor(0.2, 0.2, 0.2)
for x in arange(-1, 1.1, 0.1):
glVertex(x, 1, 0)
glVertex(x, -1, 0)
for y in arange(-1, 1.1, 0.1):
glVertex(1, y, 0)
glVertex(-1, y, 0)
glEnd()
# Origin marker
glBegin(GL_LINES)
# X - axis
glColor(1, 0, 0)
glVertex(0, 0, 0)
glColor(1, 0, 0)
glVertex(0.1, 0, 0)
# Y - axis
glColor(0, 1, 0)
glVertex(0, 0, 0)
glColor(0, 1, 0)
glVertex(0, 0.1, 0)
# Z - axis
glColor(0, 0, 1)
glVertex(0, 0, 0)
glColor(0, 0, 1)
glVertex(0, 0, 0.1)
glEnd()
# LEDs
glPointSize(5)
glBegin(GL_LINES)
trans = linspace(0, 1, self.n_leds)
for led in range(self.n_leds - 1):
glColor(1, trans[led], 1 - trans[led])
glVertex(self.led_position_buffer[led * 4],
self.led_position_buffer[led * 4 + 1],
self.led_position_buffer[led * 4 + 2])
glColor(1, trans[led + 1], 1 - trans[led + 1])
glVertex(self.led_position_buffer[(led + 1) * 4],
self.led_position_buffer[(led + 1) * 4 + 1],
self.led_position_buffer[(led + 1) * 4 + 2])
glEnd()
glBegin(GL_POINTS)
for led in range(self.n_leds):
glColor(self.led_color_buffer[led * 4],
self.led_color_buffer[led * 4 + 1],
self.led_color_buffer[led * 4 + 2])
glVertex(self.led_position_buffer[led * 4],
self.led_position_buffer[led * 4 + 1],
self.led_position_buffer[led * 4 + 2])
glEnd()
# Enclosure
for poly in self.model['led-enclosure']:
glBegin(GL_LINE_LOOP)
glColor(0, 1, 1)
for vert in poly:
glVertex(vert[0], vert[1], vert[2])
glEnd()
def _render(self):
if self.shutdown_requested:
glutLeaveMainLoop()
return
now_time = time.time()
self.delta_time = now_time - self.last_time
self.last_time = now_time
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
debug_state = self.debug
if debug_state:
glUseProgram(self.debug_program)
else:
glUseProgram(self.program)
if self.active_debug != debug_state:
self.active_debug = debug_state
#self._bind_uniforms()
if self.refresh_queued:
light_intensity = 0.0
for i in range(self.n_leds):
led_intensity = 0.0
for j in range(3):
led = self.led_colors[i * 3 + j] / 255.0
led_intensity += led / 3.0
self.led_color_buffer[i * 4 + j] = led
self.led_color_buffer[i * 4 + 3] = 1.0
light_intensity += led_intensity
light_intensity /= self.n_leds
self.hdr_goal[1] = light_intensity * 0.5
if not debug_state:
glUniform4fv(self.attrib_led_color_id, self.n_leds,
self.led_color_buffer)
"""
glBindBuffer(GL_UNIFORM_BUFFER, self.led_buffer_color_index)
glBufferSubData(GL_UNIFORM_BUFFER,
0,
len(self.led_buffer_colors)*sizeof(c_float),
self.led_buffer_colors)
glBindBuffer(GL_UNIFORM_BUFFER, 0)
"""
self.refresh_queued = False
self._update_hdr()
self._update_camera()
if debug_state:
self._draw_debug()
else:
self._draw_model()
glutSwapBuffers()
glUseProgram(0)
time_taken = time.time() - now_time
sync_time = 1. / self.fps - time_taken
if sync_time < 0:
#print('Virtual model can\'t keep up')
sync_time = 0
time.sleep(sync_time)
def refresh(self, led_color_array):
for i in range(self.n_leds):
for j in range(3):
self.led_colors[i * 3 + j] = led_color_array[i * 3 + j]
self.refresh_queued = True
def running(self):
return self.visualizer_thread.is_alive()
def shutdown(self):
self.shutdown_requested = True
def _keyboard_used(self, key, x, y):
if key == b'd':
self.debug = not self.debug
def _bind_uniforms(self):
glUniform4fv(self.attrib_led_position_id, self.n_leds,
self.led_position_buffer)
glUniform4fv(self.attrib_led_color_id, self.n_leds,
self.led_color_buffer)
def _mouse_used(self, button, state, x, y):
if button == GLUT_LEFT_BUTTON:
if state == GLUT_UP:
self.key_down_left_mouse = False
self.mouse_last_x = -1.0
self.mouse_last_y = -1.0
else:
self.key_down_left_mouse = True
def _mouse_scroll_used(self, wheel, direction, x, y):
self.zoom_factor -= direction * self.mouse_scroll_speed
def _motion(self, x, y):
if self.key_down_left_mouse:
if self.mouse_last_x == -1.0:
self.mouse_last_x = x
self.mouse_last_y = y
self.camera_horizontal_angle -= (
x - self.mouse_last_x) * self.mouse_drag_speed
self.camera_horizontal_angle = self.camera_horizontal_angle % (2 *
pi)
temp = self.camera_vertical_angle - (
y - self.mouse_last_y) * self.mouse_drag_speed
self.camera_vertical_angle = clip(temp, 0.001, pi - 0.001)
self.mouse_last_x = x
self.mouse_last_y = y
def colourRange(n):
blue = Color('blue')
return list(blue.range_to(Color("green"), n))
def draw(self, qp):
pen = QPen(Qt.black, 1, Qt.SolidLine)
qp.setPen(pen)
# draw current arc expansion
if self.status == "arc-expand":
pen.setColor(Qt.yellow)
qp.setPen(pen)
for pixel in self.pixelsToColorInExpansion:
qp.drawPoint(pixel[0], pixel[1])
pen.setColor(Qt.red)
qp.setPen(pen)
for pixel in self.boundaryPixelsToColorInExpansion:
qp.drawPoint(pixel[0], pixel[1])
# paint completed arcs
if self.status != 'spine-search' and self.status != 'spine-map' and self.status != 'spine-extension' and self.status != 'done':
pen.setColor(Qt.green)
qp.setPen(pen)
for arcNum in self.arcsCompletedInArcExpansion: # all pixels
for pixel in self.ah.getArcPixels(arcNum):
qp.drawPoint(pixel[0], pixel[1])
pen.setColor(Qt.red)
qp.setPen(pen)
for arcNum in self.arcsCompletedInArcExpansion: # boundary pixels
for pixel in self.ah.getArcPixels(arcNum, boundary=True):
qp.drawPoint(pixel[0], pixel[1])
# draw our arc search pixel on top
if hasattr(
self, 'currPixelInArcSearch'
) and self.currPixelInArcSearch is not None: # first time it'll be None
pen.setColor(Qt.black)
qp.setPen(pen)
qp.drawPoint(self.currPixelInArcSearch[0],
self.currPixelInArcSearch[1])
# draw our spine search pixel on top
if hasattr(self, 'currPixelInSpineSearch'
) and self.currPixelInSpineSearch is not None:
pen.setColor(Qt.white)
qp.setPen(pen)
qp.drawPoint(self.currPixelInSpineSearch[0],
self.currPixelInSpineSearch[1])
# draw current spine mapping
if hasattr(self, 'pixelsVisitedInSpineMapping'
) and self.pixelsVisitedInSpineMapping is not None:
for pixel in self.pixelsVisitedInSpineMapping:
pen.setColor(Qt.red)
qp.setPen(pen)
qp.drawPoint(pixel[0], pixel[1])
# draw gradient between endpoints of completed spines
if self.status != "done" and len(self.arcsCompletedInSpineMapping) > 0:
for arcNum in self.arcsCompletedInSpineMapping:
pixels, colors = self.ah.getSpinePaintMap(arcNum)
for i in range(len(pixels)):
pixel = pixels[i]
color = colors[i]
pen.setColor(QColor(color[0], color[1], color[2]))
qp.setPen(pen)
qp.drawPoint(pixel[0], pixel[1])
# draw paths extended from endpoints
if self.status == "spine-extension":
for endPoint, stepped in self.spineExtensionStepped.items():
for pixel in stepped:
if self.ah.getEndPointPair(endPoint) is None:
pen.setColor(Qt.white)
else:
pen.setColor(QColor(50, 205, 50)) # is connected
qp.setPen(pen)
qp.drawPoint(pixel[0], pixel[1])
# draw color gradient over entire knot
if self.status == "done":
# get rgb values for as many pixels as we need
red = Color("red")
blue = Color("blue")
colors = list(
red.range_to(blue, int(len(self.knotEnumeration) / 2)))
colors.extend(
list(blue.range_to(red,
int(len(self.knotEnumeration) / 2) + 1)))
rgbs = [color.rgb for color in colors]
scaledRgbs = [(r * 255, g * 255, b * 255) for (r, g, b) in rgbs]
i = 0
source = list(self.knotEnumeration.keys())[0]
currPixel = source
while True:
color = scaledRgbs[i]
pen.setColor(QColor(color[0], color[1], color[2]))
qp.setPen(pen)
qp.drawPoint(currPixel[0], currPixel[1]) # ignore error
currPixel = self.knotEnumeration[currPixel]['next']
i += 1
if currPixel == source:
break
if self.status == "done":
pass
def color(self, color: Union[AnyStr, Color]):
if not isinstance(color, Color):
color = Color(color)
self._color = color
width = 480
pixels_size_height = height /pixels_colum
pixels_size_width = width /pixels_row
num_color = (0,0,0)
resolution = (height,width )
num_size = height / pixels_row /2
max_temp = 31
min_temp = 26
color_resolution = 100
blue = Color("blue")
#list() turn the tuple to list.
colors = list(blue.range_to(Color("red"), color_resolution))
colors = [(int(c.red * 255), int(c.green * 255), int(c.blue * 255)) for c in colors]
#print colors
def select_color(val):
if (val< min_temp):
return 0
return int((float(val)-min_temp)/(max_temp-min_temp) *color_resolution -1)
def conver_val_to_str(value):
val_str=str(value)
val_str=val_str[0:4]
return val_str
def get_stroke_colors(self, background=False):
return [
Color(rgb=rgba[:3]) for rgba in self.get_stroke_rgbas(background)
]
def get_fill_colors(self):
return [Color(rgb=rgba[:3]) for rgba in self.get_fill_rgbas()]
import plotly.express as px
import pandas as pd
from dash.dependencies import Input, Output
from dash.exceptions import PreventUpdate
import json
###
## To Do:
## Show name of node on hover
##
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
from colour import Color
red = Color("blue")
colors = list(red.range_to(Color("green"), 36))
# Create color gradient for groups
group_stylesheet = [{
"selector": '[group = {}]'.format(group + 1),
'style': {
"opacity": .50,
'z-index': 9999,
'background-color': colors[group].hex
}
} for group in range(36)]
default_cyto_stylesheet = group_stylesheet + [
# Instantiate with the first node highlight white as a prompt
{
def _get_color(self, value, _max, _min=0):
spectrum = list(Color("lime").range_to(Color("red"), 100))
percent = ((value - _min) / (_max - _min)) * 100
index = int(max(0, min(99, percent)))
return spectrum[index].hex
def make_time_map(times, times_tot_mins, sep_array, Ncolors):
print 'rendering normal time map ...'
## set up color list
red=Color("red")
blue=Color("blue")
color_list = list(red.range_to(blue, Ncolors)) # range of colors evenly speced on the spectrum between red and blue. Each element is a colour object
color_list = [c.hex for c in color_list] # give hex version
fig=plt.figure()
ax =fig.add_subplot(111)
plt.rc('text',usetex=True)
plt.rc('font',family='serif')
colormap = plt.cm.get_cmap('rainbow') # see color maps at http://matplotlib.org/users/colormaps.html
order=np.argsort(times_tot_mins[1:-1]) # so that the red dots are on top
# order=np.arange(1,len(times_tot_mins)-2) # dots are unsorted
# taken from http://stackoverflow.com/questions/6063876/matplotlib-colorbar-for-scatter
sc= ax.scatter(sep_array[:,0][order],sep_array[:,1][order],c=times_tot_mins[1:-1][order],vmin=0,vmax=24*60,s=25,cmap=colormap,marker='o',edgecolors='none')
color_bar=fig.colorbar(sc,ticks=[0,24*15,24*30,24*45,24*60],orientation='horizontal',shrink=0.5)
color_bar.ax.set_xticklabels(['Midnight','18:00','Noon','6:00','Midnight'])
color_bar.ax.invert_xaxis()
color_bar.ax.tick_params(labelsize=16)
ax.set_yscale('log') # logarithmic axes
ax.set_xscale('log')
plt.minorticks_off()
pure_ticks = np.array([1e-3,1,10,60*10,2*3600,1*24*3600, 7*24*3600]) # where the tick marks will be placed, in units of seconds.
labels = ['1 msec','1 sec','10 sec','10 min','2 hr','1 day','1 week'] # tick labels
max_val = np.max([np.max(sep_array[:,0]), np.max(sep_array[:,1])])
ticks = np.hstack((pure_ticks, max_val))
min_val = np.min([np.min(sep_array[:,0]), np.min(sep_array[:,1])])
plt.xticks(ticks,labels,fontsize=16)
plt.yticks(ticks,labels,fontsize=16)
plt.xlabel('Time Before Tweet',fontsize=18)
plt.ylabel('Time After Tweet',fontsize=18)
plt.xlim((min_val, max_val))
plt.ylim((min_val, max_val))
ax.set_aspect('equal')
plt.tight_layout()
plt.show()
return None
pygame.init()
#initialize the sensor
sensor = adafruit_amg88xx.AMG88XX(i2c_bus)
# pylint: disable=invalid-slice-index
points = [(math.floor(ix / 8), (ix % 8)) for ix in range(0, 64)]
grid_x, grid_y = np.mgrid[0:7:32j, 0:7:32j]
# pylint: enable=invalid-slice-index
#sensor is an 8x8 grid so lets do a square
height = 240
width = 240
#the list of colors we can choose from
blue = Color("indigo")
colors = list(blue.range_to(Color("red"), COLORDEPTH))
#create the array of colors
colors = [(int(c.red * 255), int(c.green * 255), int(c.blue * 255)) for c in colors]
displayPixelWidth = width / 30
displayPixelHeight = height / 30
lcd = pygame.display.set_mode((width, height))
lcd.fill((255, 0, 0))
pygame.display.update()
pygame.mouse.set_visible(False)
def main5(argv):
pygame.init()
pygame.midi.init()
fenetre = pygame.display.set_mode((1470, 750), DOUBLEBUF)
fenetre.set_alpha(None)
fond = pygame.image.load("Images/fond3.png").convert_alpha()
clavier = pygame.image.load("Images/clavier7.png").convert_alpha()
touche = pygame.image.load("Images/db.png").convert()
touchen = pygame.image.load("Images/dn.png").convert()
touche_n = pygame.image.load("Images/gb.png").convert()
terrain = pygame.image.load("Images/terrain.png").convert()
fond1 = pygame.image.load("Images/fond.png").convert()
red = Color("red")
colors = list(red.range_to(Color("green"), 10))
midiOut = pygame.midi.Output(0)
class Test():
def __init__(self,
touche,
time_pos,
time,
octave,
posy=0,
posx=0,
val=0,
nature='ok',
increment=0):
self.touche = touche
self.time_pos = time_pos
self.time = time
self.octave = octave
self.posy = posy
self.posx = posx
self.val = val
self.nature = nature
self.increment = increment
class conv():
def __init__(self, type, note, time):
self.type = type
self.note = note
self.time = time
path = "fichier_midi/"
Fpath = path + argv
mid = MidiFile(Fpath)
conversion = []
conversion2 = []
partition = []
partition2 = []
compteur = 0
fichier = open("midi.txt", "w")
for i, j in enumerate(mid.tracks):
for msg in j:
fichier.write("%s %s %s\n" % (msg.type, msg.bytes()[1], msg.time))
p1 = 0
ok = 0
ligne = 0
for i, j in enumerate(mid.tracks):
for msg in j:
if (msg.type == 'note_on'
or msg.type == 'note_off') and (p1 == 0 or p1 == 2):
conversion.append(
conv(msg.type,
msg.bytes()[1], int(msg.time * 1.7)))
#print("%s, %s, %s" % (msg.type, msg.bytes()[1], msg.time))
if msg.type == 'end_of_track' and len(conversion) == 0:
p1 = 2
elif msg.type == 'end_of_track' and len(conversion) > 0:
p1 = 1
if (msg.type == 'note_on' or msg.type == 'note_off') and p1 == 1:
conversion2.append(
conv(msg.type,
msg.bytes()[1], int(msg.time * 1.7)))
#print("Droite : %s, %s, %s" % (msg.type, msg.bytes()[1], msg.time))
taille = len(conversion)
taille2 = len(conversion2)
print(taille2)
tempo = 0
def _render_region(image, rect, color, rad):
"""Helper function for round_rect."""
corners = rect.inflate(-2 * rad, -2 * rad)
for attribute in ("topleft", "topright", "bottomleft", "bottomright"):
pg.draw.circle(image, color, getattr(corners, attribute), rad)
image.fill(color, rect.inflate(-2 * rad, 0))
image.fill(color, rect.inflate(0, -2 * rad))
def round_rect(surface,
rect,
color,
rad=20,
border=0,
inside=(0, 0, 0, 0)):
"""
Draw a rect with rounded corners to surface. Argument rad can be specified
to adjust curvature of edges (given in pixels). An optional border
width can also be supplied; if not provided the rect will be filled.
Both the color and optional interior color (the inside argument) support
alpha.
"""
rect = pg.Rect(rect)
zeroed_rect = rect.copy()
zeroed_rect.topleft = 0, 0
image = pg.Surface(rect.size).convert_alpha()
image.fill((0, 0, 0, 0))
_render_region(image, zeroed_rect, color, rad)
if border:
zeroed_rect.inflate_ip(-2 * border, -2 * border)
_render_region(image, zeroed_rect, inside, rad)
surface.blit(image, rect)
def verif_note_on(nb):
for i in range(nb):
if conversion[i].type != 'note_on':
return False
return True
if verif_note_on(10):
for i in range(len(conversion)):
if conversion[i].type == 'note_on':
cp = 1
if conversion[i].note == conversion[i + cp].note:
conversion[i + cp].type = 'note_off'
while conversion[i].note != conversion[i + cp].note:
cp += 1
if cp != 1:
conversion[i + cp].type = 'note_off'
for i in range(len(conversion2)):
if conversion2[i].type == 'note_on':
cp = 1
if conversion2[i].note == conversion2[i + cp].note:
conversion2[i + cp].type = 'note_off'
while conversion2[i].note != conversion2[i + cp].note:
cp += 1
if cp != 1:
conversion2[i + cp].type = 'note_off'
#for obj in conversion:
# print(obj.type, obj.note, obj.time)
def verif_blanc(touche):
if (int(touche) % 12 < 5):
if ((int(touche) % 12) % 2 == 0):
return True
else:
return False
else:
if ((int(touche) % 12) % 2 == 1):
return True
else:
return False
for i in range(len(conversion)):
if conversion[i].type == 'note_on':
cp = 1
time_on = int(conversion[i].time)
time_off = 0
while conversion[i].note != conversion[i + cp].note:
time_off += int(conversion[i + cp].time)
cp += 1
time_off += int(conversion[i + cp].time)
tempo += int(conversion[i].time)
note_centre = int(conversion[i].note) % 12
if note_centre < 5:
if note_centre % 2 == 0:
note_place = (note_centre / 2) * 30
else:
note_place = 19 + (note_centre / 2) * 30
else:
if note_centre % 2 == 1:
note_place = ((
(conversion[i].note - 5) % 12) / 2) * 30 + 3 * 30
else:
note_place = ((
(conversion[i].note - 6) % 12) / 2) * 30 + 108
nb_octave_px = (int(conversion[i].note / 12) - 2) * 210
if verif_blanc(conversion[i].note):
partition.append(
Test(conversion[i].note, int(tempo / 10),
int(time_off / 10),
int(conversion[i].note) / 12, -int(time_off / 10),
note_place + nb_octave_px, 0, 'blanc'))
else:
partition.append(
Test(conversion[i].note, int(tempo / 10),
int(time_off / 10),
int(conversion[i].note) / 12, -int(time_off / 10),
note_place + nb_octave_px, 0, 'noir'))
else:
tempo += int(conversion[i].time)
tempo = 0
for i in range(len(conversion2)):
if conversion2[i].type == 'note_on':
cp = 1
time_on = int(conversion2[i].time)
time_off = 0
while conversion2[i].note != conversion2[i + cp].note:
time_off += int(conversion2[i + cp].time)
cp += 1
time_off += int(conversion2[i + cp].time)
tempo += int(conversion2[i].time)
note_centre = int(conversion2[i].note) % 12
if note_centre < 5:
if note_centre % 2 == 0:
note_place = (note_centre / 2) * 30
else:
note_place = 19 + (note_centre / 2) * 30
else:
if note_centre % 2 == 1:
note_place = ((
(conversion2[i].note - 5) % 12) / 2) * 30 + 3 * 30
else:
note_place = ((
(conversion2[i].note - 6) % 12) / 2) * 30 + 108
nb_octave_px = (int(conversion2[i].note / 12) - 2) * 210
if verif_blanc(conversion2[i].note):
partition2.append(
Test(conversion2[i].note, int(tempo / 10),
int(time_off / 10),
int(conversion2[i].note) / 12, -int(time_off / 10),
note_place + nb_octave_px, 0, 'blanc'))
else:
partition2.append(
Test(conversion2[i].note, int(tempo / 10),
int(time_off / 10),
int(conversion2[i].note) / 12, -int(time_off / 10),
note_place + nb_octave_px, 0, 'noir'))
else:
tempo += int(conversion2[i].time)
for obj in partition:
print(obj.touche, obj.time_pos, obj.time, obj.posx, obj.posy)
posx = 0
posy = 0
haut = bas = gauche = droite = 0
font = pygame.font.SysFont("gameovercre", 30)
continuer = 1
c = 0
score = 0
touche_actuelle = []
touche_actuelle2 = []
touche_actuelle.append(partition2[0])
index2 = 0
if (len(partition2) != 0):
touche_actuelle2.append(partition2[0])
index = 0
while partition2[index].time_pos == partition2[index + 1].time_pos:
touche_actuelle.append(partition2[index + 1])
index += 1
#touche_actuelle = [partition[0],partition[1]]
#print(len(touche_actuelle))
tps_actuel = tps_precedent = 0
start = 1
stop = 0
fenetre.blit(fond, (0, 0))
index = 0
class vecColor:
def __init__(self, r, g, b):
self.R = r
self.G = g
self.B = b
def computeVarColor(first, second, shades):
toReturn = vecColor(0.0, 0.0, 0.0)
toReturn.R = abs(first.R - second.R) / shades
if first.R > second.R:
toReturn.R = -1 * toReturn.R
toReturn.G = abs(first.G - second.G) / shades
if first.G > second.G:
toReturn.G = -1 * toReturn.G
toReturn.B = abs(first.B - second.B) / shades
if first.B > second.B:
toReturn.B = -1 * toReturn.B
return toReturn
color1 = vecColor(132, 176, 217)
color2 = vecColor(33, 112, 187)
colorvars = computeVarColor(color1, color2, 200)
# for i in range(300):
# print("%d %d %d" % (color1.R + i*colorvars.R, color1.G + i*colorvars.G, color1.B + i*colorvars.B))
inp = pygame.midi.Input(1)
clock = pygame.time.Clock()
while continuer:
dt = clock.tick(161)
if inp.poll():
for items in inp.read(1000):
midi_value = items[0][0:3]
if midi_value[0] == 144:
midiOut.note_on(midi_value[1], 127)
elif midi_value[0] != 144:
midiOut.note_off(midi_value[1], 127)
print(midi_value)
if len(touche_actuelle) == 1 and touche_actuelle[
0].posy + touche_actuelle[0].time >= 531:
#if midi_value[0] == int(touche_actuelle[0].touche) and midi_value[1] != 0:
if midi_value[1] == int(
touche_actuelle[0].touche
) and midi_value[0] == 144 and midi_value[2] != 0:
touche_actuelle[0].val = 1
index += 1
del touche_actuelle[:]
plus = 0
touche_actuelle.append(partition2[index])
while partition2[index + plus].time_pos == partition2[
index + 1 + plus].time_pos:
touche_actuelle.append(partition2[index + 1 +
plus])
plus += 1
'''else:
touche_actuelle[0].val =2
index+=1
del touche_actuelle[:]
if partition[index].time_pos == partition[index+1].time_pos:
touche_actuelle.append(partition[index])
touche_actuelle.append(partition[index+1])
else:
touche_actuelle.append(partition[index])'''
else:
for elem in touche_actuelle:
if elem.posy + elem.time >= 531:
#if midi_value[0] == int(elem.touche) and midi_value[1] != 0:
if midi_value[1] == int(
elem.touche
) and midi_value[0] == 144 and midi_value[2] != 0:
elem.val = 1
ok = 1
for elem in touche_actuelle:
if elem.val == 1 or elem.val == 2:
ok *= 1
else:
ok *= 0
if ok == 1:
index += len(touche_actuelle)
del touche_actuelle[:]
plus = 0
touche_actuelle.append(partition2[index])
while partition2[index + plus].time_pos == partition2[
index + 1 + plus].time_pos:
touche_actuelle.append(partition2[index + 1 +
plus])
plus += 1
for event in pygame.event.get():
if event.type == QUIT:
continuer = 0
if event.type == KEYDOWN:
if event.key == K_DOWN:
bas = 1
if event.key == K_UP:
haut = 1
if event.key == K_RIGHT:
droite = 1
'''if touche_actuelle.posy+touche_actuelle.time>=531:
score=1'''
if event.key == K_LEFT:
gauche = 1
if event.type == KEYUP:
if event.key == K_DOWN:
bas = 0
if event.key == K_UP:
haut = 0
if event.key == K_RIGHT:
droite = 0
#score=0
if event.key == K_LEFT:
gauche = 0
if event.type == MOUSEBUTTONDOWN:
if event.button == 1:
posx = event.pos[0]
posy = event.pos[1]
if droite == 1:
posx += 1
if gauche == 1:
posx -= 1
if haut == 1:
posy -= 1
if bas == 1:
posy += 1
'''
c+=1
for i in range(int(taille/2)):
if i == 0:
if partition[0].posy+int(partition[0].time)<fenetre.get_height()- clavier.get_height() and partition[0].val==0:
partition[0].posy+=1
elif partition[0].val == 1:
partition[0].posy+=1
elif partition[i].posy+int(partition[i].time)<=partition[i-1].posy and partition[i].val == 0 and partition[i].posy+int(partition[i].time)<fenetre.get_height()- clavier.get_height():
partition[i].posy+=1
elif partition[i].posy+int(partition[i].time)<=partition[i-1].posy and partition[i].val == 1:
partition[i].posy+=1'''
tps_actuel = pygame.time.get_ticks()
if start == 1:
c += 1
if len(touche_actuelle) == 1:
if touche_actuelle[0].posy + int(touche_actuelle[
0].time) < fenetre.get_height() - clavier.get_height():
start = 1
elif touche_actuelle[0].posy + int(touche_actuelle[
0].time) >= fenetre.get_height() - clavier.get_height():
start = 0
else:
ok = 1
for elem in touche_actuelle:
if elem.posy + int(elem.time) < fenetre.get_height(
) - clavier.get_height():
ok *= 1
#tps_precedent=tps_actuel
elif elem.posy + int(elem.time) >= fenetre.get_height(
) - clavier.get_height():
ok *= 0
#tps_precedent=tps_actuel
if ok == 1:
start = 1
else:
start = 0
#fenetre.blit(fond, (0,0))
for i in range(int(taille2 / 2)):
cropped = pygame.Surface([44, partition2[i].time], pygame.SRCALPHA,
32)
cropped.blit(fond, (0, 0), (partition2[i].posx, partition2[i].posy,
44, partition2[i].time))
fenetre.blit(cropped, (partition2[i].posx, partition2[i].posy))
if c >= partition2[i].time_pos and start == 1:
partition2[i].posy += 1
'''for i in range(int(taille/2)):
if i == 0:
if partition[0].val == 0 and score == 1:
#partition[0].val=1
del touche_actuelle[:]
touche_actuelle.append(partition[1])
score=0
break
else:
if partition[i-1].val == 1 and score == 1 and partition[i].val == 0:
#partition[i].val =1
if partition[i].time_pos == partition[i+1].time_pos:
del touche_actuelle[:]
touche_actuelle.append(partition[i])
touche_actuelle.append(partition[i+1])
score=0'''
for i in range(int(taille2 / 2)):
'''if c>=partition[i].time_pos and partition[i].posy+partition[i].time-1 == fenetre.get_height()- clavier.get_height():
midiOut.note_on(partition[i].touche,127)
if c>=partition[i].time_pos and partition[i].posy == fenetre.get_height()- clavier.get_height():
midiOut.note_off(partition[i].touche,127)'''
if c >= partition2[i].time_pos and partition2[
i].posy < fenetre.get_height() - clavier.get_height():
if partition2[i].val == 1:
if partition2[i].nature == 'blanc':
round_rect(fenetre,
(partition2[i].posx, partition2[i].posy, 30,
partition2[i].time), pg.Color("blue"), 8,
2, (132, 0, 217, 255))
else:
round_rect(fenetre,
(partition2[i].posx, partition2[i].posy, 19,
partition2[i].time), pg.Color("blue"), 5,
2, (33, 0, 187, 255))
elif partition2[i].val == 0:
if partition2[i].nature == 'blanc':
round_rect(fenetre,
(partition2[i].posx, partition2[i].posy, 30,
partition2[i].time), pg.Color("white"), 8,
2, (132, 0, 217, 255))
else:
round_rect(fenetre,
(partition2[i].posx, partition2[i].posy, 19,
partition2[i].time), pg.Color("white"), 5,
2, (33, 0, 187, 255))
else:
if partition2[i].nature == 'blanc':
round_rect(fenetre,
(partition2[i].posx, partition2[i].posy, 30,
partition2[i].time), pg.Color("red"), 8, 2,
(132, 0, 217, 255))
else:
round_rect(fenetre,
(partition2[i].posx, partition2[i].posy, 19,
partition2[i].time), pg.Color("red"), 5, 2,
(33, 0, 187, 255))
#fenetre.blit(touches[i], (partition[i].posx, partition[i].posy))
fenetre.blit(clavier, (0, fenetre.get_height() - clavier.get_height()))
#write = "COUCOU %d s, score : %d, : %d, test ; %d %d %d" % (int(c/100),osu, score, partition[0].val,partition[1].val,partition[2].val)
write = "Compteur : %d Start : %d" % (c, start)
#texte = font.render(write, 1, (0,0,0))
texte = font.render(" ", 1, (0, 0, 0))
fenetre.blit(texte, (0, 0))
#round_rect(fenetre, (500,250,44,200), pg.Color("black"), 10,3, (0,0,0,0))
pygame.display.flip()
'''
for obj in partition:
print(obj.touche, obj.time_pos, obj.time, obj.octave)'''
'''
index=0
for i,j in enumerate(mid.tracks):
for msg in j:
print(index, msg)
index +=1
'''
'''def getNoteRangeAndTicks(files_dir, res_factor=1):
ticks = []
notes = []
for file_dir in files_dir:
file_path = "%s" %(file_dir)
mid = MidiFile(file_path)
for track in mid.tracks: #preprocessing: Checking range of notes and total number of ticks
num_ticks = 0
for message in track:
if not isinstance(message, MetaMessage):
notes.append(message.note)
num_ticks += int(message.time/res_factor)
ticks.append(num_ticks)
return min(notes), max(notes), max(ticks) '''
#print(mid.ticks_per_beat)
'''continuer = 1
i = 0
clock = pygame.time.Clock()
while continuer:
for event in pygame.event.get():
if event.type == QUIT:
continuer = 0
i+=1
if i == 7:
i=0
fenetre.blit(logo_a[i], (0,0))
pygame.display.flip()
clock.tick(10)'''
inp.close()
pygame.display.quit()
def createGrad(startColor=Color("#FFA13D"), endColor=Color("#0D1D3B")):
#Create the color gradient
colorGrad = list(startColor.range_to(endColor, 30))
#Adjust the color gradient to be returned in a form that pyplot can accept
return list(map(lambda x: x.hex, colorGrad))
def main():
# argument parsing
parser = argparse.ArgumentParser()
parser.add_argument("color_depth",
help="integer number of colors to use to draw temps",
type=int)
parser.add_argument('--headless',
help='run the pygame headlessly',
action='store_true')
args = parser.parse_args()
MAXTEMP = 31 # initial max temperature
COLORDEPTH = args.color_depth # how many color values we can have
AMBIENT_OFFSET = 9 # value to offset ambient temperature by to get rolling MAXTEMP
AMBIENT_TIME = 3000 # length of ambient temperature collecting intervals in seconds
# create data folders if they don't exist
if not os.path.exists(get_filepath('../img')):
os.makedirs(get_filepath('../img'))
if not os.path.exists(get_filepath('../data')):
os.makedirs(get_filepath('../data'))
if not os.path.exists(get_filepath('../video')):
os.makedirs(get_filepath('../video'))
# empty the images folder
for filename in os.listdir(get_filepath('../img/')):
if filename.endswith('.jpeg'):
os.unlink(get_filepath('../img/') + filename)
i2c_bus = busio.I2C(board.SCL, board.SDA)
# For headless pygame
if args.headless:
os.putenv('SDL_VIDEODRIVER', 'dummy')
else:
os.putenv('SDL_FBDEV', '/dev/fb1')
pygame.init()
# initialize the sensor
sensor = adafruit_amg88xx.AMG88XX(i2c_bus)
points = [(math.floor(ix / 8), (ix % 8)) for ix in range(0, 64)]
grid_x, grid_y = np.mgrid[0:7:32j, 0:7:32j]
# sensor is an 8x8 grid so lets do a square
height = 240
width = 240
# the list of colors we can choose from
blue = Color("indigo")
colors = list(blue.range_to(Color("red"), COLORDEPTH))
# create the array of colors
colors = [(int(c.red * 255), int(c.green * 255), int(c.blue * 255))
for c in colors]
displayPixelWidth = width / 30
displayPixelHeight = height / 30
lcd = pygame.display.set_mode((width, height))
lcd.fill((255, 0, 0))
pygame.display.update()
pygame.mouse.set_visible(False)
lcd.fill((0, 0, 0))
pygame.display.update()
# Setup SimpleBlobDetector parameters.
params = cv2.SimpleBlobDetector_Params()
# # Change thresholds
params.minThreshold = 10
params.maxThreshold = 255
# # Filter by Area.
params.filterByArea = True
params.minArea = 250
# # Filter by Circularity
params.filterByCircularity = True
params.minCircularity = 0.1
# # Filter by Convexity
params.filterByConvexity = False
params.minConvexity = 0.87
# # Filter by Inertia
params.filterByInertia = False
params.minInertiaRatio = 0.01
# # Set up the detector with default parameters.
detector = cv2.SimpleBlobDetector_create(params)
# initialize centroid tracker
ct = CentroidTracker()
# let the sensor initialize
time.sleep(.1)
# press key to exit
screencap = True
# json dump
data = {}
data['sensor_readings'] = []
# array to hold mode of last 10 minutes of temperatures
mode_list = []
print('sensor started!')
start_time = time.time()
while (screencap):
start = time.time()
date = datetime.now()
# read the pixels
pixels = []
for row in sensor.pixels:
pixels = pixels + row
data['sensor_readings'].append({
'time': datetime.now().isoformat(),
'temps': pixels,
'count': ct.get_count()
})
mode_result = stats.mode([round(p) for p in pixels])
mode_list.append(int(mode_result[0]))
# instead of taking the ambient temperature over one frame of data take it over a set amount of time
MAXTEMP = float(np.mean(mode_list)) + AMBIENT_OFFSET
pixels = [
map_value(p,
np.mean(mode_list) + 2, MAXTEMP, 0, COLORDEPTH - 1)
for p in pixels
]
# perform interpolation
bicubic = griddata(points, pixels, (grid_x, grid_y), method='cubic')
# draw everything
for ix, row in enumerate(bicubic):
for jx, pixel in enumerate(row):
try:
pygame.draw.rect(
lcd, colors[constrain(int(pixel), 0, COLORDEPTH - 1)],
(displayPixelHeight * ix, displayPixelWidth * jx,
displayPixelHeight, displayPixelWidth))
except:
print("Caught drawing error")
pygame.display.update()
surface = pygame.display.get_surface()
# frame saving
folder = get_filepath('../img/')
filename = str(date) + '.jpeg'
pygame.image.save(surface, folder + filename)
img = pygame.surfarray.array3d(surface)
img = np.swapaxes(img, 0, 1)
# Read image
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img = cv2.bitwise_not(img)
# Detect blobs.
keypoints = detector.detect(img)
for i in range(0, len(keypoints)):
x = keypoints[i].pt[0]
y = keypoints[i].pt[1]
# print little circle
pygame.draw.circle(lcd, (200, 0, 0), (int(x), int(y)), 7, 3)
# update our centroid tracker using the detected centroids
ct.update(keypoints)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
print('terminating...')
screencap = False
break
# for running the save on for a certain amount of time
# if time.time() - start_time >= 10:
# print('terminating...')
# screencap = False
# empty mode_list every AMBIENT_TIME seconds
if len(mode_list) > AMBIENT_TIME:
mode_list = []
time.sleep(max(1. / 25 - (time.time() - start), 0))
# write raw sensor data to file
data_index = 0
while os.path.exists(
get_filepath('../data/') + 'data%s.json' % data_index):
data_index += 1
data_path = str(get_filepath('../data/') + 'data%s.json' % data_index)
with open(data_path, 'w+') as outfile:
json.dump(data, outfile, indent=4)
# stitch the frames together
dir_path = get_filepath('../img/')
ext = '.jpeg'
out_index = 0
while os.path.exists(
get_filepath('../video/') + 'output%s.avi' % out_index):
out_index += 1
output = str(get_filepath('../video/') + 'output%s.avi' % out_index)
framerate = 10
# get files from directory
images = []
for f in os.listdir(dir_path):
if f.endswith(ext):
images.append(f)
# sort files
images = sorted(images,
key=lambda x: datetime.strptime(
x.split('.j')[0], '%Y-%m-%d %H:%M:%S.%f'))
# determine width and height from first image
image_path = os.path.join(dir_path, images[0])
frame = cv2.imread(image_path)
if not args.headless:
cv2.imshow('video', frame)
height, width, channels = frame.shape
# Define the codec and create VideoWriter object
fourcc = cv2.VideoWriter_fourcc(*'XVID') # Be sure to use lower case
out = cv2.VideoWriter(output, fourcc, framerate, (width, height))
for image in images:
image_path = os.path.join(dir_path, image)
frame = cv2.imread(image_path)
out.write(frame) # Write out frame to video
if not args.headless:
cv2.imshow('video', frame)
if (cv2.waitKey(1) & 0xFF) == ord('q'): # Hit `q` to exit
break
print('video created!')
# Release everything if job is finished
out.release()
cv2.destroyAllWindows()
def _getColorList(self, color1, color2, nColors):
colorList = []
colorRange = Color(color1).range_to(Color(color2), nColors)
for color in list(colorRange):
colorList.append(color.hex_l)
return colorList
return lazylights.Bulb(b'LIFXV2',
binascii.unhexlify(macString.replace(':', '')),
(ip, port))
#------------------------------------------------------------------------------------------------------------
myBulb1 = createBulb('10.0.0.X',
'XX:XX:XX:XX:XX:XX') #Bulb for right side of screen
#lazylights requires a 'set' of bulbs as input so I put each one in its own set
bulbs1 = [myBulb1]
while True:
target_name = "Pixel XL"
target_address = None
nearby_devices = bluetooth.discover_devices()
for bdaddr in nearby_devices:
if target_name == bluetooth.lookup_name(bdaddr):
target_address = bdaddr
break
if target_address is not None:
c = Color("green")
print "***True"
lazylights.set_state(bulbs1, c.hue * 360, (c.saturation), c.luminance,
3500, (500), False)
else:
c = Color("yellow")
print "***False"
lazylights.set_state(bulbs1, c.hue * 360, (c.saturation), c.luminance,
3500, (500), False)
def clock(ctx, color, ampm):
if(color):
c = color_convert(Color(color).get_rgb())
ctx.obj['dev'].send(set_time_color(c[0],c[1],c[2],0xff,not ampm))
else:
ctx.obj['dev'].send(switch_view("clock"))
import pandas
import matplotlib as ma
import gmplot
from colour import Color
import pygmaps
import matplotlib.pyplot as plt
import numpy
import scipy
from scipy.cluster.vq import kmeans2, whiten
data = pandas.read_csv("work.csv")
columns = ['TRIP_ID','TAXI_ID','TIMESTAMP','DAY_TYPE','POLYLINE']
main_data = data[columns]
red = Color("red")
blue = Color("blue")
array_color = list(red.range_to(blue, main_data.shape[0]))
all_location = []
str = main_data['POLYLINE'][1]
str = str.split("],[")
str[0] = str[0].split("[[")[1]
str[len(str)-1] = str[len(str)-1].split("]]")[0]
str = [x.split(",") for x in str]
str = [[float(x),float(y)] for [x,y] in str]
lan = [x for [x,y] in str]
lat = [y for [x,y] in str]
path = [(y,x) for [x,y] in str]
gmap = pygmaps.maps(lat[0],lan[0],12)
all_location += str
for i in range(2,100):
if main_data['POLYLINE'][i] != '[]':
import pandas as pd
import datetime
from colour import Color
import datetime
import random
app = Flask(__name__)
# set up api and caching
api = Api(app)
cache = Cache(app, config={'CACHE_TYPE': 'simple'})
with app.app_context():
MAX_DECIMALS = 3
# get color range for station status and bike angels
red = Color("red")
green = Color("green")
colors = list(green.range_to(red, 101))
months = [
'January', 'February', 'March', 'April', 'May', 'June', 'July',
'August', 'September', 'October', 'November', 'December'
]
## get current status and merge that with stations
sa_data_url = "https://github.com/cdepeuter/dsi-waterquality-data/raw/master/flask-app/data/south_africa_data.csv"
x = requests.get(url=sa_data_url).content
sa_data = pd.read_csv(io.StringIO(x.decode('utf8')))
print("sa data columns", sa_data.columns)
## local for testing
#sa_data = pd.read_csv("data/south_africa_data.csv")
def set_color(self, color):
self.highlight(color)
self.color = Color(color)
return self
from colour import Color
input = []
while (len(input) < 49):
input.extend(raw_input().split())
output = []
for color_text in input:
c = Color(color_text)
c.luminance = c.luminance / 2
output.append(c.hex_l)
for _ in range(7):
for _ in range(7):
print output.pop(0) + " ",
print
# -*- coding: utf-8 -*-
import dash
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd
import datetime
from colour import Color
app = dash.Dash()
server = app.server
# Variables
text_style = dict(color='#444', fontFamily='sans-serif', fontWeight=300)
colors = list(Color('#68ff68').range_to(Color('#ff6868'),14))
# Import data and adjust entero count
df = pd.read_csv('https://raw.githubusercontent.com/ilyakats/'
'CUNY-DATA608/master/hw4/'
'riverkeeper_data_2013.csv',
parse_dates=['Date'])
df['EnteroNo'] = df['EnteroCount']
df['EnteroNo'] = df['EnteroCount'].map(lambda x: x.lstrip('<>')).astype(int)
# Format output table
def generate_table(dataframe):
rows = []
for i in range(len(dataframe)):
row = []
for col in dataframe.columns:
value = dataframe.iloc[i][col]
if col=='Site':
def browse_variant(request, histone_type, variant, gi=None):
""""Dispaly the browse variant page
Parameters
----------
request : Django request
histone_type : {"H2A", "H2B", "H3", "H4", "H1"}
variant : str
Name of variant
gi : str or int
GI to select to show it curated sequence browser. Optional. If specified, should open curated sequences page and activate this variant.
"""
# variant = variant.replace("_", "") if "canonical" in variant else variant
#the previous line currenly breaks the code. ALEXEY, 12/30/15
try:
variant = Variant.objects.get(id=variant)
except:
return "404"
#This is a hack to open a page with features from Analyze your seqs page, where we do not know the type
# Then we say type is ALL , ALEXEY
if histone_type=='ALL':
histone_type=Variant.objects.get(id=variant).hist_type
go_to_curated = gi is not None
print gi, "!!!!!!!"
go_to_gi = gi if gi is not None else 0
highlight_human=False
#Here we want always by default highlight human
if not go_to_curated:
try:
go_to_gi=Sequence.objects.filter(variant=variant,taxonomy__id__in=["9606","10090"]).order_by('taxonomy').first().gi
highlight_human=True
except:
pass
green = Color("#66c2a5")
red = Color("#fc8d62")
color_range = map(str, red.range_to(green, 12))
scores = Sequence.objects.filter(
variant__id=variant,
all_model_scores__used_for_classification=True
).annotate(
score=Max("all_model_scores__score")
).aggregate(
max=Max("score"),
min=Min("score")
)
#Distinct will not work here, because we order by "start", which is also included - see https://docs.djangoproject.com/en/dev/ref/models/querysets/#distinct
features_gen = Feature.objects.filter(template__variant="General{}".format(histone_type)).values_list("name", "description", "color").distinct()
features_var = Feature.objects.filter(template__variant=variant).values_list("name", "description", "color").distinct()
features_gen=list(unique_everseen(features_gen))
features_var=list(unique_everseen(features_var))
sequences = Sequence.objects.filter(
variant__id=variant,
all_model_scores__used_for_classification=True
).annotate(
score=Max("all_model_scores__score")
).order_by("score")
human_sequence = sequences.filter(taxonomy__name="h**o sapiens", reviewed=True).first()
# if not human_sequence:
# human_sequence = sequences.filter(taxonomy__name="h**o sapiens").first()
if not human_sequence:
human_sequence = sequences.filter(reviewed=True).first()
print human_sequence
try:
publication_ids = ",".join(map(str, variant.publication_set.values_list("id", flat=True)))
handle = Entrez.efetch(db="pubmed", id=publication_ids, rettype="medline", retmode="text")
records = Medline.parse(handle)
publications = ['{}. "{}" <i>{}</i>, {}. PMID: <a href="http://www.ncbi.nlm.nih.gov/pubmed/?term={}">{}</a>'.format(
"{}, {}, et al".format(*record["AU"][0:2]) if len(record["AU"])>2 else " and ".join(record["AU"]) if len(record["AU"])==2 else record["AU"][0],
record["TI"],
record["TA"],
re.search("\d\d\d\d",record["SO"]).group(0),
record["PMID"],
record["PMID"],
) for record in records]
except:
publications=map(lambda x: "PMID: "+str(x),variant.publication_set.values_list("id", flat=True))
data = {
"hist_type": variant.hist_type.id,
"variant": variant.id,
"name": variant.id,
"features_gen": features_gen,
"features_var": features_var,
"human_sequence":human_sequence.id,
"publications":publications,
"sunburst_url": static("browse/sunbursts/{}/{}.json".format(variant.hist_type.id, variant.id)),
"seed_url": reverse("browse.views.get_seed_aln_and_features", args=[variant.id]),
"colors":color_range,
"score_min":scores["min"],
"score_max":scores["max"],
"browse_section": "variant",
"description": variant.description,
"alternate_names": ", ".join(variant.old_names.values_list("name", flat=True)),
"filter_form": AdvancedFilterForm(),
"go_to_curated":go_to_curated,
"go_to_gi":go_to_gi,
"highlight_human":highlight_human,
}
data["original_query"] = {"id_variant":variant.id}
return render(request, 'browse_variant.html', data)
zurich_lat, zurich_long = 47.36667, 8.55
travel_time.append(cities.iloc[idx]['Travel time'])
# save the data as csv
cities.to_csv('all_cities_CH_time_geo.cvs', sep=',', encoding='utf-8')
# Normalize travel time for the coloring scheme
travel_time = np.array(travel_time)
# Remove a few outliers above 14000 s
travel_time[travel_time > 14000] = 14000
travel_time = normalize_list(travel_time)
unique_times = np.unique(np.array(travel_time))
red = Color("green")
colors = list(red.range_to(Color("red"), cities_shape[0]))
cities.to_csv('new_data2.csv', encoding='utf-8')
# print(travel_time)
# Generate map
gmap1 = gmplot.GoogleMapPlotter(46.8181877, 8.2275124, 9, apikey=API)
for idx, lat_ in enumerate(lat_list):
frac = idx / len(lat_list)
if travel_time[idx] != 0:
color_value = colors[int(travel_time[idx] * cities_shape[0] -
1)].get_hex()
def __init__(self, iterations):
self.steps = int(iterations)
blue = Color('blue')
green = Color('green')
self.grad = list(blue.range_to(green, self.steps))
self.grad += list(green.range_to(blue, self.steps))
def test_set_color_sets_fill_and_stroke():
expected_color = "#EEE777"
svg = SVGMobject(get_svg_resource("heart.svg"), color=expected_color)
assert svg.color == Color(expected_color)
assert svg.fill_color == Color(expected_color)
assert svg.stroke_color == Color(expected_color)
image = image.resize((width, height), resample=Image.ANTIALIAS)
rendered_card_data[name] = np.array(image)
print 'done.'
say('ready')
# Setup the output image for the debug and gameplay windows.
output_image_width = output_card_height * cards_per_col
display_width_buffer = output_card_width
output_image_height = (output_card_width * max_number_of_cols +
display_width_buffer +
output_card_width * max_number_of_cols +
output_card_width)
gameplay_output_frame_width = 1000
# Setup a green-to-red color gradient for drawing rectangles.
red = Color('red')
lime = Color('lime')
gradient = list(red.range_to(lime, 100))
# Start the camera.
while True:
_, frame = vc.read()
if frame is not None:
# Get time for fps.
now = time.time()
# Set white threshold.
lower_white = np.array([0, 0, 255-sensitivity])
upper_white = np.array([255, sensitivity, 255])
def hexcolor (cls, color) :
return Color(color).hex_l
def setPalette(self, plist):
self.palette = []
for item in plist:
self.palette.append(Color(item))
def to_color(self):
return Color(self.name)
os.putenv('SDL_FBDEV', '/dev/fb1')
pygame.init()
#initialize the sensor
sensor = Adafruit_AMG88xx()
points = [(math.floor(ix / 8), (ix % 8)) for ix in range(0, 64)]
grid_x, grid_y = np.mgrid[0:7:32j, 0:7:32j]
#sensor is an 8x8 grid so lets do a square
height = 240
width = 240
#the list of colors we can choose from
blue = Color("indigo")
colors = list(blue.range_to(Color("red"), COLORDEPTH))
#create the array of colors
colors = [(int(c.red * 255), int(c.green * 255), int(c.blue * 255))
for c in colors]
displayPixelWidth = width / 30
displayPixelHeight = height / 30
lcd = pygame.display.set_mode((width, height))
lcd.fill((255, 0, 0))
pygame.display.update()
pygame.mouse.set_visible(False)
if len(sys.argv) == 2:
clean = (sys.argv[1] == 'clean')
SMALL_SIZE = 8
MEDIUM_SIZE = 10
BIGGER_SIZE = 20
plt.rc('font', size=BIGGER_SIZE) # controls default text sizes
plt.rc('axes', titlesize=BIGGER_SIZE) # fontsize of the axes title
plt.rc('axes', labelsize=BIGGER_SIZE) # fontsize of the x and y labels
a_s = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
q_st = 0.707
p_st = 0.3
begin_color = Color("blue")
colors = list(begin_color.range_to(Color("green"), len(a_s)))
plt.figure(1).set_size_inches((8, 8), forward=False)
i = 0
for a in a_s:
create.multiplicity_function(q_st, p_st, a, clean=clean)
x_axis = dat.get_x_axis_multiplicity_function(q_st, p_st, a)
column = dat.get_column_multiplicity_function(q_st, p_st, a)
plt.plot(x_axis, column, color=colors[i].rgb, label="a={0}".format(a))
i += 1
plt.xscale('log')
