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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 makeFrameDict(self, filepath, compressed):
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, compressed)
if not veh.getVID() in self.VIDs:
self.VIDs.append(veh.getVID())
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}
lineCounter += 1
return frameDict
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 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
