def update(self, ctx):
r,g,b,a = self.color
if ctx.layers.get(self.layer):
a = interpolate(a, 1.0)
else:
a = interpolate(a, 0.0)
self.color = (r,g,b,a)
super(LayerMarker, self).update(ctx)
def update(self):
s = self.scatter.scale
if s < 1.5 and not self.scatter._touches:
self.scatter.center = interpolate(self.scatter.center, self.center, 30)
if s < 1.8 and not self.scatter._touches:
self.scatter.center = interpolate(self.scatter.center, self.center, 40)
if s < 1 and not self.scatter._touches:
self.scatter.scale = interpolate(self.scatter.scale, 1.0, 40)
xpan = self.scatter.center_x - self.center_x
ypan = self.scatter.center_y - self.center_y
tx = xpan/float(1920)
ty = ypan/float(1920)
mat = Matrix().scale(s,s,s).translate(tx,ty,0)
self.t_viewtrans.matrix = mat
def test_interpolate_multi(self):
x = [10., 19., 27.1]
y = [-10., -19., -27.1]
p = 0., 0.
for i in range(0, 3):
p = interpolate(p, [100, -100])
self.assertEqual(p, [x[i], y[i]])
def test_interpolate_multi(self):
x = [10., 19., 27.1]
y = [-10., -19., -27.1]
p = 0., 0.
for i in range(0, 3):
p = interpolate(p, [100, -100])
self.assertEqual(p, [x[i], y[i]])
def _update_progress_interval(self, delta_time):
if not self.updating_progress:
self.updating_progress = True
if self.player.current_track and self.player.playback_started and self.player.playing:
# time_played_ms = pygame.mixer.music.get_pos()
# duration_ms = int(self.musicmanager.current_track['duration_ms'])
# progress = time_played_ms / (duration_ms / 100)
progress_percent = self.player.send_cmd_to_mplayer(
'get_percent_pos', 'ANS_PERCENT_POSITION')
if progress_percent is not False and progress_percent is not None:
old_progress_percent = self.player.progress_percent
self.player.progress_percent = interpolate(
old_progress_percent, int(progress_percent))
Logger.trace('Progress: ' +
str(self.player.progress_percent))
elif progress_percent is False:
Logger.debug('_update_progress_interval: Received ' +
str(progress_percent) + ' as progress')
self.player.playback_finished()
self.play_next_track()
else:
Logger.debug('_update_progress_interval: Received ' +
str(progress_percent) + ' as progress')
# remove schedule if no track selected
elif not self.player.playback_started and not self.player.playing:
Logger.debug(
'No song playing, removing slider update interval..')
self.updating_progress = False
return False
self.updating_progress = False
def get_bricks_and_target_pos(self):
left_brick = self.choose_left_brick()
right_brick = self.choose_right_brick()
if right_brick is not None:
target_pos_by_right = (right_brick.target_x - self.width,
right_brick.target_y)
if left_brick is not None:
target_pos_by_left = tuple(left_brick.target_right_pos)
distance_from_left = (Vector(self.target_pos)
.distance(left_brick.target_right_pos))
distance_from_right = (Vector(self.target_right_pos)
.distance(right_brick.target_pos))
if self.can_attach_to_both(
left_brick, right_brick,
target_pos_by_left, target_pos_by_right,
distance_from_left, distance_from_right):
target_pos = interpolate(target_pos_by_left,
target_pos_by_right,
step=2)
elif self.should_attach_to_left(
left_brick, right_brick,
distance_from_left, distance_from_right):
target_pos = target_pos_by_left
right_brick = None
else:
target_pos = target_pos_by_right
left_brick = None
else:
target_pos = target_pos_by_right
elif left_brick is not None:
target_pos = left_brick.target_right_pos
else:
target_pos = None
return left_brick, right_brick, target_pos
def get_bricks_and_target_pos(self):
left_brick = self.choose_left_brick()
right_brick = self.choose_right_brick()
if right_brick is not None:
target_pos_by_right = (right_brick.target_x - self.width,
right_brick.target_y)
if left_brick is not None:
target_pos_by_left = tuple(left_brick.target_right_pos)
distance_from_left = (Vector(self.target_pos).distance(
left_brick.target_right_pos))
distance_from_right = (Vector(self.target_right_pos).distance(
right_brick.target_pos))
if self.can_attach_to_both(left_brick, right_brick,
target_pos_by_left,
target_pos_by_right,
distance_from_left,
distance_from_right):
target_pos = interpolate(target_pos_by_left,
target_pos_by_right,
step=2)
elif self.should_attach_to_left(left_brick, right_brick,
distance_from_left,
distance_from_right):
target_pos = target_pos_by_left
right_brick = None
else:
target_pos = target_pos_by_right
left_brick = None
else:
target_pos = target_pos_by_right
elif left_brick is not None:
target_pos = left_brick.target_right_pos
else:
target_pos = None
return left_brick, right_brick, target_pos
def reset_zoom(self, *args):
# rotation = 360. if self.scatter.rotation > 180 else 0.
# Animation(rotation=rotation, scale=1., center=self.center,
# d=0.5, t='out_quart').start(self.scatter)
self.scatter.scale = interpolate(self.scatter.scale, 1.0)
self.scatter.center = interpolate(self.scatter.center, self.center)
if self.scatter.rotation > 200:
self.scatter.rotation = interpolate(self.scatter.rotation, 360.0)
else:
self.scatter.rotation = interpolate(self.scatter.rotation, 0.0)
if (
abs(1.0 - self.scatter.scale) < 0.1
and abs(self.scatter.center_x - self.center_x) < 10
and abs(self.scatter.center_y - self.center_y) < 10
):
return
Clock.schedule_once(self.reset_zoom, 1 / 60.0)
def move(self, dt):
"""
Moves the vehicle according to Simple Vehicle Model principles.
This method is called by self.parent repeatedly.
"""
self.calculate_new_lookup_point()
self.velocity = self.calculate_new_velocity()
new_pos = self.validate_pos(self.velocity + self.pos)
self.pos = interpolate(self.pos, new_pos, 3)
def update_velocity(self, *args):
if abs(self.velocity) == 0.001:
self.velocity = 0
min_offset = (1080 - self.item_list.height)
is_too_high = self.total_offset > 0
is_too_low = self.total_offset < min_offset
within_bounds = not (is_too_high or is_too_low)
if self.velocity == 0 and within_bounds:
return
if is_too_high:
self.total_offset = interpolate(self.total_offset, 0)
if is_too_low:
self.total_offset = interpolate(self.total_offset, min_offset)
self.total_offset += self.velocity
self.velocity = interpolate(self.velocity, 0, 15)
Clock.schedule_once(self.update_velocity, 1.0/30.0)
def update_velocity(self, *args):
if abs(self.velocity) < 1.0:
self.velocity = 0
w = self.width if self.width < 2050 else self.width -100
min_offset = min(-0.001, 2048 - w )
is_too_high = self.total_offset > 0.001
is_too_low = self.total_offset < min_offset
within_bounds = not (is_too_high or is_too_low)
#print "offset", self.total_offset, is_too_low, is_too_high
if self.velocity == 0 and within_bounds:
return
if is_too_high:
self.total_offset = interpolate(self.total_offset, 0)
if is_too_low:
self.total_offset = interpolate(self.total_offset, min_offset)
self.total_offset += self.velocity
self.velocity = interpolate(self.velocity, 0, 15)
Clock.schedule_once(self.update_velocity, 1.0/30.0)
def test_interpolate_solo(self):
values = [10., 19., 27.1]
a = 0.
for i in range(0, 3):
a = interpolate(a, 100)
self.assertEqual(a, values[i])
def update(self, *args):
t = time() - self.starttime
ft = 1 - abs(t % 2 - 1)
color = interpolate((1, 0, 0, 1), (0, 0, 1, 1), 1. / ft)
self.root.background_color = color
def test_interpolate_solo(self):
values = [10., 19., 27.1]
a = 0.
for i in range(0, 3):
a = interpolate(a, 100)
self.assertEqual(a, values[i])
def scale_up_marker(self, marker, *args):
marker.color = interpolate(marker.color, (1,1,1,1))
marker.scal = interpolate(marker.scal, 0.06)
marker.g_color.rgba = marker.color
marker.g_scale.matrix = Matrix().scale(marker.scal, marker.scal, marker.scal)
def scale_back_marker(self, marker, *args):
marker.color = interpolate(marker.color, (.75, .75, .75, .75))
marker.scal = interpolate(marker.scal, 0.04)
marker.g_color.rgba = marker.color
marker.g_scale.matrix = Matrix().scale(marker.scal, marker.scal, marker.scal)
