repo/traffic-intelligence: python/moving.py comparison

comparison python/moving.py @ 998:933670761a57

updated code to python 3 (tests pass and scripts run, but non-executed parts of code are probably still not correct)

author	Nicolas Saunier <nicolas.saunier@polymtl.ca>
date	Sun, 27 May 2018 23:22:48 -0400
parents	4f3387a242a1
children	cc7c6b821ae6

comparison

equal deleted inserted replaced

-:4f3387a242a1
+:933670761a57
 def __iter__(self):
 self.iterInstantNum = -1
 return self
-def next(self):
+def __next__(self):
 if self.iterInstantNum >= self.length()-1:
 raise StopIteration
 else:
 self.iterInstantNum += 1
 return self[self.iterInstantNum]
 '''Optimized tests of a series of points within (Shapely) polygon (not prepared)'''
 if type(polygon) == PreparedGeometry:
 prepared_polygon = polygon
 else:
 prepared_polygon = prep(polygon)
-return filter(prepared_polygon.contains, points)
+return list(filter(prepared_polygon.contains, points))
 # Functions for coordinate transformation
 # From Paul St-Aubin's PVA tools
 def subsec_spline_dist(splines):
 ''' Prepare list of spline subsegments from a spline list.
 def prepareSplines(splines):
 'Approximates slope singularity by giving some slope roundoff; account for roundoff error'
 for spline in splines:
 p1 = spline[0]
-for i in xrange(len(spline)-1):
+for i in range(len(spline)-1):
 p2 = spline[i+1]
 if(round(p1.x, 10) == round(p2.x, 10)):
 p2.x += 0.0000000001
 if(round(p1.y, 10) == round(p2.y, 10)):
 p2.y += 0.0000000001
 @staticmethod
 def generate(p, v, nPoints):
 t = Trajectory()
 p0 = Point(p.x, p.y)
 t.addPosition(p0)
-for i in xrange(nPoints-1):
+for i in range(nPoints-1):
 p0 += v
 t.addPosition(p0)
 return t, Trajectory([[v.x]*nPoints, [v.y]*nPoints])
 @staticmethod
 return Trajectory([self.positions[0][i],self.positions[1][i]])
 else:
 raise TypeError("Invalid argument type.")
 def __str__(self):
-return ' '.join([self.__getitem__(i).__str__() for i in xrange(self.length())])
+return ' '.join([self.__getitem__(i).__str__() for i in range(self.length())])
 def __repr__(self):
 return self.__str__()
 def __iter__(self):
 self.iterInstantNum = 0
 return self
-def next(self):
+def __next__(self):
 if self.iterInstantNum >= self.length():
 raise StopIteration
 else:
 self.iterInstantNum += 1
 return self[self.iterInstantNum-1]
 return Trajectory([[alpha*x for x in self.getXCoordinates()],
 [alpha*y for y in self.getYCoordinates()]])
 def differentiate(self, doubleLastPosition = False):
 diff = Trajectory()
-for i in xrange(1, self.length()):
+for i in range(1, self.length()):
 diff.addPosition(self[i]-self[i-1])
 if doubleLastPosition:
 diff.addPosition(diff[-1])
 return diff
 Can be accessed through getDistance(idx) and getCumulativeDistance(idx)'''
 self.distances = []
 self.cumulativeDistances = [0.]
 p1 = self[0]
 cumulativeDistance = 0.
-for i in xrange(self.length()-1):
+for i in range(self.length()-1):
 p2 = self[i+1]
 self.distances.append(Point.distanceNorm2(p1,p2))
 cumulativeDistance += self.distances[-1]
 self.cumulativeDistances.append(cumulativeDistance)
 p1 = p2
 intersects with the segment of extremities p1 and p2
 Returns an empty list if there is no crossing'''
 indices = []
 intersections = []
-for i in xrange(self.length()-1):
+for i in range(self.length()-1):
 q1=self.__getitem__(i)
 q2=self.__getitem__(i+1)
 p = segmentIntersection(q1, q2, p1, p2)
 if p is not None:
 if q1.x != q2.x:
 intersects with the line going through p1 and p2
 Returns an empty list if there is no crossing'''
 indices = []
 intersections = []
-for i in xrange(self.length()-1):
+for i in range(self.length()-1):
 q1=self.__getitem__(i)
 q2=self.__getitem__(i+1)
 p = segmentLineIntersection(p1, p2, q1, q2)
 if p is not None:
 if q1.x != q2.x:
 self.lanes[i] = lane
 def differentiate(self, doubleLastPosition = False):
 diff = CurvilinearTrajectory()
 p1 = self[0]
-for i in xrange(1, self.length()):
+for i in range(1, self.length()):
 p2 = self[i]
 diff.addPositionSYL(p2[0]-p1[0], p2[1]-p1[1], p1[2])
 p1=p2
 if doubleLastPosition and self.length() > 1:
 diff.addPosition(diff[-1])
 '''Returns a list of the indices at which the trajectory
 goes past the curvilinear coordinate S1
 (in provided lane if lane is not None)
 Returns an empty list if there is no crossing'''
 indices = []
