def ReadTrackTree(self, NEvents=-1): event = 0 nentries = self.TrackTree.GetEntriesFast() events = [] for i in xrange(nentries): self.entry = self.TrackTree.GetEntry(i) events.append(self.TrackTree.event) for i in range(max(events) + 1): self.AllTracks.append([]) print "%i events in track file" % max(events) for i in xrange(nentries): self.entry = self.TrackTree.GetEntry(i) track = Track() for i in range(self.TrackTree.size): track.trackX.append(self.TrackTree.trackX[i]) track.trackY.append(self.TrackTree.trackY[i]) track.chi2.append(self.TrackTree.chi2[i]) track.ndof.append(self.TrackTree.ndof[i]) track.trackNum.append(self.TrackTree.trackNum[i]) track.dxdz.append(self.TrackTree.dxdz[i]) track.dydz.append(self.TrackTree.dydz[i]) track.iden.append(self.TrackTree.iden[i]) event = self.TrackTree.event track.cluster = self.TrackTree.cluster self.AllTracks[event].append(track)
def ReadTrackTree(self,NEvents=-1): event = 0 nentries = self.TrackTree.GetEntriesFast() events = [] for i in xrange(nentries) : self.entry = self.TrackTree.GetEntry(i) events.append(self.TrackTree.event) for i in range(max(events)+1): self.AllTracks.append([]) print "%i events in track file"%max(events) for i in xrange(nentries) : self.entry = self.TrackTree.GetEntry(i) track = Track() for i in range(self.TrackTree.size) : track.trackX.append(self.TrackTree.trackX[i]) track.trackY.append(self.TrackTree.trackY[i]) track.chi2.append(self.TrackTree.chi2[i]) track.ndof.append(self.TrackTree.ndof[i]) track.trackNum.append(self.TrackTree.trackNum[i]) track.dxdz.append(self.TrackTree.dxdz[i]) track.dydz.append(self.TrackTree.dydz[i]) track.iden.append(self.TrackTree.iden[i]) event = self.TrackTree.event track.cluster = self.TrackTree.cluster self.AllTracks[event].append(track)
def __init__(self, *args, **kwargs): super(MyWindow, self).__init__(*args, **kwargs) #this clear thing affect the background color #comment it out to get a black background glClearColor(1, 1.0, 1.0, 1) self.fps_display = FPSDisplay(self) self.car = CarSprite() self.key_handler = key.KeyStateHandler() self.testTrack = Track([40, 60, 1200, 600], [240, 260, 800, 200]) self.testGrid = Grid(40, 60, 1200, 600, 50)
def AddPoint(self, x, y): print "adding point", x, Track.PositionToTime(x) # work out which track is clicked and then pass on the event # to that track i = y / self.track_height if (i < len(self.tracks) and x > self.name_length): self.LastClickedTrack = self.tracks[i] self.tracks[i].AddPoint(Track.PositionToTime(x - self.name_length)) # if the track clicked on is the currently playing track # reload it so that any changes are taken account of if i == self.selectedTrack: self.PlayTrack(i) self.Refresh()
def tracksDict(pl, gm_api): """ Takes in a google music playlist dictionary and an authenticated MobileClient api. The playlist dictionary contains the field 'tracks'; itself a list of "properly ordered playlist entry dicts". Params: pl: google music playlist dict gm_api: authenticated Mobileclient object Returns: playlist: A list of Track objects, in the order they appear in the given playlist. Returned list may be incomplete if not all tracks are hosted on GMusic. notFound: A list of trackIDs foor which metadata could not be found. """ playlist = [] notFound = [] # song metadata used as cross-check reference if a playlist entry doesn't # have desired metadata all_song_meta_data = gm_api.get_all_songs() for t in pl['tracks']: # Check source: # '2' indicates hosted on Google Music, '1' otherwise if t['source'] == '2': song = Track.Track(title=t['track']['title'], artist=t['track']['artist']) playlist.append(song) elif t['source'] == '1': # Important: when source is '1', playlistEntry object's 'trackId' # will correspond w/ a track object's 'id' in all_song_meta_data badtrackID = t['trackId'] song = next((t for t in all_song_meta_data \ if t['id'] == badtrackID), None) if song != None: # create track object, add to new "playlist" track_obj = Track.Track(title=song['title'], artist=song['artist']) playlist.append(track_obj) else: msg = "Error with track " + str(badtrackID) + ": 'source'" + \ " field is '1', but could not find matching metadata." print(msg, file=sys.stderr) notFound.append(badtrackID) else: msg = "Error with track " + str(t['trackId']) + ": 'source'" + \ " field not '1' or '2'." print(msg, file=sys.stderr) notFound.append(t['trackId']) return playlist, notFound
def getFace(video, detector, recognizer): while True: threshold = 70 frame = video.get_frame() face = detector.detect(frame, False) if len(face): frame, faces_img = get_images(frame, face) for i, face_img in enumerate(faces_img): pred, Confidence = recognizer.predict(face_img) print 'Confidence: ' + str(round(Confidence)) print 'Threshold: ' + str(threshold) if Confidence < threshold: if tr.track(frame, face) == 1: break else: cv2.putText(frame, "Unknown", (face[i][0], face[i][1]), cv2.FONT_HERSHEY_PLAIN, 1.7, (206, 0, 209), 2, cv2.LINE_AA) cv2.putText(frame, "ESC to exit", (5, frame.shape[0] - 5), cv2.FONT_HERSHEY_PLAIN, 1.2, (206, 0, 209), 2, cv2.LINE_AA) #cv2.imshow('Video', frame) if cv2.waitKey(100) & 0xFF == 27: sys.exit()
def PCA(self): if self.pcs == None: print "CANNOT DO PCA, scipy isn't loaded" print "doing pca" motion = self.tracks[self.selectedTrack].GetMotion() splits = self.tracks[self.selectedTrack].GetSplits() if len(splits) > 0: motions = [ Piavca.SubMotion(motion, split.GetStart(), split.GetEnd()) for split in splits ] else: motions = [motion] splits = [(0, split.GetStart(), split.GetEnd()) for split in splits] length = Track.PositionToTime( self.track_length) * Track.frames_per_second #self.pcs.do_pca([motion], splits, length, Track.frames_per_second) self.pcs.addMotions(motions) self.pcs.setFramesPerSecond(Track.frames_per_second) self.pcs.create() #self.pcs.setMotion(motion) # load the PCAs into the avatar to play them Piavca.Core.getCore().setCurrentTime(0) #self.avatar.playMotionDirect(Piavca.PyMotion(self.pcs)) self.avatar.playMotionDirect(self.pcs) Piavca.Core.getCore().setCurrentTime(self.time)
def build(self): for elem in sorted(self.path.rglob('*')): # NOTE: <sorted(self.path.glob("**/*"))> gives every file and folder in self.path print(type(elem), elem) if elem.is_file() and elem.suffix in self.patterns: self.tracks.append(Track.Track(elem))
def addTrackWidget(self): self.index = self.count self.count += 1 self.trackArray[self.index] = Track(str(self.count), str(self.projectPath)) self.scrollLayout.addRow(self.trackArray[self.index])
def calculator(xCoords, yCoords, RPMGearVelArr, initialVel): ''' This function takes the array of x coordinates, array of y coordinates and an array with five columns of: Power, RPM, Velocity, Torque, Gear Ratio. The initial normal force is calculated using the maximum velocity of the engine performance. The for loop iterates over the trackcoordinates, calculating the acceleration from the previous point, with a limit on the speed due to the maximum corner velocity. Assuming the acceleration is constant over the distance between the points the velocity can be calculated. The output is the time of the lap and a velocity distance graph. ''' effectiveRadiusArr = Track.effectiveCurve( xCoords, yCoords) # obtain track coordinates from Track script u = initialVel vArr = np.array([u]) # create velocity array with first value torqueInterpArr = np.array( [0]) # create Torque array with 0 as the first value entranceVelArr = np.array([]) # create empty array for entrance velocity distArr = np.array([0]) count = 0 # set count equal to 0 for i in range(0, len(xCoords) - 1): count = count + 1 # increase count hyp = ((xCoords[i + 1] - xCoords[i])**2 + (yCoords[i + 1] - yCoords[i]) **2)**0.5 # calculate hypotenuse of points dist = distArr[-1] + hyp # cumulative addition of hyp to the distance distArr = np.append(distArr, dist) u = vArr[[-1]] # u is equal to the final value in vArr torqueInterp = np.interp( u, RPMGearVelArr[:, 2], RPMGearVelArr[:, 3]) # interpolate the torque for the # given velocity torqueInterpArr = np.append(torqueInterpArr, torqueInterp) gearRatioInterp = np.interp( u, RPMGearVelArr[:, 2], RPMGearVelArr[:, 4]) # approximation of interpolating the # gear values # using function acceleration to calculate the acceleration a = acceleration(torqueInterp, gearRatioInterp, finalDriveRatio, efficiency, wheelDiameter, airDensity, dragCoefficient, frontalArea, u, mass, g, rollingResistanceCoefficient) v = ( u**2 + 2 * hyp * a )**0.5 # assuming constant acceleration over the distance between the points if effectiveRadiusArr[ i] != 'straight': # if the effective radius is not 'straight', then the max corner # velocity may limit the velocity of the vehicle. If the velocity is larger than the maximum value it is # assumed the vehicle will travel at the maximum possible velocity float(effectiveRadiusArr[i]) corner = maxCornerVel( tyreFrictionCoefficient, normalForce(mass, g, airDensity, liftCoefficient, liftArea, u), mass, effectiveRadiusArr[i], airDensity, frontalArea, dragCoefficient, rollingResistanceCoefficient, g) if v > corner: v = corner vArr = np.append(vArr, v) entranceVelArr = np.append(entranceVelArr, v) return distArr, vArr
def loadProject(self): print "project loaded" fname = QtGui.QFileDialog.getOpenFileName(self, 'Open file') json_data = open(fname) data = json.load(json_data) pprint(data) fname = str(fname) base = os.path.basename(fname) path = os.path.splitext(base)[0] print "path " + path tracks = len(data["tracks"]) print "tracks " + str(tracks) count = 0 while count < tracks: print data["tracks"][count]["name"] self.index = self.count self.count += 1 self.trackArray[self.index] = Track(str(self.count), str(self.projectPath)) self.trackArray[self.index].setTrackName( data["tracks"][count]["name"]) self.scrollLayout.addRow(self.trackArray[self.index]) count += 1 self.setProjectPath(path)
def draw_points(self): """ draw_points: define points on the coordinate of canvas """ self.chess_points = [[None for i in range(15)] for j in range(15)] for i in range(15): for j in range(15): self.chess_points[i][j] = Track.Point(i, j)
def main(): # Google Music MobileClient api gm_api = gmusic.login_to_gmusic_with_oauth() print('Logged in to Google music using ', getenv('GMUSIC_OAUTH_CREDS_PATH')) all_songs = gm_api.get_all_user_playlist_contents() # Spotify api sp_api = spotify.login2spotify() user = sp_api.me() print('Logged in to spotify as ', user['display_name']) sp_user_id = user['id'] found = False while not found: try: pl_name = input("Playlist name: ") pl = next((p for p in all_songs if p['name'] == pl_name), None) if pl == None: print('Could not find playlist with name ', pl_name, ', please try again.') else: found = True except EOFError: print('Ok yes goodbye') sys.exit(1) # Found desired playlist, so get data about its tracks all_song_meta_data = gm_api.get_all_songs() badtrackID = '' tracks = [] count = 0 for t in pl['tracks']: # Check for bad source. # '2' indicates hosted on Google Music, '1' otherwise if t['source'] == '1': badtrackID = t['trackId'] song = next((t for t in all_song_meta_data if t['id'] == badtrackID), None) else: # t['source'] == '2' song = t['track'] if song is not None: count += 1 title = song['title'] artist = song['artist'] album = song['album'] track = Track(title=title, artist=artist, album=album) tracks.append(track) new_playlist = Playlist(tracks=tracks, plTitle=pl_name) print('ok, added ', count, ' songs to Playlist object with length ', new_playlist.length) spotify.new_playlist(sp_api, new_playlist, interactive=True)
def main(): setTrack(Track.Track().track) """Testing SensorNode""" sn = SensorNode(0, 0) setPos(coord(5, 5)) for i in xrange(0, 7): sn.direction = i result = sn.getResult() assert result == 0 setPos(coord(5, 1)) sn.direction = 0 res = sn.getResult() assert res == 1 sn.direction = 2 res = sn.getResult() assert res == 0 """Testing MoveNode""" mn = MoveNode(0, 0) res = EvaluateTree(Track.Track().track, coord(5, 1), mn) assert res == -1 mn.direction = 1 res = EvaluateTree(Track.Track().track, coord(5, 1), mn) assert res == 1 """Testing moveCounting""" t = Track.Track() mn = MoveNode(0, 0) res = EvaluateTree(t.track, coord(5, 5), mn) assert res == 0 res = EvaluateTree(t.track, getPos(), mn) assert res == 0 res = EvaluateTree(t.track, getPos(), mn) assert res == 0 res = EvaluateTree(t.track, getPos(), mn) assert res == 1 res = EvaluateTree(t.track, getPos(), mn) assert res == -1
def convert_to_object(self, spotify_track): id = spotify_track['id'] track_title = spotify_track['name'] artists = ', '.join([artist['name'] for artist in spotify_track['artists']]) isrc = '' try: isrc = spotify_track['external_ids']['isrc'] except KeyError: pass return Track(id, track_title, artists, isrc)
def __init__(self): self.car = Car.Car(220, 420, 40, 20) self.track = Track.Track('test', (255, 255, 255)) self.isRendering = False self.observation_space = ((0, 1e9)) * 7 self.rewardIndex = 0 self.isRendering = False
def __init__(self, screen=(540, 840)): self.SCREEN = screen pygame.init() self.logo = pygame.image.load('images.jpg') pygame.display.set_icon(self.logo) pygame.display.set_caption('run') self.screen = pygame.display.set_mode(self.SCREEN) self.tracks = Track.Track(self.screen) self.tracks.generate_track(self.SCREEN) pygame.display.flip() self.me = Person.Person(1, self.screen, self.SCREEN) self.me.person_draw() self.track = Track.Obstacle(self.screen, self.SCREEN) self.run = Track.Running(self.tracks.generate_track(self.SCREEN), self.SCREEN, self.me) self.default = 0
def __init__(self, *args, **kwargs): super(MyWindow, self).__init__(*args, **kwargs) #this clear thing affect the background color #comment it out to get a black background glClearColor(1, 1.0, 1.0, 1) self.fps_display = FPSDisplay(self) self.car = CarSprite() self.key_handler = key.KeyStateHandler() self.testTrack = Track([40, 60, 1200, 600], [240, 260, 800, 200]) self.testGrid = Grid(40, 60, 1200, 600, 50) self.ai = AI() self.train = 0 self.play = 0 self.manualSaveCounter = 0 #printing variable self.episodeCounter = self.ai.episodeCounter self.stepCounter = self.ai.stepCounter self.completeC = 0 self.minStep = self.ai.maxSteps self.toggleGrid = 0
def ReadTracks(self, tracksFile): self.tracks = [] self.tracks.append(Track.Track(self.motion, "All", None)) try: file = open(tracksFile, 'r') # each line contains a name for the track # followed by a list of joint names for line in file.readlines(): joints = line.split() self.tracks.append( Track.Track(self.motion, joints[0], joints[1:])) print "tracks from file" print "self.motion", self.motion except IOError: for trackname in default_tracks.keys(): self.tracks.append( Track.Track(self.motion, trackname, default_tracks[trackname])) print "self.motion", self.motion print "tracks used", self.tracks self.SetItemCount(len(self.tracks))
def __init__(self, avatar, motion, motion_name, tracksFile, parent, id): # the MotionTracks are based on the wxPython VListBox print "list constructor" wx.VListBox.__init__(self, parent, id) print "after parent constructor" self.distancemeasure = None # the Motion tracks will control time in Piavca, not # the piavca timer Piavca.Core.getCore().setAutoTimeOff() self.showfootplants = 0 self.SetTime(0) self.playing = 0 # the avatar the motion is played on self.avatar = avatar # the motion being analysed self.motion = motion self.motion_name = motion_name self.motiongraph = None # play the motion on the avatar self.avatar.playMotionDirect(motion) # set up the parameters of the tracks self.track_height = 20 self.name_length = 60 self.track_length = Track.TimeToPosition(motion.getMotionLength()) print "track length", self.track_length, "motionlength", motion.getMotionLength( ) self.selectedTrack = None # read in a specification of which tracks to use self.ReadTracks(tracksFile) # the last track that the user interacted with # (for undoing) self.LastClickedTrack = None # the size of the window windowlength = self.GetLength() windowheight = self.GetHeight() self.SetSize(wx.Size(windowlength, windowheight)) print "end of list constructor" print "item count", self.GetItemCount() # start without any Principal Components #self.pcs = ComponentAnalysis.ComponentAnalysis() self.pcs = None try: self.pcs = Piavca.PCAMotion() except: pass
def OnDrawBackground(self, dc, rect, item): #print "drawing background", item if item == self.selectedTrack: dc.SetBrush(wx.Brush("orange")) else: dc.SetBrush(wx.Brush("white")) dc.DrawRectangle(rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight()) dc.SetBrush(wx.Brush("blue")) dc.DrawRectangle( Track.TimeToPosition(self.time) + self.name_length, rect.GetTop(), 5, rect.GetHeight())
def main(): # Organism # Dendraster # Largest Organism diameter in mm Dorg = 0.3 dataFolder = '/Volumes/GRAVMACH1 2/HopkinsEmbroyologyCourse_GoodData/2018_06_11/Dendraster_starved_11Days_nofood' # Load the set of tracks we want to analyze TrackNames = {0: 'Dendraster1', 1: 'Dendraster2', 2: 'Dendraster3'} TrackFile = 'track.csv' SquaredDisp_XY = [] SquaredDisp_Z = [] trackLen_array = np.zeros(len(TrackNames.keys())) # SquaredDisp_subtracks = for ii, currFolder in TrackNames.items(): Track_curr = Track.GravMachineTrack( os.path.join(dataFolder, currFolder, TrackFile)) trackLen_array[ii] = Track_curr.trackLen SquaredDisp_Z.append( squared_displacement(Track_curr.Z, 0, Track_curr.trackLen)) SquaredDisp_XY.append( squared_displacement(Track_curr.X, 0, Track_curr.trackLen) + squared_displacement(Track_curr.Y, 0, Track_curr.trackLen)) maxTrackLen = np.max(trackLen_array) stackedArray_Z = np.zeros((len(TrackNames.keys(), maxTrackLen))) stackedArray_XY = np.zeros((len(TrackNames.keys(), maxTrackLen))) for ii in TrackNames.keys(): stackedArray_Z[ii, :trackLen_array[ii]] = SquaredDisp_Z[ii] stackedArray_XY[ii, :trackLen_array[ii]] = SquaredDisp_XY[ii] stackedArray_Z = np.ma.array(stackedArray_Z, mask=stackedArray_Z == 0) stackedArray_XY = np.ma.array(stackedArray_XY, mask=stackedArray_XY == 0) RMSD_Z = (stackedArray_Z.mean(axis=0)) RMSD_XY = (stackedArray_XY.mean(axis=0))
def build(json_path): connections.create_connection(hosts=['localhost']) music = Index('music') # define custom settings music.settings(number_of_shards=1, number_of_replicas=0) # delete the index, ignore if it doesn't exist music.delete(ignore=404) # create the index in elasticsearch # music.create() Track.init() track_dict = import_dict(json_path) track_list = [] for key in track_dict: latitude = convert(track_dict[key]["artist_latitude"]) longitude = convert(track_dict[key]["artist_longitude"]) song_hotttnesss = convert(track_dict[key]["song_hotttnesss"]) danceability = convert(track_dict[key]["danceability"]) duration = convert(track_dict[key]["duration"]) track = Track(track_id=track_dict[key]["track_id"], title=track_dict[key]["title"], lyric=track_dict[key]["original_lyrics"], artist_name=track_dict[key]["artist_name"], artist_id=track_dict[key]["artist_id"], artist_location=track_dict[key]["artist_location"], genres=track_dict[key]["genre"], album=track_dict[key]["release"], year=track_dict[key]["year"], similar_artists=track_dict[key]["similar_artists"], artist_latitude=latitude, artist_longitude=longitude, song_hotttnesss=song_hotttnesss, danceability=danceability, duration=duration) track.meta.id = key track_list.append(track) print len(track_list) es = Elasticsearch() helpers.bulk(es, (d.to_dict(include_meta=True) for d in track_list))
class MyWindow(pyglet.window.Window): def __init__(self, *args, **kwargs): super(MyWindow, self).__init__(*args, **kwargs) #this clear thing affect the background color #comment it out to get a black background glClearColor(1, 1.0, 1.0, 1) self.fps_display = FPSDisplay(self) self.car = CarSprite() self.key_handler = key.KeyStateHandler() self.testTrack = Track([40, 60, 1200, 600], [240, 260, 800, 200]) self.testGrid = Grid(40, 60, 1200, 600, 50) def on_draw(self): glClear(GL_COLOR_BUFFER_BIT) self.fps_display.draw() self.testGrid.draw() self.testTrack.draw() self.car.draw() def on_key_press(self, symbol, modifiers): if symbol == key.UP: print('accelerate') self.car.goStraight() elif symbol == key.DOWN: print('reverse') self.car.goReverse() elif symbol == key.LEFT: print('turn left') self.car.turnLeft() elif symbol == key.RIGHT: print('turn right') self.car.turnRight() elif symbol == key.ESCAPE: pyglet.app.exit() def update(self, dt): pass
def OnLeftClick(self, x, y): print "OnLeftClick" self.restartPlaying = 0 if x < self.name_length: i = y / self.track_height if (i < len(self.tracks)): self.SelectTrack(i) else: self.SetTime(Track.PositionToTime(x - self.name_length)) # restart playing to get make sure it plays from the new time if self.playing: self.Stop() self.restartPlaying = 1 else: self.restartPlaying = 0
def __init__(self, target=None, height=0, width=0): """ Initializing the chessboard by drawing points and grids. Attributes: target: a drawing object. It uses to add the title of the frame. height: an integer that stands for the height of canvas. width: an integer that stands for the width of canvas. Track_Record: track the chessbroad status. Then, draw points and grids on the canvas. """ tkinter.Canvas.__init__(self, target, height=height, width=width) self.Track_Record = Track.Track_Record() self.draw_points() #draw points on canvas self.draw_canvas() #draw grids on canvas
def __init__(self, pop_size, mut_rate): self.pop_size = pop_size self.mut_rate = mut_rate self.tracks = [] # Seeds the initial population with random tracks for i in range(pop_size): track = Track() track.random(32) track.normalize() hq.heappush(self.tracks, track)
def mousemoving_map(self, event): self.clean_markings() # TODO: there is maybe stil a bug in CROSSING = False in seldom cases? self.pos = event.pos spos = self.is_station_pos(self.pos) # TODO: there should be no station in the way # (plus a little extrasize) # or: minimum angle between tracks if self.draw_status and spos and not is_in_range( self.pos, self.startpos): # create a potential new track if (not DOUBLE_TRACKS and not self.is_track(self.startpos, spos) and not self.is_track(spos, self.startpos)): if (len(self.get_station(spos).get_tracks()) < MAXSTATIONTRACKS and len(self.get_station( self.startpos).get_tracks()) < MAXSTATIONTRACKS): if 'track' in DEBUG: print("stop drawing at ", self.pos, " moving to ", spos) if self.score >= TRACKCOST: self.status = "Build track for $" + str(TRACKCOST) self.score -= TRACKCOST if self.have_line: if 'track' in DEBUG: print("appending track to line with color", self.drawing_color) # TODO: parameter in self should not be necessary newtrack = Track.Track(self, self.startpos, spos, self.drawing_color, self.line, 0) else: if 'track' in DEBUG: print("creating new line...") self.line = Line.Line(self, self.startpos, spos) self.lines.append(self.line) self.have_line = True self.startpos = spos else: self.status = "Not enough money left to build track for $" + str( TRACKCOST) else: self.status = "to many tracks at station!" else: self.status = "no doubletracks allowed!"
def init(data): data.width = width data.height = height data.size = (data.width, data.height) data.screen = pygame.display.set_mode(data.size) data.fps = 60 Obstacle.Obstacle.init() data.obstacles = pygame.sprite.Group() data.leftObstacles = pygame.sprite.Group() data.midObstacles = pygame.sprite.Group() data.rightObstacles = pygame.sprite.Group() Explosion.init() data.explosions = pygame.sprite.Group() data.bg = Colors.black data.bg = pygame.image.load("Images/background4.png").convert() data.bg = pygame.transform.scale(data.bg, (data.width, data.height)) data.track = Track.Track(data) Player.init(data) data.players = pygame.sprite.GroupSingle() data.leftPlayers = pygame.sprite.GroupSingle() data.midPlayers = pygame.sprite.GroupSingle() data.rightPlayers = pygame.sprite.GroupSingle() data.scrollY = 0 data.score = 0 data.mode = "splashScreen" data.gameModes = ["Groove Mode", "Rhythm Mode"] data.title = pygame.image.load("Images/title.png") data.instructions = pygame.image.load("Images/instructions.png") data.running = True data.songsPath = "Music" data.songNames = [i for i in os.listdir(data.songsPath) \ if not os.path.isdir(data.songsPath + '/' + i)] data.songs = [ font.render(i[:-4], False, Colors.white) for i in data.songNames ] data.highlighted = 0 data.lanes = 3 data.delay = 3000 # in ms, 3 seconds data.songGameOffset = .75 # in seconds data.curIndex = -1 data.lastLane = 0 data.lastIndexObstacleAdded = 0 data.indecesBetweenObstacles = 10
def _load_playlist(manager, playlist_filename): print "Loading playlist '" + playlist_filename + "'" with open(playlist_filename, "r") as f: content = f.readlines() for l in content: soundpath = l.rstrip() if soundpath: try: imagepath = soundpath + ".bmp" sound, image = _get_sound_and_image(soundpath, imagepath) if sound != None: track = Track.Track(sound, soundpath.split("/")[-1], image) manager.add(track) except RuntimeError: print "Error when loading sound '" + l + "'" f.close()
def __init__(self, game, start, end): self.game = game self.color = game.LINES[-1] self.tracks = [] self.stations = [start, end] newtrack = Track.Track(self.game, start, end, self.color, self)
# (Tau=torque,alpha=alpha,beta=beta,v0=14) #speed, err= sp.integrate.quad( accelbalance ,0,1, args=(tiger19 , tire , Tau , v0 )) #print speed def brakebalance(u,t,car,tire,v0): u1, u2=u #u1=x u2=x' beta=( 2*car.massv ) / ( car.cd * const.rhoair * car.frontarea ) gamma=( 2*car.massv ) / ( tire.mu * car.cl * const.rhoair * car.frontarea ) uprime=[u2 , -tire.mu * sp.constants.g - ( 1/gamma + 1/beta ) * u2**2] return uprime #print sp.integrate.odeint(brakebalance,[0,14],np.linspace(0,2,100),args=(tiger19,tire,v0)) #Track must start and end with corner (can be same corner if continous track) track1=Track() track1.add_feature(Corner(10,25)) track1.add_feature(Straight(70)) track1.add_feature(Corner(10,25)) track1.add_feature(EndFeature) def LapTimeCalc(Track,Car,Tire,tau): vlast=0.01 dt=.001 laptime=float(0) for i in range(Track.num_features()): print i feature = Track._features[i] if isinstance(Track._features[i],EndFeature): next_feature=Track.features[0]
def GetTrack(self,i) : self.getEvent(i) posX_tmp = [] posY_tmp = [] dxdz_tmp = [] dydz_tmp = [] iden_tmp = [] chi2_tmp = [] ndof_tmp = [] trackNum_tmp = [] nTrackParams_tmp = 0 tracks = [] #--------------------- self.t_nTrackParams = self.TrackTree.nTrackParams #------------------------------------- self.t_euEv= self.TrackTree.euEvt #------------------------------------- self.t_posX = self.TrackTree.xPos #-------------------------------------- self.t_posY= self.TrackTree.yPos #-------------------------------------- self.t_dxdz= self.TrackTree.dxdz #-------------------------------------- self.t_dydz= self.TrackTree.dydz #-------------------------------------- self.t_iden= self.TrackTree.iden #------------------------------ self.t_trackNum= self.TrackTree.trackNum #-------------------------------------- self.t_chi2= self.TrackTree.chi2 #------------------------------------- self.t_ndof = self.TrackTree.ndof for data in self.t_posX : posX_tmp.append(data) for data in self.t_posY : posY_tmp.append(data) for data in self.t_iden : iden_tmp.append(data) for data in self.t_dxdz : dxdz_tmp.append(data) for data in self.t_dydz : dydz_tmp.append(data) for data in self.t_chi2 : chi2_tmp.append(data) for data in self.t_ndof : ndof_tmp.append(data) for data in self.t_trackNum : trackNum_tmp.append(data) nTrackParams_tmp=self.t_nTrackParams if len(trackNum_tmp)>0 : for j in range(max(trackNum_tmp)+1) : aTrack = Track() ndata = nTrackParams_tmp/(max(trackNum_tmp)+1) #print "nTrackParam : %i len(trackNum %i)"%(nTrackParams_tmp,max(trackNum_tmp)+1) aTrack.trackX = posX_tmp[j*ndata:j*ndata+ndata] aTrack.trackY = posY_tmp[j*ndata:j*ndata+ndata] for index,element in enumerate(aTrack.trackX) : #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1 aTrack.trackX[index] = aTrack.trackX[index]-halfChip_X-pitchX/2. aTrack.trackY[index] = aTrack.trackY[index]-halfChip_Y-pitchY/2. aTrack.iden = iden_tmp[j*ndata:j*ndata+ndata] aTrack.chi2 = chi2_tmp[j*ndata:j*ndata+ndata] aTrack.trackNum = trackNum_tmp[j*ndata:j*ndata+ndata] aTrack.ndof = ndof_tmp[j*ndata:j*ndata+ndata] aTrack.dxdz = dxdz_tmp[j*ndata:j*ndata+ndata] aTrack.dydz = dydz_tmp[j*ndata:j*ndata+ndata] if(aTrack.chi2[0]<self.Chi2_Cut): tracks.append(aTrack) #print aTrack.chi2 self.AllTracks.append(tracks)