def start_animation(self, animation_time, target_index=None, direction="left"): if target_index is None: if self.active_index >= self.slider_numuber - 1: return False target_index = 0 else: target_index = self.active_index + 1 else: if target_index < self.active_index: direction = "right" if not self.in_animation: self.in_animation = True self.target_index = target_index self.timeline = Timeline(animation_time, CURVE_SINE) self.timeline.connect( "update", lambda source, status: self.update_animation( source, status, direction)) self.timeline.connect( "completed", lambda source: self.completed_animation(source, target_index)) self.timeline.run() return True
class Switch(): def __init__(self, switchRadix, reconfig_penalty, timeline_params): self.switchRadix = switchRadix self.reconfig_penalty = reconfig_penalty self.switch_scheduler = Scheduler(switchRadix, reconfig_penalty) self.demand = Timeline(timeline_params) self.reconfig_delay = reconfig_penalty self.currConfig = None def update(self, clock): if self.switch_scheduler.readyToSchedule(self.demand, clock): demandMatrix = self.demand.getDemand() self.switch_scheduler.scheduleDemand(demandMatrix) if self.reconfig_delay > 0: self.reconfig_delay = self.reconfig_delay - 1 return if self.currConfig == None: self.currConfig = self.switch_scheduler.getNextConfig() if self.currConfig != None and self.currConfig.timeDuration > 0: self.demand.serveDemand(self.currConfig) self.currConfig.service() if self.currConfig.timeDuration == 0: self.currConfig = None self.reconfig_delay = self.reconfig_penalty
class World: """ The Underworlds world data structure """ def __init__(self, name, meshes): self.__scene = Scene() self.__timeline = Timeline() self.__meshes = meshes self.__name = name def apply_changes(self, header, changes): invalidations = Invalidations() invalidations.node_ids_deleted = self.__scene.remove( changes.nodes_to_delete) invalidations.node_ids_updated = self.__scene.update( changes.nodes_to_update) invalidations.situation_ids_deleted = self.__timeline.remove( changes.situations_to_delete) invalidations.situation_ids_updated = self.__timeline.update( changes.situations_to_update) for mesh_id in changes.meshes_to_delete: del self.__meshes[mesh_id] invalidations.mesh_ids_deleted.append(mesh_id) for mesh in changes.meshes_to_update: self.__meshes[mesh.id] = mesh invalidations.mesh_ids_updated.append(mesh.id) return invalidations def reset(self): self.__scene.reset(self.__scene.root_id()) self.__timeline.reset(self.__timeline.origin().data) self.__meshes.reset()
def label_timeline(self, label): """Get timeline for a given label Parameters ---------- label : Returns ------- timeline : :class:`Timeline` Timeline made of all segments annotated with `label` """ if label not in self.labels(): return Timeline(uri=self.uri) if self._labelNeedsUpdate[label]: self._updateLabels() for l, hasChanged in self._labelNeedsUpdate.iteritems(): if hasChanged: self._labels[l] = Timeline(uri=self.uri) for segment, track, l in self.itertracks(label=True): if self._labelNeedsUpdate[l]: self._labels[l].add(segment) self._labelNeedsUpdate = {l: False for l in self._labels} return self._labels[label].copy()
def timeline_json(): headline = "Timeline Photo Headline" text = "this is the text" start_date = '2012,4,12' # find settings settings = Setting.query.order_by(desc(Setting.id)).all() if len(settings) > 0: setting = settings[0] headline = setting.headline text = setting.setting_text start_date = setting.start_date.replace("-", ",") # convert timeline's start date to datetime obj album_start_date = datetime.datetime.strptime(start_date, "%Y,%m,%d") # collect all photos tl = Timeline(headline, text, start_date) photos = Photo.query.filter(Photo.visibility == True).all() for photo in photos: dt = photo.start_date.replace("-", ",") # convert photo's start date to datetime obj photo_start_date = datetime.datetime.strptime(dt, "%Y,%m,%d") days_in_album = (photo_start_date - album_start_date).days + 1 # get No.D after timeline's start date asset_caption = _("Day %(value)d", value=days_in_album) text = photo.photo_text + "<BR/><BR/><A href='%s'><i class='icon-zoom-in'></i>%s</A>" % (url_for("photos.show_html", filename=photo.filename), photo.filename) tl.add_date(startDate=dt, headline=photo.headline, asset_media=url_for("photos.show_thumb", filename=photo.filename), text=text, asset_caption=asset_caption) return tl.get_json()
def __init__(self, switchRadix, reconfig_penalty, timeline_params): self.switchRadix = switchRadix self.reconfig_penalty = reconfig_penalty self.switch_scheduler = Scheduler(switchRadix, reconfig_penalty) self.demand = Timeline(timeline_params) self.reconfig_delay = reconfig_penalty self.currConfig = None
def test_daily(self): n_days = 10 data = get_timed_data(n_days) timeline = Timeline(data) daily = timeline.split_daily() self.assertEqual(len(daily), n_days, msg='Testing with {} days should yield dictionary with {} items'.format(daily, daily))
def graphicsView_reset(self): self.projects_list = db.get_projects() timeline = Timeline(self.projects_list) self.dates = timeline.generate_timeline() self.timeline_scene = self.create_scene() self.graphicsView.setScene(self.timeline_scene) self.projects = create_project_items(self.projects_list) self.show_projects() self.timeline_scene.itemClicked.connect(self.project_clicked)
def singlebeat(beat, *args, **kwargs): beat_timeline = Timeline() time = 0.0 beat_timeline.add(time+0.0, beat) print "Rendering beat audio..." beat_data = beat_timeline.render() return beat_data
def test_get_merged_timeline__single_timeline(self): """Verify merged timeline of exactly one partial timeline. """ partial_timeline = ['one', 'two', 'three', 'four'] timeline = Timeline(partial_timelines=[partial_timeline]) # Verify get_merged_timelines return value merged_timelines = timeline.get_merged_timelines() self.assertEqual([partial_timeline], merged_timelines)
def test_get_all_subsequent_events__simple(self): """Verify behavior of _get_all_subsequent_events. """ timeline = Timeline() timeline._subsequent_events = {'one': set(['two']), 'two': set(['three']), 'three': set(['four']), 'four': set()} subsequent_events = timeline._get_all_subsequent_events('one') self.assertEqual(set(['two', 'three', 'four']), subsequent_events)
def clear(self): self.global_settings = {} PlateDesign.clear() # # TODO: # self.timeline = Timeline('TEST_STOCK') for matchstring, callbacks in self.subscribers.items(): for callback in callbacks: callback(None)
def test_get_merged_timelines__full_merge__interleaved(self): """Verify that unambiguous interleaved timelines merge correctly. """ partial_timelines = [['two', 'three', 'seven'], ['three', 'four', 'five', 'seven']] timeline = Timeline(partial_timelines=partial_timelines) merged_timelines = timeline.get_merged_timelines() self.assertEqual([['two', 'three', 'four', 'five', 'seven']], merged_timelines)
def test_get_merged_timelines__full_merge__start_and_end_overlap(self): """Verify that unambiguous overlapping timelines merge correctly. """ partial_timelines = [['two', 'three', 'six'], ['six', 'seven'], ['one', 'two']] timeline = Timeline(partial_timelines=partial_timelines) merged_timelines = timeline.get_merged_timelines() self.assertEqual([['one', 'two', 'three', 'six', 'seven']], merged_timelines)
def test_get_merged_timelines__full_merge__shooting_example(self): """Verify that full merge is possible for shooting example. """ partial_timelines = [ ['shouting', 'fight', 'fleeing'], ['fight', 'gunshot', 'panic', 'fleeing'], ['anger', 'shouting']] timeline = Timeline(partial_timelines=partial_timelines) merged_timelines = timeline.get_merged_timelines() self.assertEqual([['anger', 'shouting', 'fight', 'gunshot', 'panic', 'fleeing']], merged_timelines)
def test_eq(self): t1 = Timeline(elements=[ScoreSpaceElement(0), ScoreSpaceElement(1)]) t2 = Timeline(elements=[ScoreSpaceElement(0)]) t3 = Timeline() t4 = Timeline(elements=[ScoreSpaceElement(0), ScoreSpaceElement(1)]) t5 = Timeline(elements=[ScoreSpaceElement(1), ScoreSpaceElement(1)]) self.assertEqual(t1, t4) self.assertNotEqual(t1, t2) self.assertNotEqual(t1, t3) self.assertNotEqual(t2, t3) self.assertNotEqual(t4, t5)
def singlenote(note_number, *args, **kwargs): singlenote_timeline = Timeline() time = 0.0 # Keep track of currect note placement time in seconds # Strum out root chord to finish chord = kwargs['progression'][0] singlenote_timeline.add(time + 0.0, Hit(chord.notes[note_number], 3.0)) print "Rendering singlenote audio..." singlenote_data = singlenote_timeline.render() return singlenote_data
def test_daily(self): n_days = 10 data = get_timed_data(n_days) timeline = Timeline(data) daily = timeline.split_daily() self.assertEqual( len(daily), n_days, msg='Testing with {} days should yield dictionary with {} items'. format(daily, daily))
def settings(user_token): try: user = User.objects.get(user_token=user_token) except User.DoesNotExist: return render_template('registration_wait.html') # Wait until geocode completes if not user.location_geoname: return render_template('registration_wait.html') if not user.timeline_token: return render_template('no_timeline.html') if request.method == "POST": old_config = dict(user.config) user.config["method"] = request.form["method"] user.config["asr"] = request.form["asr"] user.config["prayer_names"] = request.form["prayer_names"] user.save() if old_config != user.config: Timeline.push_pins_for_user(user) return render_template('settings_confirmed.html') # Allow calculation method to override geocoded name, where applicable location = user.location if hasattr(location, "keys"): location = location['coordinates'] location = location[::-1] # From the database, it's lon/lat location_geoname = TimetableResolver.ResolveLocationGeoname( user.config["method"], user.config, location) if location_geoname is None: location_geoname = user.location_geoname asr_options = ["Standard", "Hanafi"] method_options = sorted(list(TimetableResolver.Methods())) asr_setting_availability = json.dumps( {x: TimetableResolver.AsrSettingAvailable(x) for x in method_options}) prayer_name_options = { k: ", ".join([v[p] for p in ["fajr", "dhuhr", "asr", "maghrib", "isha"]]) for k, v in sorted(list(Timeline.PRAYER_NAMES.items()), key=lambda i: i[0] == "standard") } return render_template('settings.html', user=user, location_geoname=location_geoname, asr_options=asr_options, method_options=method_options, asr_setting_availability=asr_setting_availability, prayer_name_options=prayer_name_options)
def test_add_partial_timeline__simple(self): """Verify side-effects of single call to add_partial_timeline. """ partial_timeline = ['one', 'two', 'three', 'four'] timeline = Timeline() timeline.add_partial_timeline(partial_timeline) # Verify internal timeline data expected_subsequent_events = {'one': set(['two']), 'two': set(['three']), 'three': set(['four']), 'four': set()} self.assertEqual(expected_subsequent_events, timeline._subsequent_events)
def test_add_partial_timeline__contradiction(self): """Verify that order contradiction is detected and avoided. """ partial_timelines = [ ['one', 'two', 'three'], ['three', 'two']] timeline = Timeline() timeline.add_partial_timeline(partial_timelines[0]) self.assertRaisesRegexp( ValueError, "Contradiction detected: event 'three' comes before and after event 'two'", timeline.add_partial_timeline, partial_timelines[1])
def test_get_all_subsequent_events__branching(self): """Verify behavior of _get_all_subsequent_events when events overlap. """ timeline = Timeline() timeline._subsequent_events = {'one': set(['two']), 'two': set(['three']), 'three': set(['six', 'four']), 'four': set(['five']), 'five': set(['six']), 'six': set(['seven']), 'seven': set()} subsequent_events = timeline._get_all_subsequent_events('one') self.assertEqual(set(['two', 'three', 'four', 'five', 'six', 'seven']), subsequent_events)
def test_get_merged_timelines__no_merge__scandal_example(self): """Verify that no merge is possible for scandal example. """ partial_timelines = [ ['argument', 'coverup', 'pointing'], ['press brief', 'scandal', 'pointing'], ['argument', 'bribe']] timeline = Timeline(partial_timelines=partial_timelines) merged_timelines = timeline.get_merged_timelines() expected_timelines = partial_timelines self.assertEqual(len(expected_timelines), len(merged_timelines)) for merged_timeline in merged_timelines: self.assertTrue(merged_timeline in expected_timelines)
def test_place(self): a1 = Animation(np.ndarray((2, 1))) scores = [ [ScoreSpaceElement(0, 0, anim=a1), ScoreSpaceElement(3, 1, anim=a1), ScoreSpaceElement(5, 2, anim=a1), ScoreSpaceElement(6, 3, anim=a1)], [ScoreSpaceElement(1, 0, anim=a1), ScoreSpaceElement(2, 1, anim=a1), ScoreSpaceElement(4, 2, anim=a1), ScoreSpaceElement(5, 3, anim=a1)], [ScoreSpaceElement(4, 2, anim=a1), ScoreSpaceElement(6, 1, anim=a1), ScoreSpaceElement(10, 0, anim=a1)] ] timeline = Timeline(10) TimelinePlacer.layout_score_space_on_timeline(scores, timeline) desired_timeline = Timeline(length=10, elements=[ScoreSpaceElement(0, 0, anim=a1), ScoreSpaceElement(4, 2, anim=a1)]) self.assertEqual(desired_timeline, timeline)
def test_get_merged_timelines__partial_merge(self): """Verify that ambiguous partial timelines are merged as far as possible. """ partial_timelines = [['two', 'three', 'four', 'seven', 'eight'], ['one', 'two', 'five', 'six', 'seven']] timeline = Timeline(partial_timelines=partial_timelines) merged_timelines = timeline.get_merged_timelines() expected_timelines = [ ['one', 'two', 'three', 'four', 'seven', 'eight'], ['one', 'two', 'five', 'six', 'seven', 'eight']] self.assertEqual(len(expected_timelines), len(merged_timelines)) for merged_timeline in merged_timelines: self.assertTrue(merged_timeline in expected_timelines)
def handle_button_press(self, cr, rect, event_x, event_y): if self.is_expandable: if not self.in_animation: if self.has_expand: text_width, text_height = self.shrink_button_width, self.shrink_button_height else: text_width, text_height = self.expand_button_width, self.expand_button_height if is_in_rect((event_x, event_y), (rect.width - (rect.width - self.label_wrap_width) / 2 - text_width, rect.height - text_height, text_width, text_height)): if self.has_expand: start_position = self.expand_height animation_distance = self.init_height - self.expand_height else: start_position = self.init_height animation_distance = self.expand_height - self.init_height self.in_animation = True timeline = Timeline(self.animation_time, CURVE_SINE) timeline.connect('update', lambda source, status: self.update(source, status, start_position, animation_distance)) timeline.connect("completed", self.completed) timeline.run() else: print "no expand button"
def test_get_merged_timelines__partial_merge__foiled_mugging_example(self): """Verify that partial merge is possible for foiled_mugging example. """ partial_timelines = [ ['shadowy figure', 'demands', 'scream', 'siren'], ['shadowy figure', 'pointed gun', 'scream']] timeline = Timeline(partial_timelines=partial_timelines) merged_timelines = timeline.get_merged_timelines() expected_timelines = [ ['shadowy figure', 'demands', 'scream', 'siren'], ['shadowy figure', 'pointed gun', 'scream', 'siren']] self.assertEqual(len(expected_timelines), len(merged_timelines)) for merged_timeline in merged_timelines: self.assertTrue(merged_timeline in expected_timelines)
def test_get_merged_timelines__partial_merge__arson_example(self): """Verify that partial merge is possible for arson example. """ partial_timelines = [ ['pouring gas', 'laughing', 'lighting match', 'fire'], ['buying gas', 'pouring gas', 'crying', 'fire', 'smoke']] timeline = Timeline(partial_timelines=partial_timelines) merged_timelines = timeline.get_merged_timelines() expected_timelines = [ ['buying gas', 'pouring gas', 'crying', 'fire', 'smoke'], ['buying gas', 'pouring gas', 'laughing', 'lighting match', 'fire', 'smoke']] self.assertEqual(len(expected_timelines), len(merged_timelines)) for merged_timeline in merged_timelines: self.assertTrue(merged_timeline in expected_timelines)
def follow(self, target): current_time = time() user_following_tl = Timeline(self.client, following_key(self.user)) user_following_tl.add(target, current_time) target_follower_tl = Timeline(self.client, follower_key(target)) target_follower_tl.add(self.user, current_time)
def test_free_frames_set(self): t = Timeline() self.assertEqual(set(), t.free_frames_set()) t = Timeline(length=5) self.assertEqual(set(range(5)), t.free_frames_set()) anim1 = Animation(np.ndarray((2, 1))) # Anim with 2 frames se1 = ScoreSpaceElement(0, anim=anim1, window_start_frame=0) t.add_element(se1) # Must reserve frames 0 and 1 self.assertEqual(set(range(2, 5)), t.free_frames_set())
def OnInit(self): try: if self.options.record: # Connect to ROS master if not self.connect_to_ros(): raise Exception('recording requires connection to master') # Get filename to record to record_filename = time.strftime('%Y-%m-%d-%H-%M-%S.bag', time.localtime(time.time())) if self.options.name: record_filename = self.options.name if not record_filename.endswith('.bag'): record_filename += '.bag' elif self.options.prefix: prefix = self.options.prefix if prefix.endswith('.bag'): prefix = prefix[:-len('.bag')] if prefix: record_filename = '%s_%s' % (prefix, record_filename) rospy.loginfo('Recording to %s.' % record_filename) # Create main timeline frame self.frame = BaseFrame(None, 'rxbag', 'Timeline') self.frame.BackgroundColour = wx.WHITE self.frame.Bind(wx.EVT_CLOSE, lambda e: wx.Exit()) scroll = wx.ScrolledWindow(self.frame, -1) scroll.BackgroundColour = wx.WHITE timeline = Timeline(scroll, -1) timeline.Size = (100, 100) self.frame.Show() self.SetTopWindow(self.frame) timeline.SetFocus() if self.options.record: timeline.record_bag(record_filename, all=self.options.all, topics=self.args, regex=self.options.regex, limit=self.options.limit) else: RxBagInitThread(self, timeline) except Exception, ex: print >> sys.stderr, 'Error initializing application:', ex #import traceback #traceback.print_exc() return False
def object_hook(d): """ Usage ----- >>> import simplejson as json >>> with open('file.json', 'r') as f: ... json.load(f, object_hook=object_hook) """ from segment import Segment from timeline import Timeline from annotation import Annotation from transcription import Transcription if PYANNOTE_JSON_SEGMENT in d: return Segment.from_json(d) if PYANNOTE_JSON_TIMELINE in d: return Timeline.from_json(d) if PYANNOTE_JSON_ANNOTATION in d: return Annotation.from_json(d) if PYANNOTE_JSON_TRANSCRIPTION in d: return Transcription.from_json(d) return d
def setUp(self): self.client = Redis(decode_responses=True) self.client.flushdb() self.tl = Timeline(self.client, "blog::timeline") self.blogs = [ {"id": "blog::100", "time": 1000}, {"id": "blog::101", "time": 1500}, {"id": "blog::102", "time": 1550}, {"id": "blog::103", "time": 1700}, {"id": "blog::104", "time": 1750}, {"id": "blog::105", "time": 2500} ] self.reversed_blogs = list(reversed(self.blogs))
def to_page(self, w, direction): ''' Slide to given page. @param w: gtk.Widget to slide. @param direction: The direction of slide animation, can use below value: - \"right\" slide from right to left - \"left\" slide from left to right - None no animation effect, slide directly ''' if self.in_sliding: return if w != self.active_widget: w.set_size_request(self.page_width, self.page_height) if w.parent != self.fixed: self.fixed.put(w, self.page_width, 0) self.active_widget = w self.timeline = Timeline(self.slide_time, CURVE_SINE) if direction == "right": self.timeline.connect('update', lambda source, status: self._to_right(status)) elif direction == "left": self.timeline.connect('update', lambda source, status: self._to_left(status)) else: self._no_effect() self.timeline.connect("start", lambda source: self._start()) self.timeline.connect("completed", lambda source: self._completed()) self.timeline.run() self.in_sliding = True self.show_all()
def subscribe(): data = request.get_json() user_token = data["user_token"] user = User.objects(user_token=user_token) \ .modify(upsert=True, new=True, set_on_insert__created_at=datetime.utcnow()) if "timeline_token" in data: user.timeline_token = data["timeline_token"] user.location = [float(data["location_lon"]), float(data["location_lat"])] user.tz_offset = int(data["tz_offset"]) user.subscribed_at = datetime.utcnow() user.geocode() user.save() Timeline.push_pins_for_user(user) result = {"location_geoname": user.location_geoname} return jsonify(result)
def __init__(self, file=None, verbose=False): # Create an empty workplace self.agents = [] self.completed_tasks = [] self.current_task = None self.tasks_todo = [] self.time = 0 self.timeline = Timeline() # list of TimePoints self.coordination_times = {} self.Tperf = {} self.verbose = verbose if file: print("Reading from input file " + file + "...\n") self.parse_json(file, verbose)
def set_value(self, value): if (not self.in_animation) and value != self.value: self.start_value = self.value self.range = value - self.value times = int(abs(self.range)) * 10 from timeline import Timeline, CURVE_SINE timeline = Timeline(times * 10, CURVE_SINE) timeline.connect("start", self.start_animation) timeline.connect("stop", self.stop_animation) timeline.connect("update", self.update_animation) timeline.run() return False
def strum(*args, **kwargs): strum_timeline = Timeline() time = 0.0 # Keep track of currect note placement time in seconds # Strum out root chord to finish chord = kwargs['progression'][0] strum_timeline.add(time + 0.0, Hit(chord.notes[0], 4.0)) strum_timeline.add(time + 0.1, Hit(chord.notes[1], 4.0)) strum_timeline.add(time + 0.2, Hit(chord.notes[2], 4.0)) strum_timeline.add(time + 0.3, Hit(chord.notes[1].transpose(12), 4.0)) strum_timeline.add(time + 0.4, Hit(chord.notes[2].transpose(12), 4.0)) strum_timeline.add(time + 0.5, Hit(chord.notes[0].transpose(12), 4.0)) print "Rendering strum audio..." strum_data = strum_timeline.render() return strum_data
def get_request_timeline(request): """Get a `Timeline` for request. This should ideally return the request.annotations['timeline'], creating it if necessary. However due to bug 623199 it instead using the adapter context for 'requests'. Once bug 623199 is fixed it will instead use the request annotations. :param request: A zope/launchpad request object. :return: A timeline.timeline.Timeline object for the request. """ try: return webapp.adapter._local.request_timeline except AttributeError: return set_request_timeline(request, Timeline()) # Disabled code path: bug 623199, ideally we would use this code path. return request.annotations.setdefault('timeline', Timeline())
def set_value(self, value): if (not self.in_animation) and value != self.value: self.start_value = self.value self.range = value - self.value times = int(abs(self.range)) * 10 if times != 0: from timeline import Timeline, CURVE_SINE timeline = Timeline(times * 10, CURVE_SINE) timeline.connect("start", self.start_animation) timeline.connect("stop", self.stop_animation) timeline.connect("update", self.update_animation) timeline.run() else: self.value = value self.queue_draw() return False
def arpeggio(*args, **kwargs): arpeggio_timeline = Timeline() time = 0.0 # Keep track of currect note placement time in seconds # Add progression to timeline by arpeggiating chords from the progression for index in [0, 1]: chord = kwargs['progression'][index] root, third, fifth = chord.notes arpeggio = [root, third, fifth, third, root, third, fifth, third] for i, interval in enumerate(arpeggio): ts = float(i * 2) / len(arpeggio) arpeggio_timeline.add(time + ts, Hit(interval, 1.0)) time += 2.0 print "Rendering arpeggio audio..." arpeggio_data = arpeggio_timeline.render() return arpeggio_data
def init_timelines(): buffers = ('home', 'mentions', 'direct', 'search', 'user', 'favorite', 'thread', 'user_retweet', 'list') timelines = {} for buff in buffers: timelines[buff] = Timeline(buff) container.add('timelines', timelines) container.add('buffers', buffers) completion = Completion() container.add('completion', completion)
def test_construct(self): with self.assertRaises(ValueError): Timeline(length=-1) t = Timeline() self.assertListEqual([], t.elements) self.assertEqual(t.length, 0) t = Timeline(length=5) self.assertListEqual([], t.elements) self.assertEqual(t.length, 5) t = Timeline(elements=[]) self.assertListEqual([], t.elements) self.assertEqual(t.length, 0) els = [ScoreSpaceElement(0), ScoreSpaceElement(1)] t = Timeline(elements=els) self.assertListEqual(els, t.elements)
def slide_to(self, widget): self.active_widget = widget def update(source, status): pos = end_position - start_position adjustment.set_value(start_position + int(round(status * pos))) adjustment = self.get_hadjustment() start_position = adjustment.get_value() end_position = widget.get_allocation().x if start_position != end_position: timeline = Timeline(500, CURVE_SINE) timeline.connect('update', update) timeline.run() if self.slide_callback: self.slide_callback(self.layout.get_children().index(widget), widget)
def main(): parser = CommandParser() try: command_list = parser.parse() except CommandParser.ParserException as e: sys.exit(e) router = Router(command_list) runner_class = router.get_runner() timeline = Timeline() runner_class(timeline).run(command_list)
def test_get_merged_timelines__multiple_partial_merge(self): """Verify that ambiguous partial timelines are merged in multiple places. Note that generating four timelines may not be the desired behavior. Rather, we would like two timelines with merged fronts, middles, and ends, one timeline with the divergent sections of the first partial timeline and the other with the divergent sections of the second partial timeline. """ partial_timelines = [['two', 'three', 'four', 'six', 'seven', 'eight', 'nine', 'eleven'], ['one', 'two', 'five', 'six', 'seven', 'ten', 'eleven', 'twelve']] timeline = Timeline(partial_timelines=partial_timelines) merged_timelines = timeline.get_merged_timelines() expected_timelines = [ ['one', 'two', 'three', 'four', 'six', 'seven', 'eight', 'nine', 'eleven', 'twelve'], ['one', 'two', 'three', 'four', 'six', 'seven', 'ten', 'eleven', 'twelve'], ['one', 'two', 'five', 'six', 'seven', 'eight', 'nine', 'eleven', 'twelve'], ['one', 'two', 'five', 'six', 'seven', 'ten', 'eleven', 'twelve']] self.assertEqual(len(expected_timelines), len(merged_timelines)) for merged_timeline in merged_timelines: self.assertTrue(merged_timeline in expected_timelines)
def test_process_and_get_timeline(self): p = AnimationRecognitionProcessor() p.process(self.data) timeline = p.get_timeline_with_placed_animations() desired_timeline = Timeline( length=5, elements=[ ScoreSpaceElement(0, 0, self.lib_anim1), ScoreSpaceElement(4, 2, self.lib_anim2) ]) self.assertEqual(desired_timeline, timeline)
def __init__(self, width, height, player=None): self.width = width self.height = height self.grid = Grid(width, height) self.player = Player #self.camera = Camera(51, 19, self) self.camera = Camera(51, 19, self) self.output_buffer = OutputBuffer(self.camera.lensHeight) self.timeline = Timeline(100) self.portalList = [] self.triggerTileList = [] self.name = None #not used self.viewDistance = 3
class Window(QtGui.QMainWindow): def __init__(self): super(Window, self).__init__() self.ctr = 0 self.timeline = Timeline() self.signals_slots = signals_slots.Signal_Slots() #timer for animation #self.timer = QtCore.QTimer(self) #self.connect(self.timer, # QtCore.SIGNAL("timeout()"), # self.update) #self.timer.start(DELAY) def setup_connections( self, ui ) : ui.actionExit.triggered.connect(QtCore.QCoreApplication.instance().quit ) ui.actionOpen.triggered.connect(lambda: self.signals_slots.open_file(self, ui)) ui.playButton.clicked.connect(lambda: self.signals_slots.start_playback(self, ui)) ui.stopButton.clicked.connect(lambda: self.signals_slots.stop_playback(self, ui)) ui.seekSlider.setMediaObject(ui.videoPlayer.mediaObject()) ui.volumeSlider.setAudioOutput(ui.videoPlayer.audioOutput()) #ticker ui.videoPlayer.mediaObject().tick.connect(self.tick) def paintEvent(self, e): print "paintEvent called" start = {"x" : 170, "y" : 410 } end = {"x" : 430, "y" : 500} lines = { "short" : 5, "long" : 12 } qp = QtGui.QPainter() qp.begin(self) self.timeline.drawRectangles(qp, start, end, lines) self.timeline.drawLines(qp, start, end, lines) self.timeline.drawTicker(qp, start, end, lines, self.ctr) qp.end() #def update( self) : # print "something" # self.ctr = self.ctr + 1 # print self.ctr # self.repaint() def tick(self, time): displayTime = QtCore.QTime(0, (time / 60000) % 60, (time / 1000) % 60).second() print displayTime * 10 self.ctr = displayTime * 10 self.repaint()
class Window(QtGui.QMainWindow): def __init__(self): super(Window, self).__init__() self.ctr = 0 self.timeline = Timeline() self.signals_slots = signals_slots.Signal_Slots() #timer for animation #self.timer = QtCore.QTimer(self) #self.connect(self.timer, # QtCore.SIGNAL("timeout()"), # self.update) #self.timer.start(DELAY) def setup_connections(self, ui): ui.actionExit.triggered.connect( QtCore.QCoreApplication.instance().quit) ui.actionOpen.triggered.connect( lambda: self.signals_slots.open_file(self, ui)) ui.playButton.clicked.connect( lambda: self.signals_slots.start_playback(self, ui)) ui.stopButton.clicked.connect( lambda: self.signals_slots.stop_playback(self, ui)) ui.seekSlider.setMediaObject(ui.videoPlayer.mediaObject()) ui.volumeSlider.setAudioOutput(ui.videoPlayer.audioOutput()) #ticker ui.videoPlayer.mediaObject().tick.connect(self.tick) def paintEvent(self, e): print "paintEvent called" start = {"x": 170, "y": 410} end = {"x": 430, "y": 500} lines = {"short": 5, "long": 12} qp = QtGui.QPainter() qp.begin(self) self.timeline.drawRectangles(qp, start, end, lines) self.timeline.drawLines(qp, start, end, lines) self.timeline.drawTicker(qp, start, end, lines, self.ctr) qp.end() #def update( self) : # print "something" # self.ctr = self.ctr + 1 # print self.ctr # self.repaint() def tick(self, time): displayTime = QtCore.QTime(0, (time / 60000) % 60, (time / 1000) % 60).second() print displayTime * 10 self.ctr = displayTime * 10 self.repaint()
def layout_score_space_on_timeline(score_space: List[ List[ScoreSpaceElement]], timeline: Timeline) -> Timeline: # TODO Replace List[List[ScoreSpaceElement]] with LinearScoreSpace or smth. everywhere """ Grab elements from the score space and drop them onto the timeline using some algorithm, that may (and will) change. So consider it to be sort of a callback or mixin or... So, the algorithm is: 1. Find the highest score through all the ScoreSpaceElements 2. If each of its frames is not reserved on the timeline 2.1. Add it to the timeline 2.2. Add the frames occupied by the animation to the reserved frames list 3. Drop it from the list 4. Repeat step 1 till the timeline is full or till the score list is empty. - """ # This is a temporary trick while I don't use the ScoreSpace everywhere in the code # instead of list of lists from score_space_simple_2d import ScoreSpaceSimple2D score_space = ScoreSpaceSimple2D(score_space) while not score_space.empty(): score_element = score_space.get_best_score_element(remove=True) try: timeline.add_element(score_element) print(f"Added {score_element} to timeline") except FramesAlreadyReservedError: # Just drop the elements which can't be placed to the Timeline and move on pass return timeline
def start_animation(self, index, tab_start_x): if not self.in_animiation: self.in_animiation = True source_tab_x = tab_start_x + self.tab_index * self.tab_width target_tab_x = tab_start_x + index * self.tab_width timeline = Timeline(self.tab_animation_time, CURVE_SINE) timeline.connect('update', lambda source, status: self.update_animation(source, status, source_tab_x, (target_tab_x - source_tab_x))) timeline.connect("completed", lambda source: self.completed_animation(source, index)) timeline.run() self.emit("tab-switch-start", index)
def to_page(self, w, direction): ''' Slide to given page. @param w: gtk.Widget to slide. @param direction: The direction of slide animation, can use below value: - \"right\" slide from right to left - \"left\" slide from left to right - None no animation effect, slide directly ''' if self.in_sliding: return if w != self.active_widget: w.set_size_request(self.page_width, self.page_height) if w.parent != self.fixed: self.fixed.put(w, self.page_width, 0) self.active_widget = w self.timeline = Timeline(self.slide_time, CURVE_SINE) if direction == "right": self.timeline.connect( 'update', lambda source, status: self._to_right(status)) elif direction == "left": self.timeline.connect( 'update', lambda source, status: self._to_left(status)) else: self._no_effect() self.timeline.connect("start", lambda source: self._start()) self.timeline.connect("completed", lambda source: self._completed()) self.timeline.run() self.in_sliding = True self.show_all()
def __init__(self, multitrack=True, video=None, modality=None): super(Annotation, self).__init__() # whether a segment can contain multiple track (True) or not (False) self.__multitrack = multitrack # name of annotated modality self.__modality = modality # path to (or any identifier of) segmented video self.__video = video # this timeline is meant to store annotated segments. # it only contains segments with at least one labelled track. # a segment that is no longer annotated must be removed from it. self.__timeline = Timeline(video=self.video) # this is where tracks and labels are actually stored. # it is a dictionary indexed by segments. # .__data[segment] is a dictionary indexed by tracks. # .__data[segment][track] contains the actual label. self.__data = {} # this is a dictionary indexed by labels. # .__label_timeline[label] is a timeline made of segments for which # there exists at least one track labelled by label. # when a label no longer exists, its entry must be removed. self.__label_timeline = {} # this is a dictionary indexed by labels # .__label_count[label] is a dictionary indexed by segments containing # at least one track labelled by label. # .__label_count[label][segment] contains the number of tracks labelled # as label in this segment. when zero, segment entry must be removed. self.__label_count = {}
def __init__(self, app=None, token=None, refresh_token=None, tokens=None): if tokens: token = tokens["access_token"] refresh_token = tokens["refresh_token"] self.app = app self.token = token self.refresh_token = refresh_token self.session = self.app.oauth.get_session(token=self.token) self.session.headers.update({'Content-Type': 'application/json'}) self.timeline = Timeline(self) self.contacts = Contacts(self)
def start_animation(self, animation_time, index=None): # Update ticker with active index if option index is None. if index == None: if self.active_index >= self.image_number - 1: index = 0 else: index = self.active_index + 1 if not self.in_animiation: self.in_animiation = True self.target_index = index timeline = Timeline(animation_time, CURVE_SINE) timeline.connect("update", self.update_animation) timeline.connect("completed", lambda source: self.completed_animation(source, index)) timeline.run() return True