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

comparison python/moving.py @ 378:3805b9639647

added tests for movement orientation, object size

author	Nicolas Saunier <nicolas.saunier@polymtl.ca>
date	Thu, 18 Jul 2013 21:55:17 -0400
parents	2aed569f39e7
children	f1a1923ddff9

comparison

equal deleted inserted replaced

-:2aed569f39e7
+:3805b9639647
 def cross(p1, p2):
 'Cross product'
 return p1.x*p2.y-p1.y*p2.x
 @staticmethod
+def cosine(p1, p2):
+return Point.dot(p1,p2)/(p1.norm2()*p2.norm2())
+@staticmethod
 def distanceNorm2(p1, p2):
 return (p1-p2).norm2()
 @staticmethod
 def plotAll(points, **kwargs):
 from matplotlib.pyplot import scatter
 scatter([p.x for p in points],[p.y for p in points], **kwargs)
+def similarOrientation(self, refDirection, cosineThreshold):
+'Indicates whether the cosine of the vector and refDirection is smaller than cosineThreshold'
+return Point.cosine(self, refDirection) >= cosineThreshold
 if shapelyAvailable:
 def pointsInPolygon(points, polygon):
 '''Optimized tests of a series of points within (Shapely) polygon '''
 prepared_polygon = prep(polygon)
 'Returns the sum of the distances between each successive point'
 displacement = 0
 for i in xrange(self.length()-1):
 displacement += Point.distanceNorm2(self.__getitem__(i),self.__getitem__(i+1))
 return displacement
+def similarOrientation(self, refDirection, cosineThreshold):
+'''Indicates whether the majority of the trajectory elements (vectors for velocity)
+have a cosine with refDirection is smaller than cosineThreshold'''
+count = 0
+halfLength = float(self.length())/2
+for p in self:
+if p.similarOrientation(refDirection, cosineThreshold):
+count += 1
+if count > halfLength:
+return True
+return False
 def wiggliness(self):
 return self.cumulatedDisplacement()/float(Point.distanceNorm2(self.__getitem__(0),self.__getitem__(self.length()-1)))
 def getIntersections(self, p1, p2):
 self.positions.drawOnWorldImage(nPixelsPerUnitDistance, imageHeight, options, withOrigin, timeStep, **kwargs)
 def play(self, videoFilename, homography = None):
 cvutils.displayTrajectories(videoFilename, [self], homography, self.getFirstInstant(), self.getLastInstant())
-def speedDiagnostics(self, display = False):
+def speedDiagnostics(self, framerate = 1., display = False):
 from numpy import std
-speeds = self.getSpeeds()
+from scipy.stats import scoreatpercentile
+speeds = framerate*self.getSpeeds()
 coef = utils.linearRegression(range(len(speeds)), speeds)
-print(speeds[-2]-speeds[1], std(speeds), coef[0])
+print(min(speeds), scoreatpercentile(speeds, 5), speeds[-2]-speeds[1], std(speeds), coef[0])
 if display:
 from matplotlib.pyplot import figure, plot
 figure(1)
 self.draw()
 figure(2)
 plot(list(self.getTimeInterval()), speeds)
+@staticmethod
+def distances(obj1, obj2, instant):
+from scipy.spatial.distance import cdist
+positions1 = [f.getPositionAtInstant(instant).astuple() for f in obj1.features if f.existsAtInstant(instant)]
+positions2 = [f.getPositionAtInstant(instant).astuple() for f in obj2.features if f.existsAtInstant(instant)]
+return cdist(positions1, positions2, metric = 'euclidean')
+@staticmethod
+def minDistance(obj1, obj2, instant):
+return MovingObject.distances(obj1, obj2, instant).min()
+@staticmethod
+def maxDistance(obj1, obj2, instant):
+return MovingObject.distances(obj1, obj2, instant).max()
+def maxSize(self):
+'''Returns the max distance between features
+at instant there are the most features'''
+if hasattr(self, 'features'):
+nFeatures = -1
+tMaxFeatures = 0
+for t in self.getTimeInterval():
+n = len([f for f in self.features if f.existsAtInstant(t)])
+if n > nFeatures:
+nFeatures = n
+tMaxFeatures = t
+return MovingObject.maxDistance(self, self, tMaxFeatures)
+else:
+print('Load features to compute a maximum size')
+return None
 def getInstantsCrossingLane(self, p1, p2):
 '''Returns the instant(s)
 at which the object passes from one side of the segment to the other
 empty list if there is no crossing'''
 indices = self.positions.getIntersections(p1, p2)
 return Point.dot(deltap, deltav)
 @staticmethod
 def collisionCourseCosine(movingObject1, movingObject2, instant):
 'A positive result indicates that the road users are getting closer'
-deltap = movingObject1.getPositionAtInstant(instant)-movingObject2.getPositionAtInstant(instant)
+return Point.cosine(movingObject1.getPositionAtInstant(instant)-movingObject2.getPositionAtInstant(instant), #deltap
-deltav = movingObject2.getVelocityAtInstant(instant)-movingObject1.getVelocityAtInstant(instant)
+movingObject2.getVelocityAtInstant(instant)-movingObject1.getVelocityAtInstant(instant)) #deltav
-return Point.dot(deltap, deltav)/(deltap.norm2()*deltav.norm2())
 def plotRoadUsers(objects, colors):
 '''Colors is a PlottingPropertyValues instance'''
 from matplotlib.pyplot import figure, axis
 figure()

Mercurial > hg > nsaunier > traffic-intelligence

comparison python/moving.py @ 378:3805b9639647