def getNextIntersectionAndRecord(self, veh, fids, maxfid, n): vid = veh.getVID() fid = veh.getFrame() n = len(fids) if vid in self.nextIntersections: if fid in self.nextIntersections[vid]: return self.nextIntersections[vid][fid] else: self.nextIntersections[vid] = {} for nextfid_index in range( fids.index(fid), n ): #starting at current fid, iterate over all frames vehicle appears in nextfid = fids[nextfid_index] if vid not in self.frameDict[nextfid]: print("vid is not in a frame it should be:", vid, fid) continue veh = v.vehicle(self.frameDict[nextfid][vid]) if veh.getIntersection( ) > 0: #if in intersection, find last in intersection lastFid_ind_InIntersection = n - 1 #if we don't find, it is last index for curFrame_ind in range( nextfid_index, n): #find last frame where vid is in intersection curFrame = fids[curFrame_ind] otherveh = v.vehicle(self.frameDict[curFrame][vid]) if otherveh.getIntersection() == 0: lastFid_ind_InIntersection = curFrame_ind - 1 break intersect = veh.getIntersection() for interfid_ind in range( fids.index(fid), lastFid_ind_InIntersection ): #from current fid through intersection, fill it in self.nextIntersections[vid][fids[interfid_ind]] = intersect return intersect return 0
def getTrafficFeatures(self, fid, vid): trafficFeatures = [] frame = self.frameDict[fid] veh = v.vehicle(frame[vid]) car_in_front_vid = veh.getPreceding() car_in_rear_vid = veh.getFollowing() left_front_vid, left_back_vid, right_front_vid, right_back_vid = dutil.getNeighbors( frame, veh) vids = [ car_in_front_vid, car_in_rear_vid, left_front_vid, left_back_vid, right_front_vid, right_back_vid ] numFeatures = (len(["dx", "dy"]) + len(["V", "A", "yaw", "hdwyInd", "headway"])) for neighbor_vid in vids: if neighbor_vid > 0 and neighbor_vid in frame.keys(): veh2 = v.vehicle(frame[neighbor_vid]) trafficFeatures.append(1) #indicator trafficFeatures.append(veh2.getX() - veh.getX()) trafficFeatures.append(veh2.getY() - veh.getY()) trafficFeatures.extend(veh2.getTrainFeaturesTraff()) else: trafficFeatures.extend([0] * (numFeatures + 1)) all_vids = vids all_vids.append(vid) intersection_vid = self.getIntersectionVID(frame, veh, all_vids) if intersection_vid > 0 and intersection_vid in frame.keys(): veh2 = v.vehicle(frame[intersection_vid]) trafficFeatures.append(1) #indicator trafficFeatures.append(veh2.getX() - veh.getX()) trafficFeatures.append(veh2.getY() - veh.getY()) trafficFeatures.extend(veh2.getTrainFeaturesTraff()) else: trafficFeatures.extend([0] * (numFeatures + 1)) return trafficFeatures
def setFirstOrient(self): frame = self.frameDict[self.firstFrame] for vid in frame.keys(): arr = frame[vid] veh = v.vehicle(arr, self.compressed) arr.append(veh.getOrientation()) self.frameDict[self.firstFrame][vid] = arr
def getFeatureVectors(self, fids, laneType=True, useHistory=False, historyFrames=[], useTraffic=True, bool_peach=False): featVecs = np.ascontiguousarray([]) fids = sorted(list(fids)) numFids = len(fids) numDone = 0 for fid in fids: fid = int(fid) numDone = numDone + 1 if numDone % int(numFids / 10) == 0: print("Done making features for", numDone, "/", numFids, "frames...") frame = self.frameDict[fid] for vid in sorted(list(frame.keys())): veh = v.vehicle(frame[vid]) fullFeatures = [] if laneType: fullFeatures.extend(veh.getTrainFeatures1(bool_peach)) else: fullFeatures.extend(veh.getTrainFeatures2()) if useHistory: fullFeatures.extend( self.getHistory(fids, fid, vid, historyFrames)) if useTraffic: fullFeatures.extend(self.getTrafficFeatures(fid, vid)) if featVecs.size == 0: featVecs = np.ascontiguousarray(fullFeatures) else: featVecs = np.vstack((featVecs, fullFeatures)) return np.ascontiguousarray(featVecs)
def findConstraints(self): #1-moto, 2-auto, 3-truck if self.featurepath: print("Loading constraints...") return self.loadFeatureConstraints('constraints') print("Finding constraints...") maxaccel = {1: 0, 2: 0, 3: 0} minaccel = {1: 0, 2: 0, 3: 0} maxvel = {1: 0, 2: 0, 3: 0} minvel = {1: 0, 2: 0, 3: 0} for frameid in self.frameDict.keys(): if int(frameid) % 300 == 0: print("on frame", frameid, "...") for vid in self.frameDict[frameid].keys(): veh = v.vehicle(self.frameDict[frameid][vid], self.compressed) vclass = veh.getClass() if veh.getAx() < 30 and veh.getAy() < 30: maxaccel[vclass] = max(veh.getAx(), veh.getAy(), maxaccel[vclass]) if veh.getAx() > -30 and veh.getAy() > -30: minaccel[vclass] = min(veh.getAx(), veh.getAy(), minaccel[vclass]) maxvel[vclass] = max(veh.getVx(), veh.getVy(), maxvel[vclass]) minvel[vclass] = min(veh.getVx(), veh.getVy(), minvel[vclass]) return maxaccel, minaccel, maxvel, minvel
def findMaxVID(self): lastFrame = self.frameDict[self.numFrames] maxvid = 0 for vid in lastFrame.keys(): veh = v.vehicle(lastFrame[vid], self.compressed) maxvid = max(int(veh.getVID()), maxvid) return maxvid
def saveFrameDict(filepath, frameDict, compressed): filename = os.path.basename(filepath) if compressed: outpath = filepath[:-len(filename)]+'driv_compr_'+filename else: outpath = filepath outFile = open(outpath, 'w') frames = list(frameDict.keys()) frames.sort() for frame in frames: vids = list(frameDict[frame].keys()) vids.sort() for vid in vids: veh = v.vehicle(frameDict[frame][vid], compressed) '''if not len(frameDict[frame][vid]) == 30: print(len(frameDict[frame][vid])) if abs(veh.getOrientation()) > math.pi: print("Problem, yaw too large.") print(vid) print(veh.getOrientation())''' arr = veh.returnArrayInfo() #if len(arr) < 21: # print("Issue with array length in saving: ", len(arr)) outFile.write(arrToStrForSave(arr)) outFile.close()
def plotFrame(curFrame, fid, signals=None, compressed=False): cars_x = [] cars_y = [] #bikes_x = [] #bikes_y = [] #trucks_x = [] #trucks_y = [] for vid in curFrame.keys(): veh = v.vehicle(curFrame[vid],compressed) x=float(veh.getX()) y=float(veh.getY()) '''if veh.getClass() == '2': bikes_x.append(x) bikes_y.append(y) elif veh.getClass() == '3': cars_x.append(x) cars_y.append(y) else: trucks_x.append(x) trucks_y.append(y)''' cars_x.append(x) cars_y.append(y) #x,y = getFramePoints(curFrame) #plt.plot(bikes_x,bikes_y, 'ko') plt.plot(cars_x,cars_y, 'bo') #plt.plot(trucks_x,trucks_y, 'bo') plt.title("t = " + str(fid)) plt.axis([-100, 100, -250, 1750]) if signals: plt.plot(signals['red']['x'], signals['red']['y'], 'ko') plt.plot(signals['green']['x'], signals['green']['y'], 'go') #display.clear_output(wait=False) display.display(plt.gcf())
def checkFrameLen(self, desired_length, frameid, errmsg="Error:", yaw=False): for vid in self.frameDict[frameid].keys(): if self.checkEntryLen(desired_length, frameid, vid, errmsg): if yaw: veh = v.vehicle(self.frameDict[frameid][vid], self.compressed) print("YAW", veh.getOrientation())
def setDestCords(self, goal_to_cords): for frameid in self.frameDict.keys(): for vid in self.frameDict[frameid].keys(): new_veh_array = self.frameDict[frameid][vid] veh = v.vehicle(new_veh_array, self.compressed) dest = veh.getDest() destLane = veh.getDestLane() cords = goal_to_cords[(dest, destLane)][0] new_veh_array.append(cords[0]) new_veh_array.append(cords[1]) self.frameDict[frameid][vid] = new_veh_array
def find_interesting_parts(data): interesting_parts = {} for frameid in range(data.getFirstFrame(), data.getNumFrames() + 1): frame = data.getFrame(frameid) interestingVehiclesInFrame = [] for vid in frame.keys(): veh = v.vehicle(frame[vid], data.getCompressed()) if inInterestingScenario(veh): interestingVehiclesInFrame.append(vid) interesting_parts[frameid] = interestingVehiclesInFrame return interesting_parts
def getNextIntersection(self, veh): curFid = veh.getFrame() vid = veh.getVID() sortedframeIDs = self.getFrames() for fid in sortedframeIDs: if fid > curFid: if not vid in self.frameDict[fid].keys(): return 0 veh2 = v.vehicle(self.frameDict[fid][vid]) if veh2.getIntersection() > 0: return veh2.getIntersection() return 0
def getXClosest(frame, veh, X, fullvidlist): closest = {-i: 99999 - i for i in range(0, X)} for vid in fullvidlist: furthestClosestKey = find_furthest(closest) veh2 = v.vehicle(frame[vid]) dist = math.sqrt( math.pow((veh.getX() - veh2.getX()), 2) + math.pow((veh.getY() - veh2.getY()), 2)) if dist < closest[furthestClosestKey]: closest.pop(furthestClosestKey) closest[vid] = dist return list(closest.keys())
def getHistory(self, fids, fid, vid, history, bool_peach=False): historyFeatures = [] fid = int(fid) for oldfid in [fid - history[i] for i in range(0, len(history))]: if oldfid in self.frameDict.keys(): oldframe = self.frameDict[oldfid] if vid in oldframe.keys(): oldveh = v.vehicle(oldframe[vid]) new = [1] #append a 1 for an indicator new.extend(oldveh.getTrainFeaturesHist(bool_peach)) historyFeatures.extend(new) else: #vehicle wasnt in scene, append 0s, and a 0 for not existing curveh = v.vehicle(self.frameDict[fid][vid]) historyFeatures.extend( [0] * (len(curveh.getTrainFeaturesHist(bool_peach)) + 1)) '''firstframewithvid = fid for frameid in range(oldfid, fid): #at max 30 loops oldframe = self.frameDict[frameid] if vid in oldframe.keys(): firstframewithvid = frameid break frame = self.frameDict[firstframewithvid] oldveh = v.vehicle(frame[vid]) historyFeatures.extend(oldveh.getTrainFeaturesHist())''' else: #frame before measurements, append 0s curveh = v.vehicle(self.frameDict[fid][vid]) historyFeatures.extend( [0] * (len(curveh.getTrainFeaturesHist(bool_peach)) + 1)) ''' firstframewithvid = fid for frameid in range(fids[0], fid): #at max 30 loops oldframe = self.frameDict[frameid] if vid in oldframe.keys(): firstframewithvid = frameid break frame = self.frameDict[firstframewithvid] oldveh = v.vehicle(frame[vid]) historyFeatures.extend(oldveh.getTrainFeaturesHist())''' return historyFeatures
def getYInner(row, dictOfFrames, predict, compressed): y_for_id = np.array([]) #this will have numFrames rows and 1 column for frame in range(row[1],row[2]): veh = v.vehicle(dictOfFrames[frame], compressed) if predict == 'Y': yrow = veh.y elif predict == 'X': yrow = veh.x else: print("ERROR: invalid prediction request:", predict) return None y_for_id = np.append(y_for_id,yrow) return y_for_id
def generateTrajFeaturesLSTM(self, vid, frames, laneType, useHistory, historyFrames, useTraffic, TrajLen, bool_peach): result = {} curTrajFeatures = None #keep track of one feature thing, when it gets to traj len, add to result #will be shape (trajLen, numFeatures+3) curInter = None for fid in frames: veh = v.vehicle(self.frameDict[fid][vid]) interid = self.getNextIntersectionAndRecord( veh, frames, None, None ) #remember, the frames are all the frames the vehicle appears in nextMove = veh.getNextMove() if nextMove == 0 or interid == 0 or veh.getIntersection( ) > 0: #if vehicle is not approaching an intersection or is already in one curTrajFeatures = None #reset curInter = None continue fidvid = [fid, vid] fullFeatures = self.getFeaturesForFidVid( [], fid, vid, laneType, useHistory, historyFrames, useTraffic, bool_peach) #this is a list fullFeatures.extend(fidvid) fullFeatures.append(nextMove) if (curInter and interid == curInter) or curInter == None: curInter = interid else: curTrajFeatures = None #reset curInter = None continue if curTrajFeatures != None: #print("Before apend", np.array(curTrajFeatures).shape) #curTrajFeatures.append(fullFeatures) #print("Before insert", np.array(curTrajFeatures).shape) curTrajFeatures.insert(0, fullFeatures) #print("After both", np.array(curTrajFeatures).shape) #features in front because we are reverse iterating else: curTrajFeatures = [fullFeatures] if len(curTrajFeatures ) >= TrajLen: #> for some tests, should not affect actual if curInter in result: result[curInter] = np.vstack( (result[curInter], np.ascontiguousarray([curTrajFeatures]))) else: result[curInter] = np.ascontiguousarray([curTrajFeatures]) curTrajFeatures = None #reset curInter = None return result
def getTargets(self, fids): targets = [] fids = sorted(list(fids)) numFids = len(fids) numDone = 0 for fid in fids: numDone = numDone + 1 if numDone % int(numFids / 10) == 0: print("Done making targets for", numDone, "/", numFids, "frames...") frame = self.frameDict[fid] for vid in sorted(list(frame.keys())): veh = v.vehicle(frame[vid]) targets.append(veh.getNextMove()) return np.array(targets)
def setOrientations(self, prevFrame, curFrame, curid): threshold = 0.5 #if the car moves a very small amount dont update max_diff = math.pi / 4 #if there is too much rotation ignore. numToAverage = 3 #smooth orientation over the last 3 orientations for vid in curFrame.keys(): if vid in prevFrame.keys(): veh_cur = v.vehicle(curFrame[vid], self.compressed) veh_prev = v.vehicle(prevFrame[vid], self.compressed) dx = veh_cur.getX() - veh_prev.getX() dy = veh_cur.getY() - veh_prev.getY() if abs(dx) < threshold or abs(dy) < threshold: if abs(self.calcYaw(dy, dx) - veh_prev.getOrientation()) > max_diff: yaw = veh_prev.getOrientation() else: yaw = self.calcYaw(dy, dx) else: yaw = self.calcYaw(dy, dx) prev_tot = veh_prev.getOrientation() * numToAverage new_avg = ((prev_tot - veh_prev.getOrientation()) + yaw) / numToAverage new_veh_data = curFrame[vid] new_veh_data.append(new_avg) self.frameDict[curid][vid] = new_veh_data
def getAllFeatureVectors_intersection(self, fids, laneType=False, useHistory=False, historyFrames=[], useTraffic=False, bool_peach=False, ids=[1, 2, 3, 4]): features = {} for interid in ids: features[interid] = np.ascontiguousarray([]) numinstances = len(fids) numDone = 0 maxfid = max(fids) n = numinstances for fid in fids: frame = self.frameDict[fid] numDone += 1 #if numDone % int(numinstances/10) == 0: print("Done making features for", numDone, "/", numinstances, "instances...") for vid in sorted(list(frame.keys())): veh = v.vehicle(frame[vid]) nextMove = veh.getNextMove() if nextMove == 0: continue interid = self.getNextIntersectionAndRecord( veh, fids, maxfid, n) if interid == 0: continue fullFeatures = [] if laneType: fullFeatures.extend(veh.getTrainFeatures1(bool_peach)) else: fullFeatures.extend(veh.getTrainFeatures2()) if useHistory: fullFeatures.extend( self.getHistory([], fid, vid, historyFrames)) if useTraffic: fullFeatures.extend(self.getTrafficFeatures(fid, vid)) fullFeatures.append(nextMove) if features[interid].size == 0: features[interid] = np.ascontiguousarray(fullFeatures) else: features[interid] = np.vstack( (features[interid], fullFeatures)) for interid in features: features[interid] = np.ascontiguousarray(features[interid]) return features
def visualize_frame_and_signals(frame, signalDict, fid): timeStr = v.vehicle(frame[list(frame.keys())[0]]).getGlobalT() frame_date_time = dru.convertNGSIMtimestampToDateTime(timeStr) #signals['green'].x/y, signals['red'].x/y ---- NOTE assumes no yellows... signalCordsColors = { 'green': { 'x': [], 'y': [] }, 'red': { 'x': [], 'y': [] } } for intersection in signalDict.keys(): if not frame_date_time in signalDict[intersection].keys(): mindis = 999999 closest = None for date_time in signalDict[intersection]: dist = abs(frame_date_time.hour - date_time.hour) * 60 * 60 dist = dist + abs(frame_date_time.minute - date_time.minute) * 60 dist = dist + abs(frame_date_time.second - date_time.second) dist = dist + abs(frame_date_time.microsecond - date_time.microsecond) * 0.001 if dist < mindis: closest = date_time mindis = dist greens = signalDict[intersection][closest] else: greens = signalDict[intersection][frame_date_time] cords = getCords(intersection) for ident in greens: ident = int(ident) if ident not in cords.keys(): print("Not a light") continue #not a light, likely ped signal signalCordsColors['green']['x'].append(cords[ident][0]) signalCordsColors['green']['y'].append(cords[ident][1]) for key in cords.keys(): if str(key) not in greens and key not in greens: signalCordsColors['red']['x'].append(cords[key][0]) signalCordsColors['red']['y'].append(cords[key][1]) fut.plotFrame(frame, fid, signals=signalCordsColors) plt.clf() return frame_date_time
def getSide_FrontAndBack(frame, veh, sidevidlist): closest2 = getXClosest(frame, veh, 2, sidevidlist) vidlist = closest2 if 0 in vidlist: return [0] * 2 elif -1 in vidlist: vid = [i for i in vidlist if not i == -1][0] else: vid = vidlist[0] veh2 = v.vehicle(frame[vid]) if veh2.getPreceding() in set(vidlist) - set([vid]): back_vid = vid front_vid = veh2.getPreceding() else: back_vid = veh2.getPreceding() front_vid = vid return front_vid, back_vid
def findPrintAvg(frameDict, isCompressed): print("Finding averages") sumAx = 0 sumAy = 0 sumVx = 0 sumVy = 0 n = 0 for frame in frameDict.keys(): for vid in frameDict[frame].keys(): veh = v.vehicle(frameDict[frame][vid], isCompressed) sumAx = sumAx + abs(veh.getAx()) sumAy = sumAy + abs(veh.getAy()) sumVx = sumVx + abs(veh.getVx()) sumVy = sumVy + abs(veh.getVy()) n = n + 1 avg = [sumAx / n, sumAy / n, sumVx / n, sumVy / n] print(avg)
def removeIDfromGrid(Frame, VID, Grid, compressed): #vehicleTraj = Frame[VID] if VID not in Frame: return Grid vehicleData = Frame[VID] veh = v.vehicle(vehicleData, compressed) xpos = veh.x ypos = veh.y #[xpos,ypos]=vehicleTraj[[constants.LocalX,constants.LocalY]] indexX, indexY = futil.GetGridIndices(xpos,ypos) if futil.InGridBounds(veh.getX(), veh.getY()): if Grid[indexX][indexY][0] > 1: Grid[indexX][indexY][0] = Grid[indexX][indexY][0]-1 #recalculate velocities? else: Grid[indexX][indexY] = [0]*len(veh.GridInfo) return Grid
def getIntersectionVID(self, frame, veh, otherNeighborsVIDs): if veh.getSection == 0: notUsedVids = [] for vid in frame.keys(): if vid not in otherNeighborsVIDs: notUsedVids.append(vid) return (dutil.getXClosest(frame, veh, 1, notUsedVids))[0] nextIntersection = self.getNextIntersection(veh) vids = frame.keys() interVIDs = [] for vid in vids: if not vid in otherNeighborsVIDs: veh2 = v.vehicle(frame[vid]) if veh2.getIntersection() == nextIntersection: interVIDs.append(vid) if len(interVIDs) > 0: return (dutil.getXClosest(frame, veh, 1, interVIDs))[0] return 0
def getNeighbors(frame, veh): left_front_vid, left_back_vid, right_front_vid, right_back_vid = [0] * 4 if veh.getSection() == 0: return getXClosest(frame, veh, 4, list(frame.keys())) #because in intersection lanesToMedian, lanesToCurb = veh.getLanesToSides() curLane = veh.getLane() leftLane = 0 rightLane = 0 if lanesToMedian > 0: if curLane == 1: if lanesToMedian == 1: leftLane = 11 else: leftLane = 12 elif curLane == 12: leftLane = 11 elif curLane == 31: leftLane = 3 else: leftLane = curLane - 1 if lanesToCurb > 0: if curLane == 12: rightLane = 1 elif curLane == 11: if veh.getSection() == 3: rightLane = 12 else: rightLane = 1 else: rightLane = curLane + 1 leftVids = [] rightVids = [] for vid in frame.keys(): veh2 = v.vehicle(frame[vid]) if veh2.getSection() == veh.getSection(): if leftLane > 0 and veh2.getLane() == leftLane: leftVids.append(vid) elif rightLane > 0 and veh2.getLane() == rightLane: rightVids.append(vid) left_front_vid, left_back_vid = getSide_FrontAndBack(frame, veh, leftVids) right_front_vid, right_back_vid = getSide_FrontAndBack( frame, veh, rightVids) return left_front_vid, left_back_vid, right_front_vid, right_back_vid
def FrameToGrid(frame, mean_centered, compressed=False): #Creates grid determined by DIV numbers in constants.py started = False grid = np.zeros((c.X_DIV +1, c.Y_DIV +1, 3))#len(dummyVehicle.GridInfo)) # is number of elems in trajectory info for vid in frame: vehicleData = frame[vid] veh = v.vehicle(vehicleData, compressed) if not started: grid = np.zeros((c.X_DIV +1, c.Y_DIV +1 , len(veh.GridInfo))) started = True if not InGridBounds(veh.getX(), veh.getY()): continue # Scales the grid into the desired window - check constants.py # to edit MIN/MAX_GRID values. gridX, gridY = GetGridIndices(veh.getX(), veh.getY()) grid[gridX][gridY] += veh.getGridInfo() if mean_centered == 1: MeanCenterGrid(grid) return grid
def goalCalcs(self, frame, vid, goal_to_cords): veh = v.vehicle(frame[vid], self.compressed) dest = veh.getDest() x = veh.getX() y = veh.getY() destLane = veh.getLane() if (dest, destLane) in goal_to_cords.keys(): val = goal_to_cords[(dest, destLane)] prev_n = val[1] prev_avgX = val[0][0] prev_avgY = val[0][1] else: prev_n, prev_avgX, prev_avgY = [0] * 3 new_avgX = float("{0:.2f}".format( float(((prev_avgX * prev_n) + x) / (prev_n + 1)))) new_avgY = float("{0:.2f}".format( float(((prev_avgY * prev_n) + y) / (prev_n + 1)))) newGoal = (new_avgX, new_avgY), prev_n + 1 return dest, destLane, newGoal
def FrameToGrid(frame, mean_centered, compressed=False): #Creates grid determined by DIV numbers in constants.py started = False grid = np.zeros((c.X_DIV +1, c.Y_DIV +1, 3))#len(dummyVehicle.GridInfo)) # is number of elems in trajectory info for vid in frame: vehicleData = frame[vid] veh = v.vehicle(vehicleData, compressed) if not started: grid = np.zeros((c.X_DIV +1, c.Y_DIV +1 , len(veh.GridInfo))) started = True if not InGridBounds(veh.getX(), veh.getY()): continue # Scales the grid into the desired window - check constants.py # to edit MIN/MAX_GRID values. gridX, gridY = GetGridIndices(veh.getX(), veh.getY()) grid[gridX][gridY] += veh.getGridInfo() if mean_centered == 1: MeanCenterGrid(grid) return grid
def getFeatureVectors_intersection(self, fids, intersectionID, laneType=False, useHistory=False, historyFrames=[], useTraffic=False, bool_peach=False): featVecs = np.ascontiguousarray([]) numinstances = len(fids) numDone = 0 maxfid = max(fids) n = numinstances for fid in fids: frame = self.frameDict[fid] numDone = numDone + 1 if numDone % int(numinstances / 10) == 0: print("Done making features for", numDone, "/", numinstances, "instances...") for vid in sorted(list(frame.keys())): veh = v.vehicle(frame[vid]) nextMove = veh.getNextMove() if nextMove == 0: continue if self.getNextIntersectionAndRecord(veh, fids, maxfid, n) != intersectionID: continue #absolutely the slowest way to do this, but irrelevant in grand scheme fullFeatures = [] if laneType: fullFeatures.extend(veh.getTrainFeatures1(bool_peach)) else: fullFeatures.extend(veh.getTrainFeatures2()) if useHistory: fullFeatures.extend( self.getHistory([], fid, vid, historyFrames)) if useTraffic: fullFeatures.extend(self.getTrafficFeatures(fid, vid)) fullFeatures.append(nextMove) if featVecs.size == 0: featVecs = np.ascontiguousarray(fullFeatures) else: featVecs = np.vstack((featVecs, fullFeatures)) return np.ascontiguousarray(featVecs)
def compress(aug_filepath): filename = os.path.basename(aug_filepath) trajectoryFile = open(aug_filepath, 'r') outpath = aug_filepath[:-len(filename)]+'compr_'+filename outFile = open(outpath, 'w') lines = trajectoryFile.readlines() numLines = len(lines) lineCounter = 0 for line in lines: if lineCounter % 30000 == 0: print("Read line ", lineCounter, "/", numLines) augArray = line.split() veh = v.vehicle(augArray, False) compAugArr = veh.returnCompressedArray() writeArray = [str(item) for item in compAugArr] writeString = ' '.join(writeArray) + "\n" outFile.write(writeString) lineCounter += 1 trajectoryFile.close() outFile.close() return
def makeFrameDict(self, filepath): trajectoryFile = open(filepath, 'r') lines = trajectoryFile.readlines() numLines = len(lines) lineCounter = 0 frameDict = {} for line in lines: if lineCounter % 30000 == 0: print("Processed line for dict: ", lineCounter, "/", numLines) array = line.split() veh = v.vehicle(array) fid = veh.getFrame() if fid in frameDict.keys(): #frameDict[fid] is a dict of vid:vehicledata frameDict[fid][veh.getVID()] = array else: frameDict[fid] = {veh.getVID(): array} if fid > self.maxFid: self.maxFid = fid lineCounter += 1 return frameDict