def annotate_image(self, string):
top_text, bot_text = string.split(',')
top_label = CoreLabel(text=top_text,
font_size=50,
text_size=(800, 80),
halign='center',
valign='top',
outline_width=10,
outline_color=(50, 50, 50))
bot_label = CoreLabel(text=bot_text,
font_size=50,
text_size=(800, 80),
halign='center',
valign='bottom',
outline_width=10)
top_label.refresh()
bot_label.refresh()
top_tex = top_label.texture
bot_tex = bot_label.texture
with self.canvas:
Color(0, 0, 0)
Rectangle(size=top_tex.size, pos=(0, 400))
Rectangle(size=bot_tex.size, pos=(0, 0))
Color(255, 255, 255)
Rectangle(size=top_tex.size, pos=(0, 400), texture=top_tex)
Rectangle(size=bot_tex.size, pos=(0, 0), texture=bot_tex)
pass
def __init__(self, canvas, **kwargs):
self.camera = Camera()
self.static_background = canvas
self.static_air_label = CoreLabel(text='Air', font_size=15)
self.air_label = CoreLabel(text='0%', font_size=15)
self.static_paint_label = CoreLabel(text='Paint', font_size=15)
self.paint_label = CoreLabel(text='0%', font_size=15)
self.paintDisplayBackground()
def __init__(self, points=[], loop=False, *args, **kwargs):
super(BezierTest, self).__init__(*args, **kwargs)
self.d = 10 # pixel tolerance when clicking on a point
self.points = points
self.loop = loop
self.saved_points = []
self.line_height = 0
self.current_point = None # index of point being dragged
self.GA = threading.Thread(target=RunGA, args=(self, ))
self.GA.start()
print "Spin thread."
self.label = CoreLabel(text=LSTM.trade_stocks[0], font_size=20)
self.label.refresh()
self.label2 = CoreLabel(text=LSTM.trade_stocks[0], font_size=10)
self.label2.refresh()
self.label3 = CoreLabel(text=LSTM.trade_stocks[0], font_size=10)
self.label3.refresh()
with self.canvas:
Color(1.0, 0.0, 0.0)
#self.cb = Callback(self.my_callback)
Color(0.1, 0.1, 0.1)
seg = 1300 / 6
Line(points=[75, 0, 75, 800], width=0.8, close=False)
Line(points=[seg, 0, seg, 800], width=0.8, close=False)
Line(points=[seg * 2, 0, seg * 2, 800], width=0.8, close=False)
Line(points=[seg * 3, 0, seg * 3, 800], width=0.8, close=False)
Line(points=[seg * 4, 0, seg * 4, 800], width=0.8, close=False)
Line(points=[seg * 5, 0, seg * 5, 800], width=0.8, close=False)
Line(points=[seg * 6, 0, seg * 6, 800], width=0.8, close=False)
Line(points=[1335, 0, 1335, 800], width=5, close=False)
'''self.bezier = Bezier(
points=self.points,
segments=150,
loop=self.loop,
dash_length=100,
dash_offset=10)
'''
Color(0.0, 0.0, 1.0)
self.line1 = Line(points=self.points, width=0.8, close=False)
"""s = Slider(y=0, pos_hint={'x': .3}, size_hint=(.3, None), height=20)
def __init__(self, **kwargs):
super(TestApp, self).__init__(**kwargs)
Window.bind(on_key_down=self.onKeyDown)
self.key_label = CoreLabel(text='', font_size=15)
self.hud = HUD(self.canvas)
self.gps_status_label = CoreLabel(text='', font_size=12)
self.gps_location_label = CoreLabel(text='', font_size=12)
self.uid_label = CoreLabel(text='UID: ', font_size=12)
self.my_lat = 0
self.my_lon = 0
self.my_heading = 0
def btn_left(self, flayout, text_input):
if text_input.text != "":
str2 = text_input.text
float = FloatLayout()
float.pos_hint = {'x': 0, 'y': 0}
my_label = CoreLabel()
my_label.text = str2
my_label.refresh()
newsize = my_label.size
mybtn = Button(text=str2,
size_hint_y=None,
size_hint_x=None,
size=(newsize[0] + 10, newsize[1] + 10),
pos_hint={
'x': 0,
'y': 0
})
mybtn.font_size = 12
mybtn.font_name = 'Arial'
mybtn.border = 0, 0, 0, 0
mybtn.background_normal = 'gr.png'
float.add_widget(mybtn)
flayout.add_widget(float)
text_input.text = ""
def draw_ticks(self):
scangle = self.angle_stop - self.angle_start
inc = scangle / (
(self.scale_max - self.scale_min) / self.scale_increment)
inc /= self.tic_frequency
cnt = 0
# create an instruction group so we can remove it and recall draw_ticks to update when pos or size changes
self.ticks = InstructionGroup()
self.ticks.add(Color(*self.tic_color))
labi = self.scale_min
x = -180.0 + self.angle_start + self.angle_offset # start
while x <= self.angle_stop - 180 + self.angle_offset:
a = x if (x < 0.0) else x + 360.0
need_label = True
ticlen = self.tic_length
if (cnt % self.tic_frequency != 0):
ticlen = self.tic_length / 2
need_label = False
cnt += 1
self.ticks.add(PushMatrix())
self.ticks.add(
Rotate(angle=a,
axis=(0, 0, -1),
origin=(self.dial_center[0], self.dial_center[1])))
self.ticks.add(Translate(0, self.tic_radius - ticlen))
self.ticks.add(
Line(points=[
self.dial_center[0], self.dial_center[1],
self.dial_center[0], self.dial_center[1] + ticlen
],
width=self.tic_width,
cap='none',
joint='none'))
if need_label:
#print("label: " + str(labi))
#kw['font_size'] = self.tic_length * 2
label = CoreLabel(text=str(int(round(labi))),
font_size=self.scale_font_size)
label.refresh()
texture = label.texture
self.ticks.add(
Translate(-texture.size[0] / 2, -texture.size[1] - 2))
self.ticks.add(
Rectangle(texture=texture,
pos=self.dial_center,
size=texture.size))
labi += self.scale_increment
self.ticks.add(PopMatrix())
x += inc
self.canvas.add(self.ticks)
def __init__(self, pattern=None, key=None, aggregate=0):
super(ScoreViewer, self).__init__(size=(Window.width, Window.height))
self.info = topleft_label()
self.add_widget(self.info)
self.info.text = 'Press SPACE to shift through bars'
self.pattern = pattern
self.key = key
self.canvas.add(Color(.3, .3, .3))
crect = CRectangle(cpos=(Window.width // 2, Window.height // 2),
csize=(Window.width, Window.height))
self.canvas.add(crect)
self.canvas.add(Color(1, 1, 1))
self.card = CRectangle(cpos=(Window.width // 2, Window.height // 2),
csize=(self.width // 4, self.height // 4))
text = "No Info right now"
label = CoreLabel(text, pos=self.card.cpos)
label.refresh()
self.card.texture = label.texture
self.canvas.add(self.card)
self.gui = KeyboardGui()
self.canvas.add(self.gui)
self.player = DataPlayer(callback=self.gui.preview)
self.barNum = -1
#self.score_dict = {}
self.data = None
self.barData = None
def affiche_timer(self, texte, size, a, b):
mylabel = CoreLabel(text=texte, font_size=size, color=(1, 1, 1, 1))
mylabel.refresh()
texture = mylabel.texture
texture_size = list(texture.size)
with self.canvas:
Rectangle(pos=(a, b), texture=texture, size=texture_size)
def __init__(self, **kwargs):
super(CircularProgressBar, self).__init__(**kwargs)
self.thickness = 35
self.label = CoreLabel(text="0%", font_size=60)
self.texture_size = None
self.refresh_text()
self.draw()
def __init__(self, combo, second):
super(ComboDisplay, self).__init__()
self.combo = combo
font_size = 25
self.pos = [Window.width / 2, Window.height / 2 + 100]
self.size = (100, 25)
self.box = Rectangle(pos=self.pos, size=self.size)
box_color = Color(0, 0, 0, 0)
self.add(box_color)
self.add(self.box)
label = CoreLabel(text='Combo %d' % (self.combo), font_size=font_size)
# the label is usually not drawn until needed, so force it to draw
label.refresh()
# now access the texture of the label and use it
texture = label.texture
self.color = Color(0, 0, 1)
self.add(self.color)
text_pos = list(self.pos[i] + (self.size[i] - texture.size[i]) / 2
for i in range(2))
self.label = Rectangle(size=texture.size,
pos=text_pos,
texture=texture)
self.add(self.label)
max_time = 1
self.alpha_anim = KFAnim((second, 1),
(second + max_time, 0)) # color disappears
self.set_second(second)
def update(self, dt):
with self.canvas:
for entity, a in self.entity_manager.pairs_for_type(Accumulateur):
# Couleur du texte rgba
if a.full():
Color(0.7, 0, 0) # rouge c'est plein
elif a.empty():
Color(0, 1, 1) # cyan c'est vide
elif a.get() < a.dispo(
): # tout n'est pas dispo (a cause de transit)
Color(1, 1, 0) # jaune c'est partiellement dispo
else:
Color(0, 1, 0) # vert tout est dispo
if not float(a.get()).is_integer():
s = str(round(a.get(), 3))
if a.getmax() != Accumulateur.infini:
s += "/" + str(round(a.getmax(), 3))
else:
s = str(a.get())
if a.getmax() != Accumulateur.infini:
s += "/" + str(a.getmax())
my_label = CoreLabel(text=s, font_size=14)
# the label is usually not drawn until needed, so force it to draw.
my_label.refresh()
# Now access the texture of the label and use it wherever
x_texture = my_label.texture
li = self.entity_manager.component_for_entity(
entity, simulation.graphe.Ligne)
Rectangle(size=x_texture.size, pos=li.ptxt, texture=x_texture)
def __init__(self, accuracy, pos, second):
super(AccuracyDisplay, self).__init__()
self.accuracy = accuracy
font_size = 25
self.pos = pos
self.size = (100, 25)
self.box = Rectangle(pos=pos, size=self.size)
box_color = Color(0, 0, 0, 0)
self.add(box_color)
self.add(self.box)
label = CoreLabel(text=self.accuracy, font_size=font_size)
# the label is usually not drawn until needed, so force it to draw
label.refresh()
# now access the texture of the label and use it
texture = label.texture
if accuracy == "Perfect":
self.color = Color(0, 1, 0)
elif accuracy == "Good":
self.color = Color(1, 127 / 255, 80 / 255)
elif accuracy == "Miss":
self.color = Color(1, 0, 0)
self.add(self.color)
text_pos = list(self.pos[i] + (self.size[i] - texture.size[i]) / 2
for i in range(2))
self.label = Rectangle(size=texture.size,
pos=text_pos,
texture=texture)
self.add(self.label)
max_time = 2
self.alpha_anim = KFAnim((second, 1),
(second + max_time, 0)) # color disappears
self.set_second(second)
def draw_text(pos, text, **kw):
label = CoreLabel(text=text, bold=True, **kw)
label.refresh()
Rectangle(texture=label.texture,
pos=(pos[0] - label.texture.size[0] / 2,
pos[1] - label.texture.size[1] / 2),
size=label.texture.size)
def redraw(self):
self.canvas.clear()
with self.canvas:
Color(*COL_FG)
total_ticks = int(self.total_axis_space / self.space_btw_marks)
for i in range(total_ticks):
if i % 5 == 0:
# Long Mark
mark = self.mark_length
else:
# Short Mark
mark = self.mark_length / 2
Line(points=[
self.fwidth - mark, i *
self.space_btw_marks, self.fwidth, i *
self.space_btw_marks, self.fwidth, (i + 1) *
self.space_btw_marks
])
i = int(self.total_axis_space / self.space_btw_marks)
Line(points=[
self.fwidth - self.mark_length, i *
self.space_btw_marks, self.fwidth, i * self.space_btw_marks
])
for i in range(int(total_ticks / 5) + 1):
label = CoreLabel()
label.text = "{:.1f}".format(0.1 * i)
label.refresh()
label_texture = label.texture
texture_size = list(label_texture.size)
Rectangle(texture=label_texture,
size=[s * 0.9 for s in texture_size],
pos=(0, i * 5 * self.space_btw_marks - 2))
def get_label_texture(self,
index,
succinct=True,
return_kw=False,
return_label=False,
**kw):
if isinstance(index, Number):
t = self.datetime_of(index)
else:
t = index
if self.mode == 'second':
return None
if self.mode == 'day':
# need to get the datetime of the previous day
text = (t - timedelta(seconds=1)).strftime('%a\n%m-%d-%y')
kw.setdefault('height', 50)
elif 'second' not in self.mode and succinct:
text = str(t.time())[:-3]
else:
text = str(t.time())
kw.setdefault('height', 20)
kw['text'] = text
if return_kw:
return kw
if not return_label:
return CoreLabel(**kw).texture
label = AutoSizeLabel(**kw)
label.texture_update()
return label
def draw_plot(self, node, color=None, depth=0, angle=0, parent_angle=360):
if depth > 2:
return None
highlighted_node = None
for idx, child in enumerate(node.get_children()):
segm_color = (idx % len(self.colors)) if color is None else color
w, h = self.size
child_angle = child.get_size() / \
child.get_size_parent_directory() * parent_angle
if child_angle < 2:
continue
cx = w / 2
cy = h / 2
r = 100 + 50 * depth
segment_width = 50
angle_start = angle
angle_end = angle + child_angle
mouse_in_segment = self.mouse_in_segment(cx, cy, r, segment_width,
angle_start, angle_end)
if mouse_in_segment:
highlighted_node = child
self.draw_segment(cx, cy, r, segment_width, angle_start, angle_end,
self.colors[segm_color][depth], mouse_in_segment)
highlighted_node = self.draw_plot(
child, segm_color, depth+1, angle, child_angle) or \
highlighted_node
angle += child_angle
if highlighted_node and depth == 0:
label = CoreLabel(text=highlighted_node.get_name(), font_size=20)
label.refresh()
text = label.texture
Rectangle(size=text.size, pos=(0, 0), texture=text)
return highlighted_node
def show_solution(self, present):
if present is None:
self.add_widget(
Label(text="No solution", color=(0, 1, 0, 1), size=self.size))
return
with self.canvas:
Color(0, 0, 0, 1)
Rectangle(pos=(0, 0), size=self.size)
height = len(present)
width = len(present[0])
self.grid_layout.cols = height
self.grid_layout.rows = width
for x in range(width):
for y in range(height):
symbol = present[y][x]
if symbol != '#':
Color(0, 1, 0, 1)
text = "" if symbol == "&&" else symbol
label = CoreLabel(text=text, font_size=20)
label.refresh()
coord_x = x * self.CELL_SIZE + self.OFFSET
top_offset = (y + 1) * self.CELL_SIZE
coord_y = self.height - top_offset + self.OFFSET
Rectangle(pos=(coord_x, coord_y),
texture=label.texture,
size=label.texture.size)
self.draw_empty_rectangle(x, self.height - top_offset)
def _required_size_for_cells(cells: List[List[AutosizeTableCell]],
base_font_size: float) -> Tuple[int, int]:
required_width = 0
required_height = 0
label = None
last_font_size = -1
for row in cells:
row_height = 0
sumw = sum([cell.layout_weight for cell in row])
weight_ratios = [sumw / cell.layout_weight for cell in row]
for cell, wrat in zip(row, weight_ratios):
fsize = base_font_size * cell.relative_font_size
# Updating an existing label's font size doesn't affect its computed
# size, so we have to recreate it if the font size changes.
if label is None or last_font_size != fsize:
debug(f'New label: {fsize}')
pad = fsize * cell.relative_padding
label = CoreLabel(font_size=fsize, padding=pad)
last_font_size = fsize
label.text = cell.text
label.refresh()
size = label.texture.size
required_width = max(required_width, size[0] * wrat)
row_height = max(row_height, size[1])
required_height += row_height
return (required_width, required_height)
def ticks_instructions(cls, axes_offsets, axes_sizes, dates_exces):
x_ticks = InstructionGroup()
ticks_len = 5
if len(dates_exces) != 0:
x_ticks_distance = axes_sizes[0] / len(dates_exces)
else:
x_ticks_distance = 0
yyyy_mm_dd = [x.split(' ')[0] for (x, y) in dates_exces]
for i, d in enumerate(yyyy_mm_dd):
x_ticks.add(
Line(points=[
axes_offsets[0] + (i + 1) * x_ticks_distance,
axes_offsets[1],
axes_offsets[0] + (i + 1) * x_ticks_distance,
axes_offsets[1] - ticks_len
],
width=3))
text_label = CoreLabel(text=d, font_size=15)
text_label.refresh()
texture = text_label.texture
texture_size = list(texture.size)
x_ticks.add(
Rectangle(texture=texture,
size=texture_size,
pos=(axes_offsets[0] + (i + 1) * x_ticks_distance -
45, axes_offsets[1] - ticks_len - 25)))
return x_ticks
def draw_text_on_canvas(arg_text, font_size=12, **kwargs):
# get text texture
label = CoreLabel(text=arg_text, font_size=font_size)
label.refresh()
tex = label.texture
# draw text
return Rectangle(size=tex.size, texture=tex, **kwargs)
def draw_text(pos, text, font_name=None, **kw):
label = CoreLabel(text=text, bold=True, font_name=font_name or i18n.font_name, **kw) #
label.refresh()
Rectangle(
texture=label.texture,
pos=(pos[0] - label.texture.size[0] / 2, pos[1] - label.texture.size[1] / 2),
size=label.texture.size,
)
def get_label_texture(self, index, **kw):
if self.invert: index *= -1
label = CoreLabel(text=get_str_date(index, self.strftime) if self.strftime else \
self.rollinglist[self.slot_value(index)] if len(self.rollinglist) else \
self.value_str(self.slot_value(index)),
font_size=self.font_size, **kw)
label.refresh()
return label.texture
def get_text_width(text, font, root=None):
logging.info("get_text_width: %s %s" % (text, font))
label = CoreLabel()
label.text = text
label.refresh()
return label.content_width
def label_size(text: str, font_size: float) -> Tuple[int, int]:
label = CoreLabel(text=text, font_size=font_size)
label.refresh()
r1 = label.texture.size
label.text = text + text
label.refresh()
r2 = label.texture.size
return r1 + r2
def __init__(self, **kwargs):
super(TestApp, self).__init__(**kwargs)
Window.bind(on_key_down=self.onKeyDown)
Window.bind(on_touch_down=self.onTouch) #TOUCH CAPABILITY
self.touch_count = 0 #TOUCH CAPABILITY DEBUGGING COUNTER
self.touch_count_label = CoreLabel(
text='', font_size=15) #TOUCH CAPABILITY DEBUGGING COUNTER
self.key_label = CoreLabel(text='', font_size=15)
self.hud = HUD(self.canvas)
self.gps_status_label = CoreLabel(text='', font_size=12)
self.gps_location_label = CoreLabel(text='', font_size=12)
self.uid_label = CoreLabel(text='UID: ', font_size=12)
self.my_lat = 0
self.my_lon = 0
self.my_heading = 0
self.my_accuracy = 0
self.DEBUG = True
def build_canvas(self, dt):
# get 3 textures
curdir = dirname(__file__)
arrow_left = CoreImage(join(curdir, 'arrow_left.png')).texture
arrow_middle = CoreImage(join(curdir, 'arrow_middle.png')).texture
arrow_right = CoreImage(join(curdir, 'arrow_right.png')).texture
self.canvas.before.clear()
with self.canvas.before:
cmax = ((self.date_end - self.date_start) / float(self.date_step))
x, y = self.pos
w, h = self.size
fh = 100
bh = 10
cy = y + h / 2
h = fh * 2
r = range(self.date_start, self.date_end, self.date_step)
for index, cx in enumerate(r):
alpha = (cx - self.date_start) / (float(self.date_end) -
float(self.date_start))
# create background of arrow (part of)
c = 0.9 - (0.4 * alpha)
a = 1.0 - 0.4 * alpha
Color(c, c, c, a)
if index == 0:
texture = arrow_left
border = (2, 2, 2, 8)
elif index == len(r) - 1:
texture = arrow_right
border = (2, 126, 2, 2)
else:
texture = arrow_middle
border = (2, 0, 2, 0)
BorderImage(pos=(x, cy - fh), size=(w/cmax, h), texture=texture,
border=border)
# create lines
x = int(x)
if index > 0:
Color(1, 1, 1, .8)
Line(points=[x, cy - fh - bh, x, cy + fh + bh])
# create label (333f43)
label = CoreLabel(text=str(cx),
font_size=14, font_name='fonts/DroidSans.ttf')
label.refresh()
Color(0x33/255., 0x3f/255., 0x43/255.)
# trick to invert the label orientation
tc = label.texture.tex_coords
th, tw = label.texture.size
tc = tc[-2:] + tc[0:-2]
Rectangle(pos=(x + 5, cy - th / 2), size=(tw, th),
texture=label.texture, tex_coords=tc)
x += w / cmax
def draw_box_and_label(self, images, rects, centers, predictions): canvas = self.ids.monitor.canvas canvas.clear() for img, rect, c, p, acc in zip(images, rects, centers, predictions.get_all_labels(), predictions.get_all_accuraces()): #Color if p[0] < 5: color = (0.75, 0.40, 0.62, 1) elif p[0] >= 5 and p[0] < 9: color = (0.40, 0.75, 0.62, 1) elif p[0] >= 8: color = (0.7, 0.7, 0.7, 1) r,g,b,_ = color label_text = LABEL[p[0]] label = CoreLabel(text="Rank :%s"%(label_text), font_size=30, color=color, italic=True) label.refresh() texture = label.texture texture_size = list(texture.size) h,w,_ = img.shape cm = h * PX2CM_FACTOR length = CoreLabel(text="Length:%.1fcm"%(cm), font_size=30, color=color, italic=True) length.refresh() texture2 = length.texture texture2_size = list(texture2.size) accuracy = CoreLabel(text="Accuracy:%d"%(int(acc[0]*100))+"%", font_size=30, color=color, italic=True) accuracy.refresh() texture3 = accuracy.texture texture3_size = list(texture3.size) label2_text = LABEL[p[1]] label2 = CoreLabel(text="(%s)"%(label2_text), font_size=20,italic=True) label2.refresh() texture4 = label2.texture texture4_size = list(texture4.size) with canvas: Color(r, g, b) Line(points=rect, width=3, close=True) Line(points=[(c[0]-5, 110), (c[0]-35, 5), (c[0] + texture2_size[0], 5)], width=1, color=color) Rectangle(texture=texture, pos=(c[0], texture3_size[1]*2+5), size=texture_size) Rectangle(texture=texture3, pos=(c[0]-7 , texture2_size[1]+5), size=texture3_size) Rectangle(texture=texture2, pos=(c[0]-14, 5), size=texture2_size) Color(0.7,0.7,0.7) Rectangle(texture=texture4, pos=(c[0] + texture_size[0] + 10, texture3_size[1]*2+10), size=texture4_size)
def plot_sets_reps(cls, dates_exces, axes_offset, axes_size):
sets_reps_instr = InstructionGroup()
if len(dates_exces) != 0:
distance_between_centers = axes_size[0] / len(dates_exces)
else:
distance_between_centers = 0
max_total = 0
for d, ex in dates_exces:
# move to sep function
ex_total = 0
reps = ex.description.get("reps")
for r in reps:
try:
ex_total = ex_total + int(r)
except ValueError:
ex_total = ex_total + 0
if ex_total > max_total:
max_total = ex_total
if max_total != 0:
y_distance = axes_size[1] / (max_total + 1)
else:
y_distance = 0
for i, (d, ex) in enumerate(dates_exces):
sets = ex.description.get("sets")
reps = ex.description.get("reps")
weights = ex.description.get("weights")
int_reps = []
for r in reps:
try:
int_reps.append(int(r))
except ValueError:
int_reps.append(0)
for i_r, r in enumerate(int_reps):
y_pos_top = axes_offset[1] + \
sum( int_reps[0:i_r+1] ) * y_distance
y_pos_bottom = axes_offset[1] + \
sum( int_reps[0:i_r] ) * y_distance
x_center_pos = \
axes_offset[0] + distance_between_centers * (i + 1)
x_size = 10
y_size = y_pos_top - y_pos_bottom
sets_reps_instr.add(
Line(points=[
x_center_pos - 5, y_pos_top, x_center_pos + 5,
y_pos_top
],
width=3))
text_label = CoreLabel(text=str(r), font_size=15)
text_label.refresh()
texture = text_label.texture
texture_size = list(texture.size)
sets_reps_instr.add(
Rectangle(texture=texture,
size=texture_size,
pos=(x_center_pos - 10, y_pos_bottom +
(y_pos_top - y_pos_bottom) / 2)))
return sets_reps_instr
def load(self,dt):
center = Window.center
progressbar = CircularProgressBar(pos=('400','250'))
progressbar.font_size = '20sp'
progressbar.label = CoreLabel('Loading our model!');
progressbar.thickness = 5
progressbar.progress_colour = (1,1,0,1)
self.add_widget(progressbar)
Clock.schedule_interval(self.animate, 0.25)
def plot_dists_times(cls, dates_exces, axes_offset, axes_size):
dists_times_instr = InstructionGroup()
if len(dates_exces) != 0:
distance_between_centers = axes_size[0] / len(dates_exces)
else:
distance_between_centers = 0
max_total = 0
for d, ex in dates_exces:
# move to sep function
ex_total = 0
dists = ex.description.get("distances")
for dist in dists:
try:
ex_total = ex_total + float(dist)
except ValueError:
ex_total = ex_total + 0
if ex_total > max_total:
max_total = ex_total
if max_total != 0:
y_distance = axes_size[1] / (max_total + 1)
else:
y_distance = 0
for i, (d, ex) in enumerate(dates_exces):
distances = ex.description.get("distances")
times = ex.description.get("times")
float_dists = []
for dist in distances:
try:
float_dists.append(float(dist))
except ValueError:
float_dists.append(0)
for f_d, d in enumerate(float_dists):
y_pos_top = axes_offset[1] + \
sum( float_dists[0:f_d+1] ) * y_distance
y_pos_bottom = axes_offset[1] + \
sum( float_dists[0:f_d] ) * y_distance
x_center_pos = \
axes_offset[0] + distance_between_centers * (i + 1)
x_size = 10
y_size = y_pos_top - y_pos_bottom
dists_times_instr.add(
Line(points=[
x_center_pos - 5, y_pos_top, x_center_pos + 5,
y_pos_top
],
width=3))
text_label = CoreLabel(text=str(d), font_size=15)
text_label.refresh()
texture = text_label.texture
texture_size = list(texture.size)
dists_times_instr.add(
Rectangle(texture=texture,
size=texture_size,
pos=(x_center_pos - 10, y_pos_bottom +
(y_pos_top - y_pos_bottom) / 2)))
return dists_times_instr