-for i in xrange(self.length()-1):
+for i in range(self.length()-1):
 q1=self.__getitem__(i)
 q2=self.__getitem__(i+1)
 if q1[0] <= S1 < q2[0] and (lane is None or (self.lanes[i] == lane and self.lanes[i+1] == lane)):
 indices.append(i+(S1-q1[0])/(q2[0]-q1[0]))
 return indices
 coords.append(NaN)
 plot(instants, coords, options, **kwargs)
 if withOrigin and len(instants)>0:
 plot([instants[0]], [coords[0]], 'ro', **kwargs)
 else:
 print('Object {} has no curvilinear positions'.format(self.getNum()))
 def setUserType(self, userType):
 self.userType = userType
 def setFeatures(self, features, featuresOrdered = False):
 def play(self, videoFilename, homography = None, undistort = False, intrinsicCameraMatrix = None, distortionCoefficients = None, undistortedImageMultiplication = 1.):
 cvutils.displayTrajectories(videoFilename, [self], homography = homography, firstFrameNum = self.getFirstInstant(), lastFrameNumArg = self.getLastInstant(), undistort = undistort, intrinsicCameraMatrix = intrinsicCameraMatrix, distortionCoefficients = distortionCoefficients, undistortedImageMultiplication = undistortedImageMultiplication)
 def speedDiagnostics(self, framerate = 1., display = False, nInstantsIgnoredAtEnds=0):
 speeds = framerate*self.getSpeeds(nInstantsIgnoredAtEnds)
-coef = utils.linearRegression(range(len(speeds)), speeds)
+coef = utils.linearRegression(list(range(len(speeds))), speeds)
 print('min/5th perc speed: {} / {}\nspeed diff: {}\nspeed stdev: {}\nregression: {}'.format(min(speeds), scoreatpercentile(speeds, 5), speeds[-2]-speeds[1], std(speeds), coef[0]))
 if display:
 from matplotlib.pyplot import figure, axis
 figure(1)
 self.plot()
 '''
 self.curvilinearPositions = CurvilinearTrajectory()
 #For each point
-for i in xrange(int(self.length())):
+for i in range(int(self.length())):
 result = getSYfromXY(self.getPositionAt(i), alignments)
 # Error handling
 if(result is None):
 print('Warning: trajectory {} at point {} {} has alignment errors (spline snapping)\nCurvilinear trajectory could not be computed'.format(self.getNum(), i, self.getPositionAt(i)))
 #Run through objects looking for outlier point
 smoothed_lanes = utils.cat_mvgavg(self.curvilinearPositions.getLanes(),ln_mv_av_win)
 ## Recalculate projected point to new lane
 lanes = self.curvilinearPositions.getLanes()
 if(lanes != smoothed_lanes):
-for i in xrange(len(lanes)):
+for i in range(len(lanes)):
 if(lanes[i] != smoothed_lanes[i]):
 result = getSYfromXY(self.getPositionAt(i),[alignments[smoothed_lanes[i]]])
 # Error handling
 if(result is None):
 if nFeatures == 0:
 print('Empty object features\nCannot compute smooth trajectory')
 else:
 # compute the relative position vectors
 relativePositions = {} # relativePositions[(i,j)] is the position of j relative to i
-for i in xrange(nFeatures):
+for i in range(nFeatures):
-for j in xrange(i):
+for j in range(i):
 fi = self.features[i]
 fj = self.features[j]
 inter = fi.commonTimeInterval(fj)
 if inter.length() >= minCommonIntervalLength:
 xi = array(fi.getXCoordinates()[inter.first-fi.getFirstInstant():int(fi.length())-(fi.getLastInstant()-inter.last)])
 gtMatches = {a.getNum():{} for a in annotations}
 toMatches = {o.getNum():{} for o in objects}
 else:
 gtMatches = None
 toMatches = None
-for t in xrange(firstInstant, lastInstant+1):
+for t in range(firstInstant, lastInstant+1):
 previousMatches = matches.copy()
 # go through currently matched GT-TO and check if they are still matched withing matchingDistance
 toDelete = []
 for a in matches:
 if a.existsAtInstant(t) and matches[a].existsAtInstant(t):
 toDelete.append(a)
 for a in toDelete:
 del matches[a]
 # match all unmatched GT-TO
-matchedGTs = matches.keys()
+matchedGTs = list(matches.keys())
-matchedTOs = matches.values()
+matchedTOs = list(matches.values())
 costs = []
 unmatchedGTs = [a for a in annotations if a.existsAtInstant(t) and a not in matchedGTs]
 unmatchedTOs = [o for o in objects if o.existsAtInstant(t) and o not in matchedTOs]
 nGTs = len(matchedGTs)+len(unmatchedGTs)
 nTOs = len(matchedTOs)+len(unmatchedTOs)
 for k,v in newMatches:
 if costs[k][v] < matchingDistance:
 matches[unmatchedGTs[k]]=unmatchedTOs[v]
 dist += costs[k][v]
 if debug:
-print('{} '.format(t)+', '.join(['{} {}'.format(k.getNum(), v.getNum()) for k,v in matches.iteritems()]))
+print('{} '.format(t)+', '.join(['{} {}'.format(k.getNum(), v.getNum()) for k,v in matches.items()]))
 if returnMatches:
-for a,o in matches.iteritems():
+for a,o in matches.items():
 gtMatches[a.getNum()][t] = o.getNum()
 toMatches[o.getNum()][t] = a.getNum()
 # compute metrics elements
 ct += len(matches)
 mismatches = []
 for a in matches:
 if a in previousMatches:
 if matches[a] != previousMatches[a]:
 mismatches.append(a)
-elif matches[a] in previousMatches.values():
+elif matches[a] in list(previousMatches.values()):
 mismatches.append(matches[a])
 for a in previousMatches:
-if a not in matches and previousMatches[a] in matches.values():
+if a not in matches and previousMatches[a] in list(matches.values()):
 mismatches.append(previousMatches[a])
 if debug:
 for mm in set(mismatches):
 print('{} {}'.format(type(mm), mm.getNum()))
 # some object mismatches may appear twice

Mercurial Hosting > traffic-intelligence

comparison python/moving.py @ 998:933670761a57