def load_gpx_file(file_name: str, use_local_time: bool) -> Track:
"""Load an individual GPX file as a track by using Track.load_gpx()"""
log.info(f"Loading track {os.path.basename(file_name)}...")
t = Track()
t.use_local_time = use_local_time
t.load_gpx(file_name)
return t
class Generator:
def __init__(self, inputt, musicName, initialBPM, initialInstrument):
input_converter = Input_information_converter(inputt)
translator = Translator()
self._text = input_converter.get_text()
self._instructions = translator.translate_text_to_instructions(
self._text)
self._music_name = musicName
self._initial_bpm = initialBPM
self._initialInstrument = initialInstrument
self._track = Track(1, self._initial_bpm, self._initialInstrument)
# Saída: um arquivo .mid é gerado
# Retorna: o próprio texto de entrada
def generate_song(self):
METHOD = 0
ARG = 1
for instruction in self._instructions:
method = instruction[METHOD]
arg = instruction[ARG]
callTrackMethod = getattr(self._track, method, 'repeatNote')
callTrackMethod(arg)
self._track.finishMusic(self._music_name)
return self._text
def add_local_tracks(self):
'''
Scan the content folder and add local tracks.
This only scans the top level folder. No subdirectories.
'''
# Create a bogus track to fix the issue
# where the screen clears itself
# This trigger the delayed import of CLI
t = Track('', '', 0, '', b'', '')
self.cli.log(
f"Checking directory '{constant.FILE_PREFIX}' for media... ")
# Only check 1 level deep
tracks = []
files = os.listdir(constant.FILE_PREFIX)
for file in files:
if (os.path.isfile(os.path.join(constant.FILE_PREFIX, file))):
self.cli.log(f"Processing '{file}'...")
tracks.append(Track.from_file(file))
self.add_tracks(tracks)
self.cli.log('Done')
def update_trackers(self, i, obs, match_mat):
"""
Updates the trackers based on the matching with detections.
If match found, runs the tracker's update function.
Else a new tracker is instantiated.
Args:
obs: List of mx1 observations
match_mat (num_trackers, num_obs): Binary matrix specifying which tracker matches which detection
Returns:
Nothing
"""
for j in range(match_mat.shape[1]):
total = match_mat[:,j].sum()
if total>0:
t_idx = match_mat[:,j].argmax()
self.tracks[t_idx].update(obs[j], i)
else:
# Pop new tracker ontop of the queue of trackers
t = Track()
t.update(obs[j], i)
self.tracks.append(t)
def update_and_get_tracks(self, dets, image):
# ---- Initialize list of predictions with number of current trackers. ---- #
curr_preds = np.zeros((len(self.trackers), self._NUM_OF_COORDINATES))
failed_to_predict = []
for p, _ in enumerate(curr_preds):
success, pos = self.trackers[p].predict(image)
if success:
curr_preds[p] = np.array(utils.convert_xywh_to_bbox(pos))
else:
failed_to_predict.append(p)
# Iterate from the end so indices of need-to-be-deleted elements will be preserved.
for p in reversed(failed_to_predict):
curr_preds = np.delete(curr_preds, p, axis=0)
self.trackers.pop(p)
matched, unmatched_dets, unmatched_trks = \
utils.associate_detections_to_trackers(dets, curr_preds, self.iou_threshold)
# ---- update matched trackers with assigned detections. ---- #
failed_to_update = []
for t, track in enumerate(self.trackers):
if t not in unmatched_trks:
d = matched[np.where(matched[:, 1] == t)[0], 0][0]
succ = track.update(image, utils.convert_bbox_to_xywh(dets[d]))
if not succ:
failed_to_update.append(t)
# Iterate from the end so indices of need-to-be-deleted elements will be preserved.
for p in reversed(failed_to_update):
self.trackers.pop(p)
# ---- create and initialise new trackers for unmatched detections ---- #
for i in unmatched_dets:
new_tracker = Track(tracker=self.tracker)
succ = new_tracker.update(image, utils.convert_bbox_to_xywh(dets[i]))
if succ:
self.trackers.append(new_tracker)
# ---- Return predictions ---- #
returned_preds = [] #
returned_preds_ids = []
i = len(self.trackers)
for track in reversed(self.trackers):
i -= 1
success, pos = track.get_state(image)
if not success or track.time_since_update > self.max_age:
self.trackers.pop(i)
continue
if (track.time_since_update < self.use_time_since_update) and (track.hits >= self.min_hits or self.frame_count <= self.min_hits):
returned_preds.append(utils.convert_xywh_to_bbox(pos))
returned_preds_ids.append(i)
return returned_preds, returned_preds_ids
def __init__(self):
"""Creates all game objects needed, loads resources, initializes
pygame library and sound mixer, sets display mode, etc."""
self.state = STATE_TITLE
pygame.mixer.pre_init(buffer=SOUND_BUFFER)
pygame.init()
self.clock = Clock()
self.scr = pygame.display.set_mode(SCREEN_SIZE, VID_MODE_FLAGS)
pygame.display.set_caption(WINDOW_CAPTION)
pygame.mouse.set_visible(False)
LoadingScreen(self.scr).draw()
sound_box.init()
self.level = GameLevel()
self.stats = GameStats(self.scr)
self.view_pt = ViewPoint(self.scr)
self.stars = Stars(self.scr, self.view_pt)
self.track = Track(self.scr, self.view_pt)
self.explosions = Explosions(self.scr, self.view_pt)
self.ship = Ship(self.scr, self.view_pt, self.explosions)
self.asteroids = Asteroids(self.scr, self.view_pt, self.explosions,
self.track)
self.title_screen = TitleScreen(self.scr, self.view_pt, self.stars)
self.level_start_screen = LevelStartScreen(self.scr)
self.level_complete_effect = LevelCompleteEffect(self.scr)
self.game_over_effect = GameOverEffect(self.scr)
self.pause_screen = PauseScreen(self.scr)
self.ending_screen = EndingScreen(self.scr)
self._init_title()
def add_track(self, loc, trackdb):
track = trackdb.get_track_by_loc(loc)
if not track:
track = Track(loc)
respone = trackdb.add_track_from_trackobj(track)
if not respone:
return False
tr_album = track.get_tag_raw('album', True)
tr_albumartist = track.get_tag_raw('albumartist', True)
if tr_albumartist == u'':
tr_albumartist = track.get_tag_raw('artist', True)
album = self.get_album_from_info(tr_album, tr_albumartist)
if not album:
# create new album
album = Album(tr_album, tr_albumartist)
self.__albums[(tr_album, tr_albumartist)] = album
album.unchecked_add_song(track)
self.__total_duration += track.get_tag_raw('__length')
# cover = coverdb.get_cover(tr_album, tr_albumartist)
# if not cover:
# tr_cover = track.get_tag_disk('cover')
# if tr_cover:
# coverdb.add_cover(tr_album, tr_albumartist, tr_cover)
return track
def loadTrack(self, trackfilename, track_id, flight_start):
#trackflilename does not include the path, it's only name and extesion
#track = open("./Flight1.txt", "r")
track = Track(track_id)
cont = 0
with open(self.scenariosfolder + "/" + self.scenarioName + "/" + trackfilename, "r") as trackfile:
for line in trackfile:
if (not (line.startswith('#') or line.startswith('/'))) and len(line)>30:
#if cont >= 4 and len(line)>30:
parts = line.split()
timestamp = parts[0]
lat = float(parts[1])
lon = float(parts[2])
altitude = float(parts[3])
heading = float(parts[6])
v_x = float(parts[8])
v_y = float(parts[10])
v_z = float(parts[9])
pitch = float(parts[4])
bank = float(parts[5])
onground = int(parts[7])
airspeed = float(parts[19])
track.addStep(timestamp, lat, lon, altitude, v_x, v_y, v_z, heading, pitch, bank, onground, airspeed)
#track.addStep(timestamp, lat, lon, altitude, v_x, v_y, v_z, heading, pitch, bank)
#cherrypy.log("%s,%s,%s,%s,%s,%s,%s,%s"%(timestamp, lat, lon, altitude, v_x, v_y, v_z, heading),context="EXPORT,")
cont += 1
track.setStart(flight_start)
return track
def create_simple_track():
"""
Creates a simple track for a line follower robot.
:return: the simple track.
:rtype: Track.
"""
track_width = 2.0
track_height = 1.0
screen_width_m = SCREEN_WIDTH * PIX2M
screen_height_m = SCREEN_HEIGHT * PIX2M
padding_y = screen_height_m - track_height
padding_x = screen_width_m - track_width
track = Track()
track.add_line_piece(
Vector2(padding_x / 2.0 + track_height / 2.0, padding_y / 2.0),
Vector2(screen_width_m - padding_x / 2.0 - track_height / 2.0,
padding_y / 2.0))
track.add_arc_piece(
Vector2(screen_width_m - padding_x / 2.0 - track_height / 2.0,
padding_y / 2.0 + track_height / 2.0), track_height / 2.0,
-pi / 2.0, pi / 2.0)
track.add_line_piece(
Vector2(screen_width_m - padding_x / 2.0 - track_height / 2.0,
screen_height_m - padding_y / 2.0),
Vector2(padding_x / 2.0 + track_height / 2.0,
screen_height_m - padding_y / 2.0))
track.add_arc_piece(
Vector2(padding_x / 2.0 + track_height / 2.0,
padding_y / 2.0 + track_height / 2.0), track_height / 2.0,
pi / 2.0, 3.0 * pi / 2.0)
return track
def run():
# create instance of player
player = Player("myPlayer")
# create instances for the following three tracks
track1 = Track("Incubus", "Drive", "Make Yourself")
track2 = Track("Ritchie Valens", "La Bamba", "La Bamba")
track3 = Track("Red Hot Chilli Peppers", "Californication", "Californication")
# add tracks to player
player.add(track1)
player.add(track2)
player.add(track3)
# play tracks
player.play()
player.next()
player.play()
player.next()
player.play()
player.next()
player.play()
player.previous()
player.play()
# directly select a track
player.selectTrack(1)
player.play()
# print out all tracks
player.printTracksInfo()
def loadJSON(self, src):
json_db = []
with open(src, 'r') as f:
json_db = f.readlines()
for track in json_db:
track_object = Track()
track_object.__dict__ = json.loads(track)
self.db[track_object.beatport_id] = track_object
def test_likelihood(self):
""" Tests that the likelihood function of track works and produces the correct result """
t = Track(np.matrix('0. 0.').T,
np.matrix('1. 0.; 0. 1.')) # Pass mean and covariance
y = np.matrix(0.5)
print(t.likelihood(y))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('tracking')
args = parser.parse_args()
package = Track(args.tracking)
os.system('clear')
package.track_factory()
def initthread(mwc, mc):
library = mwc.library
mwc.status_msg("Initializing..")
wc = Webclient()
wc.login(config.user, config.password)
devices = wc.get_registered_devices()
mwc.status_msg("Retrieving usable device ID..")
for dev in devices:
if dev["type"] == "PHONE":
# strip 0x if present
config.devid = dev["id"][2:] if dev["id"].startswith("0x") else dev["id"]
print("Found a usable device id: " + config.devid)
break
else:
md = Gtk.MessageDialog(parent=mwc.ui, buttons=Gtk.ButtonsType.OK, message_type=Gtk.MessageType.ERROR, message_format="Could not find a usable device id. Please run the Google Play Music app at least once on your phone.")
GLib.idle_add(modal_dialog_func, md)
mc.login(config.user, config.password)
player = Player(mc, config.devid)
mwc.setplayer(player)
def getalbumart(structure):
if "albumArtRef" in structure:
a = structure["albumArtRef"]
for entry in a:
if "url" in entry:
return entry["url"]
return None
mwc.status_msg("Retrieving library..")
songs = mc.get_all_songs()
for song in songs:
track = Track(song["id"], song["title"], song["artist"], song["album"],
song["trackNumber"] if "trackNumber" in song else 0)
track.albumarturl = getalbumart(song)
library.add_track(track)
mwc.status_msg("Retrieving playlists..")
playlists = mc.get_all_user_playlist_contents()
for x in playlists:
tracks = []
for t in x["tracks"]:
if t["trackId"].startswith("T"): # all access track
trackEntry = t["track"]
track = Track(t["trackId"], trackEntry["title"], trackEntry["artist"], trackEntry["album"], trackEntry["trackNumber"])
track.albumarturl = getalbumart(trackEntry)
tracks.append(track)
else:
libtrack = library.find_track(t["trackId"])
if libtrack is not None:
tracks.append(libtrack)
library.add_list(Playlist(x["name"], tracks))
mwc.status_msg("Idle")
def generate_tracks(self):
assert len(self.sentences) > 0
# initialize each language track
self.tracks = {locale: Track(locale) for locale in self.target_locales}
self.tracks[self.input_locale] = Track(self.input_locale)
# save a concatenation of all the sentences in all languages to disk
for idx, sentence in enumerate(self.sentences):
self._add_sentence_to_track(sentence)
def row_to_entity(row):
spot_entity = Spot()
spot_entity.id = row.id
spot_entity.name = row.name
spot_entity.position = GeoPoint.row_to_object(row.position)
spot_entity.tags = row.tags
spot_entity.tracks_current = [Track.row_to_object(track_row) for track_row in row.tracks_current]
spot_entity.tracks_old = [Track.row_to_object(track_row) for track_row in row.tracks_old]
return spot_entity
def load_midi(self):
chunk_extractor = ChunkExtractor(self.midi_path)
self.header = Header(chunk_extractor.header)
for track in chunk_extractor.tracks:
self._current_track = Track(track[1], track[2])
message_extractor = MessageExtractor(track)
self.tracks.append(
Track(message_extractor.track[1], message_extractor.track[2]))
self.allocate_messages(message_extractor.events)
def __init__(self, fn, name="Song name", cache_dir=None,
refresh_cache=False, labels=None, labels_in_file=False):
self._analysis = None
self._checksum = None
self.refresh_cache = refresh_cache
self.cache_dir = cache_dir
Track.__init__(self, fn, name, labels=labels,
labels_in_file=labels_in_file)
def __assign_detections_to_tracks_munkres(self, detections, frame_id, save=False):
# if there are no tracks yet, all detections are new tracks
if len(self.tracks) == 0:
for det in detections:
t = Track()
t.add_to_track(det)
self.tracks.append(t)
return True
# find distance from all tracks to all detections and formulate dists matrix
dists = np.zeros(shape=(len(self.tracks), len(detections)))
for i, track in enumerate(self.tracks):
predicted_next_bb = track.get_predicted_next_bb()
for j, det in enumerate(detections):
dist = util.dist_btwn_bb_centroids(predicted_next_bb, det.bbox)
if track.is_singular():
max_dist = const.MAX_PIXELS_DIST_TRACK_START
else:
max_dist = const.MAX_PIXELS_DIST_TRACK
if dist > max_dist:
dist = 1e6 # set to arbitrarily high number
dists[i, j] = dist
# set all tracks as unassigned
for t in self.tracks:
t.has_match = False
# assign all detections to tracks with munkres algorithm
assigned_rows, assigned_cols = linear_sum_assignment(dists)
for idx, row in enumerate(assigned_rows):
col = assigned_cols[idx]
# if track is assigned a detection with dist=1e6, discard that assignment
if dists[row, col] != 1e6:
self.tracks[row].has_match = True
detections[col].has_match = True
self.tracks[row].add_to_track(detections[col])
self.tracks[row].num_misses = 0
# create new tracks from unassigned detections:
for det in detections:
if det.has_match is False:
t = Track()
t.add_to_track(det)
self.tracks.append(t)
# keep track of how many times a track has gone unassigned
for t in self.tracks:
if t.has_match is False:
t.num_misses += 1
# t.propagate_track(frame_id=frame_id)
# cleanup any duplicate tracks that have formed (TODO: how do they form?)
self.__delete_duplicate_tracks()
# save dead tracks before deletion
if save:
self.__save_tracks_to_json()
# remove dead tracks
self.tracks = [t for t in self.tracks if (t.is_dead() is False and t.delete_me is False)]
def __init__(self,
fn,
name="Speech name",
labels=None,
labels_in_file=False):
Track.__init__(self,
fn,
name,
labels=labels,
labels_in_file=labels_in_file)
def filter(self, dt, z, R):
associated = [track.filter(dt, z, R) for track in self.tracks]
if not any(associated):
new_track = Track(filter_model=self.filter_factory())
new_track.filter(dt, z, R)
self.tracks.append(new_track)
def _test_drawing(self):
t1 = Track(np.matrix('0. 0.').T, np.matrix('1. 0.; 0. 1.'))
t2 = Track(np.matrix('2. 2.').T, np.matrix('1. 0.; 0. 1.'))
tracks = [t1, t2]
e = TrackerEngine(0.1, [])
e.tracks = tracks
e.draw()
raw_input('your mom')
def parse_response(self, response_json):
playlist = []
# used to get rid of duplicate tracks in same album
album_set = Set()
parsed_json = json.loads(response_json)
# first check if the json can be correctly parsed
if not 'tracks' in parsed_json:
return all_tracks
json_tracks = parsed_json['tracks']
for json_track in json_tracks:
track = Track()
curTrackMap = {}
album = json_track['album']['name'].lower()
if album in album_set:
continue
album_set.add(album)
track.set_album(album)
track.set_name(json_track['name'].lower())
artists = json_track['artists']
artists_name = []
for artist in artists:
artists_name.append(artist['name'].lower())
track.set_artists(artists_name)
track.set_length(json_track['length'])
playlist.append(track)
return playlist
def get_track(provider_id):
t = Track()
try:
######MediaNet######
# reqUrl = 'http://ie-api.mndigital.com?method=track.get&format=json&'\
# + urllib.urlencode({'mnetid': provider_id})\
# + '&ApiKey=%s' % MusicProvider._mnDigitalIntegrationAPIKey
reqUrl = "http://itunes.apple.com/lookup?" + urllib.urlencode({"id": provider_id})
# track_json = common.get_json(reqUrl)["Track"]
track_json = common.get_json(reqUrl)["results"][0]
t.provider_id = provider_id
t.length_seconds = 0
t.url = ""
# t.artist = track_json["Artist"]["Name"]
# t.title = track_json["Title"]
# t.length_friendly = track_json["Duration"]
# t.album = track_json["Album"]["Title"]
# t.art_url = track_json["Album"]["Images"]["Album150x150"]
t.artist = track_json["artistName"]
t.title = track_json["trackName"]
t.length_friendly = ""
t.album = track_json["collectionName"]
t.art_url = track_json["artworkUrl100"]
except Exception:
pass
return t
def __init__(self,
scale: float = 4.0,
steps: int = 30,
time: float = 20.0,
racers=[]):
self.racers = racers
self.track = Track(scale)
self.trigger_distance = scale * 0.01
self.time_steps = steps
self.time_limit = time
self.goals = []
def __init__(self,
*args,
settings=None,
carnum=10,
width=960,
height=540,
vsync=True,
**kwargs):
config = pyglet.gl.Config(sample_buffers=1,
samples=1,
depth_size=16,
double_buffer=True)
super().__init__(width=width,
height=height,
config=config,
resizable=True,
vsync=vsync)
self.keystate = key.KeyStateHandler()
self.push_handlers(self.keystate)
self.settings = defaultdict(bool)
if type(settings) == dict:
self.settings.update(settings)
self.init_speed = self.settings['speed'] if type(
self.settings['speed']) == int else 25
self.carnum = (carnum + 1) // 2 * 2 # need even number
self.carnum = carnum
self.cars = []
self.car = Car(
sensors=self.settings['sensors'],
human=True) # will be deleted later if simulation starts
self.carline_colours = tuple()
self.track = Track()
self.car.put_on_track(self.track)
self.generation = 0
self.cars_pos_vbo = VertexBufferObject(self.carnum * 64,
GL_ARRAY_BUFFER,
GL_DYNAMIC_DRAW)
self.cars_col_vbo = VertexBufferObject(self.carnum * 96,
GL_ARRAY_BUFFER, GL_STATIC_DRAW)
self.time = 0
self.fps = pyglet.clock.ClockDisplay()
self.times = defaultdict(list)
self.counter = 0
self.setup_labels()
self.x = 0
self.y = 0
self.scale = 1
pyglet.clock.schedule_interval(self.update, 1.0 / 60)
def __init__(self, inputt, musicName, initialBPM, initialInstrument):
input_converter = Input_information_converter(inputt)
translator = Translator()
self._text = input_converter.get_text()
self._instructions = translator.translate_text_to_instructions(
self._text)
self._music_name = musicName
self._initial_bpm = initialBPM
self._initialInstrument = initialInstrument
self._track = Track(1, self._initial_bpm, self._initialInstrument)
def play(self, position = 0, onError = None):
if len(self.tracks) > 0 and len(self.tracks) > position:
self.position = position
if onError == None:
self.currentTrack = Track(self.tracks[self.position])
else:
self.currentTrack = Track(self.tracks[self.position], onError)
self.currentTrack.setVolume(self.volume)
self.currentTrack.play()
else:
raise IndexError('Wrong track position')
def makeTracks(self): self.track_size = (self.screen_size[1]-(2*self.safe_area)-(2*10))/self.num_tracks tracks = [None for i in range(self.num_tracks)] tracks[0] = Track(0, 'r', self.safe_area+10) for i in range(1, self.num_tracks): if i < self.num_tracks/2: tracks[i] = Track(i, 'r', tracks[i-1].position + self.track_size) else: tracks[i] = Track(i, 'l', tracks[i-1].position + self.track_size) return tracks
def test_rgbAsGrayScale():
arr = [10,20,30,40,50,60,70,128,256]
mockFrame = np.array(arr).reshape(3,3)
"Mockframe is an array where the value of the number represents the color 0 being black, 256 being white"
np.testing.assert_allclose(
Track.rgbAsGrayscale(mockFrame, False),
np.dot(mockFrame[..., :], [0.299, 0.587, 0.114])
)
np.testing.assert_allclose(
Track.rgbAsGrayscale(mockFrame),
(np.dot(mockFrame[..., :], [0.299, 0.587, 0.114]) / 128. - 1.)
)
def lets_race(drivers=[Car("Rarri"), Car("Tesla")]) -> str:
t = Track()
done = False
while not done:
for d in drivers:
print(d)
d.accelerate()
t.check_winner(d)
if t.winner:
done = True
return "And the winner is: {}".format(t.winner)
def index(self, path):
for top, dirnames, filenames in os.walk(path):
for filename in filenames:
if filename.endswith('.mp3'):
full_path = os.path.join(top, filename);
f = tagpy.FileRef(full_path)
t = Track("file://" + full_path)
t.title = f.tag().title
t.artist = f.tag().artist
t.album = f.tag().album
a = f.audioProperties()
t.duration = a.length * 1000 # to msec
self.add_track(t)
def _test_likelihood_mat(self):
""" Provide mock tracker objects and detections and check that the correct likelihood value is generates """
t1 = Track(np.matrix('0. 0.').T, np.matrix('1. 0.; 0. 1.'))
t2 = Track(np.matrix('2. 2.').T, np.matrix('1. 0.; 0. 1.'))
#tracks = [t1, t2]
tracks = []
detections = [[np.matrix(0.), np.matrix(1.), np.matrix(2.)]]
e = TrackerEngine(0.1, detections)
print('likelihood is')
print(e.likelihood_mat(tracks, detections[0]))
def __init__(self, parent=None):
super(PlayerView, self).__init__(parent)
# Player data
self.setMinimumSize(800, 600)
self.log = Log(self)
self.log.widget.move(600, 100)
self.track = Track(self)
self.track.move(600, 300)
self.hand = Hand(self)
self.hand.move(0, 400)
self.map = Map(self)
self.multiChoice(('asdf', 'qwer'))
def load_from(data):
if data["schema"] != DB_SCHEMA:
return
for d in data["genres"]:
Genre.unpickle(d)
for d in data["artists"]:
Artist.unpickle(d)
for d in data["albums"]:
Album.unpickle(d)
for d in data["tracks"]:
Track.unpickle(d)
for l in data["libraries"]:
Library.unpickle(l)
def get_track_row(self):
row = self.db.fetchone()
tid = row["track_id"]
position = row["position"]
ptid = row["id"]
self.db.commit_statement("""select * from tracks where id = ?""", [row["track_id"]])
row = self.db.fetchone()
del row["id"]
t = Track(**row)
t.id = tid
t.position = position
t.ptid = ptid
return t
def get_track_row(self):
row = self.db.fetchone()
tid = row['track_id']
position = row['position']
ptid = row['id']
self.db.commit_statement('''select * from tracks where id = ?''', [row['track_id']])
row = self.db.fetchone()
del row['id']
t = Track(**row)
t.id = tid
t.position = position
t.ptid = ptid
return t
def track_agregar(self, funcion_sonido, frecuencia, volumen):
"""
Pre: recibe una funcion de la lista de funciones (cadena), una
frecuencia, volumen (enteros o decimales).
Post: crea y agrega un nuevo track.
"""
track = Track(funcion_sonido, frecuencia, volumen, DUTY_CYCLE)
self.tracks.append(track.dar_sonido())
self.info_tracks.append(
[funcion_sonido.upper(),
str(frecuencia),
str(volumen)])
self.canales += 1
self.cursor.track_agregar()
def output_aligns(outfile, aligns, track_name=None, contigs=None, append=False,
header=True, genome=None, refseq=None, color=None, by_fasta=False, annodir=None):
"""Outputs alignments to file"""
ext = os.path.splitext(outfile)[1]
if append:
out = open(outfile, 'a')
else:
out = open(outfile, 'w')
# desc == name
track_desc = track_name
if aligns:
if track_name and genome:
Track.ucsc_targets(genome, aligns, annodir)
if header and track_name:
header_line = "track name=\"%s\" description=\"%s\" visibility=%d itemRgb=\"On\"" % (track_name, track_desc, 3)
if color is not None:
header_line += ' color=\"%s\"' % (color)
out.write("%s\n" % (header_line))
# map contig to contig name
contig_dict = None
if contigs:
contig_dict = dict((contig.num, contig) for contig in contigs)
# sort alignments by contig order in original input fasta file
if by_fasta:
count = 0
ordered = {}
for contig in contigs:
ordered[contig.num] = count
count += 1
aligns.sort(lambda x,y: ordered[x.query] - ordered[y.query])
for align in aligns:
contig = align.query
if ' ' in contig:
contig = align.query.split(" ")[0]
if contig_dict and contig_dict.has_key(contig):
align.contig = contig_dict[contig]
if ext == ".gff":
out.write(align.gff("exon"))
elif ext == ".psl":
out.write(align.psl(refseq=refseq, genome=genome))
out.close()
def compute_tracks(event):
map.clear_log()
map.log(txt='>> 8: Compute tracks\n\n')
if len(trajectories) == 0 or len(ntc) == 0:
map.log(txt="Error: No trajectories or cluster computed.\n")
else:
global tracks_computed
if not tracks_computed:
global track_index, macro_index
track_index = 0
macro_index = 0
print(macro_clusters)
map.draw_init(Aoi.select(), origin, controls)
for traj in trajectories:
if len(tracks) == 0:
tracks.append(Track())
tracks[0].add_trajectory(traj)
else:
if tracks[len(tracks) - 1].id == traj.track:
tracks[len(tracks) - 1].add_trajectory(traj)
else:
tracks.append(Track())
tracks[len(tracks) - 1].add_trajectory(traj)
tracks_computed = True
map.log(txt="Tracks computed.\n")
# Macro cluster
for track in tracks:
key = str(track.cluster_code)
macro_clusters[key] = macro_clusters.get(key, 0) + 1
map.log(txt="Macro clusters computed.\n\n")
else:
map.log(txt="Tracks already computed. \n\n")
ord_macroclusters = OrderedDict(
sorted(macro_clusters.items(),
key=operator.itemgetter(1),
reverse=True))
map.log(txt="Macro clusters:\t\n")
for macrocluster_code in ord_macroclusters:
color_keys = []
cluster_codes = list(eval(macrocluster_code))
for cluster_code in sorted(cluster_codes, reverse=True):
color_keys.append(colors.keys()[cluster_code])
map.log(txt=str(color_keys) + " " +
str(ord_macroclusters[macrocluster_code]) + "\n")
class TestTrack(unittest.TestCase):
def setUp(self):
"""Start unittest attributes"""
self.talk_objects = TALK_OBJECTS
self.schedule = Schedule(self.talk_objects)
self.track = Track(self.schedule.list_slice[0])
def test_combination(self):
self.track.get_list_track()
def test_mount_str(self):
time = datetime.now().replace(hour=12, minute=0)
str_mount = self.track.mount_str(time, "Lunch")
self.assertEqual(str_mount, "12:00PM Lunch \n")
class App(Tk):
def __init__(self, ftimer):
Tk.__init__(self)
self.sats = Track()
self.sats.load_local("data.txt") # to be changed
self.sats.add_satellite(7) # achtung, hardcode
menu = UserMenu(parent = self)
self.config(menu = menu)
self.title('SatKit Ground Tracking')
self.timer = ftimer
self.timer.callback_function = self.redraw
self.time_speed = 1 # normal speed
self.var = IntVar()
self.scale = Scale(self, variable = self.var, from_ = 1, to = 3600,
orient = HORIZONTAL, showvalue=0, sliderlength=15,
length=400, command=self.set_time_speed)
self.date = Label(self)
def redraw(self):
self.timer.set_speed(self.time_speed) # bad, should be improven,~event
self.sats.update_satellites(self.time_speed * Time.TIMER_INTERVAL)
#print self.time_speed
# recompute "current" time, later,,,
self.date.config(text = str(self.timer.current_time)[0:21])
self.date.grid(row = 0, column = 1)
self.scale.grid(row = 0, column = 0)
self.sats.anim.grid(row = 1, columnspan = 2)
self.sats.draw()
def set_time_speed(self, secs):
self.time_speed = int(secs)
def scrapeFileTags(path):
if path.suffix == ".flac":
f = FLAC(path)
elif path.suffix == ".mp3":
f = EasyID3(path)
tr = Track(0)
tr.file_name = path.name
tr.file_path = path
# extract artist and title
try:
tr.artists = f['ARTIST'] or f['artist']
tr.title = f['TITLE'].pop().split(' (')[0] or f['title'].pop().split(
' (')[0]
except:
print("*** error cannot match file without artist or title")
print(f"*** skipping {path.name}")
return
# try to extract remixer
try:
tr.remixer = f['TITLE'][0].split('(')[1].split(
')')[0] or f['title'][0].split('(')[1].split(')')[0]
except:
# assume it's original mix, when no remixer is supplied
tr.remixer = "Original Mix"
return tr
def main(args):
'''
Main method
'''
if len(args) < 3:
print(
"Please provide the necessary parameters ie kexp.py [playlist_name] [start_date] [end_date] [playlist_description]"
)
else:
#The name of the playlist you want to use in Spotify
#If this playlist does not exist a new one with this name will be created
#If this playlist exists it will be used
playlist_name = args[0]
#The start date time of the tracks you want to return.
#The KEXP API is in UTC format so make this date must be in the UTC format and timezone
#Example: 2019-02-15T02:00:00Z
start_date = args[1]
#The end date time of the tracks you want to return.
#The KEXP API is in UTC format so make this date must be in the UTC format and timezone
#Example: 2019-02-15T05:00:00Z
end_date = args[2]
#The description of the playlist you want to appear in Spotify
playlist_description = args[3]
#Create new Playlist object
#Set this particular playlist properties
#Send the playlist object into Spotify to create/update the latest
playlist = Playlist()
spotify = Spotify()
playlist.name = playlist_name
playlist.description = playlist_description
temp_tracks = []
uri = f'https://api.kexp.org/v2/plays/?airdate_after={start_date}&airdate_before={end_date}&album=&album_exact=&artist=&artist_exact=&exclude_airbreaks=&has_comment=&host_ids=&label=&label_exact=&limit=2000&ordering=airdate&recording_id=&show_ids=&song=&song_exact='
temp_tracks = get_tracks(uri, start_date, end_date)
for temp_track in temp_tracks:
if not any(x.airdate == temp_track['airdate']
for x in playlist.tracks):
track = Track()
track.artist = temp_track['artist']
track.title = temp_track['song']
track.airdate = temp_track['airdate']
playlist.tracks.append(track)
playlist.tracks.sort(key=extract_time, reverse=False)
spotify.create_playlist(playlist)
class CyclopsEvolver(TournamentEvolver):
def __init__(self, popSize, tournSize, nIters):
super().__init__(popSize, tournSize, nIters)
self.track = Track()
self.simDuration = self.track.size * 4
self.startSeed = random.random()
def randomIndividual(self):
nNeurons = 8
return System(nNeurons)
def mutated(self, system):
return self.mutatedPartial(system, 1, 8)
def mutatedPartial(self, system, mean, variance):
sys = system.copy()
#sys.trans += variance / 4 * numpy.random.randn(*sys.trans.shape)
sys.trans *= mean + variance * numpy.random.randn(*sys.trans.shape)
#sys.trans += 1/8 * numpy.random.randn(*sys.trans.shape)
return sys
def fitness(self, system):
return sum(self.fitness1(system, self.startSeed + i) for i in range(64))
def fitness1(self, system, seed):
distances = []
def distanceTracker(track):
rawDist = track.bot.position - track.flag.position
dist = min(rawDist % track.size, (-rawDist) % track.size)
distances.append(dist)
self.simulate(system, distanceTracker, seed)
return -sum(d for d in distances[-self.track.size : ])
def simulate(self, system, watcher, seed=None):
# initialize conditions
self.track.reset(seed)
system.reset()
# simulate
for iteration in range(self.simDuration):
self.track.step(system)
watcher(self.track)
def animate(self, system):
frames = []
def frameCapturer(track):
frames.append(track.drawnState())
self.simulate(system, frameCapturer)#, self.startSeed)
return frames
def __init__(self, width, height):
self.controls = None
self.round_manager = RoundManager(self)
self.ui_font = font.Font("./fonts/FreeSansBold.ttf", 12)
self.round_label_font = font.Font("./fonts/FreeSansBold.ttf", 20)
self.mouse_position = (0, 0)
self.placing_tower = False
self.selected_place_tower = build_tower(self, BALLISTA_TOWER)
self.selected_active_tower = None
self.ui_tower_image = build_tower(self, BALLISTA_TOWER).image
self.generate_tower_placement_sprite()
self.tower_select_index = 0
self.money = 20000
self.lives = 50
self.start_tile = 16, 16
self.width, self.height = width, height
self.entities = pygame.sprite.Group()
self.towers = pygame.sprite.Group()
self.projectiles = pygame.sprite.Group()
self.explosions = pygame.sprite.Group()
total_level_width = width*16
total_level_height = height*16
self.generate_background_image()
self.track = Track()
self.camera = Camera(complex_camera, total_level_width, total_level_height)
def createNewTracks(self, detections, unmatchedDetections):
for detectionIndex in unmatchedDetections:
detection = detections[detectionIndex]
array_detection = np.array(detection, np.float32)
# TODO: Create Kalman filter object
kf = cv2.KalmanFilter(4, 2)
kf.measurementMatrix = MEASUREMENT_MATRIX
kf.transitionMatrix = TRANSITION_MATRIX
# kf.processNoiseCov = PROCESS_NOISE_COV
# Create the new track
newTrack = Track(self.nextTrackID, kf)
newTrack.update(array_detection)
newTrack.locationHistory.append(detection)
self.tracks.append(newTrack)
self.nextTrackID += 1
def remove_track(self, loc, trackdb):
"""
Remove song from playlist with given location.
"""
track = trackdb.get_track_by_loc(loc)
if not track:
track = Track(loc)
if not track._scan_valid:
return False
tr_album = track.get_tag_raw('album', True)
tr_albumartist = track.get_tag_raw('albumartist', True)
if tr_albumartist == u'':
tr_albumartist = track.get_tag_raw('artist', True)
album = self.get_album_from_info(tr_album, tr_albumartist)
if not album:
return False
return album.remove_track(loc)
class TrackThreader():
def __init__(self):
self.track = None
self.onEndCustomCallback = None
self.volume = volumizer.getJSON()['config']['milli']
def __play_track(self, track, callback = None):
self.setVolume(volumizer.getJSON()['config']['milli'])
if(callback == None):
track.play()
else:
callback(track)
self.__oversee_track(track)
#This makes track to disapear after it's done playing
def __oversee_track(self, track):
while (track.isBusy() or track.isPaused()) and not track.shouldEnd():
continue
if(self.onEndCustomCallback == None):
if(self.track != None):
print(self.track.getPath() + " finished playing.")
self.setTrack(None)
else:
self.__play_track(track, self.onEndCustomCallback)
def getThread(self, path):
self.track = Track(path, self.volume)
self.playingThread = threading.Thread(target = self.__play_track, args=(self.track, ))
self.playingThread.daemon = True
return {'thread' : self.playingThread,
'track' : self.track}
def currentTrack(self):
return self.track
def setTrack(self, track):
self.track = track
def setVolume(self, volume):
self.volume = volume
if self.track != None:
self.track.setVolume(volume)
def registerOnEndCustomCallback(self, callback):
self.onEndCustomCallback = callback
def as_list(path: str, pattern: str, default_artist="", default_title="", type="song"):
file_list = []
for file_path in Path(path).glob(pattern):
try:
file_list.append(
Track.from_path(str(file_path), default_artist, default_title, type=type, raise_error=False)
)
except (KeyError, IOError) as err:
print(err)
return file_list
def get_track_nbr(self, nbr):
self.db.commit_statement('''select * from playlist_tracks where playlist_id = ?''', [int(self.id)])
row = self.db.fetchone()
# There is probably a much smarter way to fetch a specific row number
i = 0
while i < nbr:
row = self.db.fetchone()
i = i + 1
tid = row['id']
self.db.commit_statement('''select * from tracks where id = ?''', [row['track_id']])
row = self.db.fetchone()
del row['id']
t = Track(**row)
t.id = tid
return t
def get_all_tracks(self):
self.db.commit_statement('''select * from playlist_tracks where playlist_id = ?''', [int(self.id)])
row = self.db.fetchone()
tracks = []
while row != None:
tracks.append((str(row['id']), row['track_id'])) # FIXME: broken!
row = self.db.fetchone()
ret_tracks = []
for track in tracks:
# TODO: replace with an SQL statement that instantly creates a Track object
self.db.commit_statement('''select * from tracks where id = ?''', [track[1]])
row = self.db.fetchone()
del row['id']
t = Track(**row)
t.id = track[0] # add the playlist-to-track id instead
ret_tracks.append(t)
return ret_tracks
def indexFromFile(self): self.file = open(os.getcwd() + '/options/index.txt', 'r') path = None line = self.file.readline() while line != '': code = line[0:2] if code == "NP": path = line[2:-1] line = self.file.readline() t = Track() t.path = path + "/" + line[0:-1] t.artist = self.file.readline()[0:-1] t.title = self.file.readline()[0:-1] t.album = self.file.readline()[0:-1] self.tracks.append(t) self.gui.addTrack(t) line = self.file.readline() self.file.close() self.gui.loading_finished()
def load(self, tracknames=None):
treestr = self.level*TAB + self.id + '/'
# print string to tree hierarchy and screen
self.writetree(treestr + '\n')
print(treestr)
if tracknames != None:
tracknames = tolist(tracknames)
dirnames = tracknames
else:
# all track folder names for this animal:
dirnames = [ dirname for dirname in os.listdir(self.path)
if os.path.isdir(os.path.join(self.path, dirname))
and dirname.lower().startswith('tr') ]
dirnames.sort() # alphabetical order
for dirname in dirnames:
path = os.path.join(self.path, dirname)
track = Track(path, animal=self)
track.load()
self.tr[track.id] = track
self.__setattr__('tr' + str(track.id), track) # add shortcut attrib
def post(self):
j=self.request.body
data=json.loads(j)
video=None
video=memcache.get("video of %s %s"%(data["name"],data["artist"]["name"]))
trackKey=ndb.Key('Track',data["name"]+ " - " +data["artist"]["name"] )
track=trackKey.get()
if track is None:
track=Track(key=trackKey)
track.getVideo()
video={}
video["ytid"]=track.ytid
video["img"]="http://img.youtube.com/vi/"+video["ytid"]+"/0.jpg"
memcache.set("video of %s %s"%(data["name"],data["artist"]["name"]), video)
self.response.out.write(json.dumps(video))
def get_all_tracks(self):
self.db.commit_statement(
"""select * from playlist_tracks where playlist_id = ? order by position""", [int(self.id)]
)
row = self.db.fetchone()
tracks = []
while row != None:
tracks.append((str(row["id"]), row["track_id"])) # FIXME: broken!
row = self.db.fetchone()
ret_tracks = []
for track in tracks:
# TODO: replace with an SQL statement that instantly creates a Track object
self.db.commit_statement("""select * from tracks where id = ?""", [track[1]])
row = self.db.fetchone()
del row["id"]
t = Track(**row)
t.id = track[0]
ret_tracks.append(t)
return ret_tracks
def set_files(self, files_list): for i,f in enumerate(files_list): t = Track() t.subfile_no = i t.torrent = self t.offset = f.offset t.size = f.size t.title = f.path t.filehash = f.filehash self.files.append(t)
def create_track_from_uri(self, uri):
uri = SpotifySource.strip_protocol(uri)
if uri == None:
return None
url = "http://ws.spotify.com/lookup/1/?uri=" + uri
try:
e = ET.parse(urllib.urlopen(url))
except Exception as e:
return None
ns = "http://www.spotify.com/ns/music/1"
if 'album' in uri:
title = ""
artist = e.find('.//{%s}artist/{%s}name' % (ns, ns)).text
album = e.find('.//{%s}name' % ns).text
duration = 0
album_uri = uri
else:
title = e.find('.//{%s}name' % ns).text
artist = e.find('.//{%s}artist/{%s}name' % (ns, ns)).text
album = e.find('.//{%s}album/{%s}name' % (ns, ns)).text
duration = int(float(e.find('.//{%s}length' % ns).text) * 1000)
album_uri = "spotify://" + e.find('.//{%s}album' % ns).attrib['href']
track = Track("spotify://"+uri)
track.title = title
track.artist = artist
track.album = album
track.album_uri = album_uri
track.duration = duration
return track
def create_track_from_uri(self, uri):
if 'youtube' not in uri:
return None
m = re.search('http://www.youtube.com/get_video.video_id=(.*?)&t=(.*)',uri)
client = gdata.youtube.service.YouTubeService()
client.ssl = False
entry = client.GetYouTubeVideoEntry(video_id=m.group(1))
logging.debug("Created track from uri %s in youtubesource", uri)
#PrintEntryDetails(entry)
swfuri = entry.GetSwfUrl()
video_id = m.group(1)
t = m.group(2)
track = Track(uri)
track.title = entry.media.title.text
track.artist = "YOUTUBE VIDEO"
track.album = entry.media.category[0].text
#FIXME add search for author on album?
track.album_uri = None
track.duration = int(entry.media.duration.seconds)*1000
return track
def create_track_from_uri(self, uri):
if 'asx' not in uri:
return None
logging.debug("Created track from uri %s in srradiosource", uri)
u = urllib.urlopen(uri)
str = re.search('\"mms:.+\"', u.read())
u = open("sr.xml")
tree = ET.parse(u)
u.close()
track = Track(str.group(0)[1:-1])
for e in tree.findall('channel'):
for k in e.findall('streamingurl'):
for s in k.findall('url'):
if uri in s.text:
track.title = e.get('name')
track.artist = "SR RADIOTRACK"
track.album = "SR RADIOTRACK"
track.album_uri = None
track.duration = 1
return track
