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

comparison python/moving.py @ 672:5473b7460375

moved and rationalized imports in modules

author	Nicolas Saunier <nicolas.saunier@polymtl.ca>
date	Tue, 26 May 2015 13:53:40 +0200
parents	93633ce122c3
children	01b89182891a

comparison

equal deleted inserted replaced

-:849f5f8bf4b9
+:5473b7460375
 '''Libraries for moving objects, trajectories...'''
 import utils, cvutils
 from base import VideoFilenameAddable
-from math import sqrt
+from math import sqrt, atan2, cos, sin
-from numpy import median
+from numpy import median, array, zeros, hypot, NaN, std
+from matplotlib.pyplot import plot
+from scipy.stats import scoreatpercentile
+from scipy.spatial.distance import cdist
 try:
 from shapely.geometry import Polygon, Point as shapelyPoint
 from shapely.prepared import prep
 shapelyAvailable = True
 def divide(self, alpha):
 'Warning, returns a new Point'
 return Point(self.x/alpha, self.y/alpha)
 def plot(self, options = 'o', **kwargs):
-from matplotlib.pylab import plot
 plot([self.x], [self.y], options, **kwargs)
 def norm2Squared(self):
 '''2-norm distance (Euclidean distance)'''
 return self.x**2+self.y**2
 if shapelyAvailable:
 def asShapely(self):
 return shapelyPoint(self.x, self.y)
 def project(self, homography):
-from numpy.core.multiarray import array
 projected = cvutils.projectArray(homography, array([[self.x], [self.y]]))
 return Point(projected[0], projected[1])
 def inPolygon(self, polygon):
 '''Indicates if the point x, y is inside the polygon
 def timeToCollision(p1, p2, v1, v2, collisionThreshold):
 '''Computes exact time to collision with a distance threshold
 The unknown of the equation is the time to reach the intersection
 between the relative trajectory of one road user
 and the circle of radius collisionThreshold around the other road user'''
-from math import sqrt
 dv = v1-v2
 dp = p1-p2
 a = dv.norm2Squared()#(v1.x-v2.x)**2 + (v1.y-v2.y)**2
 b = 2*Point.dot(dv, dp)#2 * ((p1.x-p2.x) * (v1.x-v2.x) + (p1.y-p2.y) * (v1.y-v2.y))
 c = dp.norm2Squared() - collisionThreshold**2#(p1.x-p2.x)**2 + (p1.y-p2.y)**2 - collisionThreshold**2
 where:
 mode=0: incremental distance
 mode=1: cumulative distance
 mode=2: cumulative distance with trailing distance
 '''
-from numpy import zeros
 ss_spline_d = []
 #Prepare subsegment distances
 for spline in range(len(splines)):
 ss_spline_d.append([[],[],[]])
 ss_spline_d[spline][0] = zeros(len(splines[spline])-1)  #Incremental distance
 self.norm = norm
 self.angle = angle
 @staticmethod
 def fromPoint(p):
-from math import atan2
 norm = p.norm2()
 if norm > 0:
 angle = atan2(p.y, p.x)
 else:
 angle = 0.
 def __add__(self, other):
 'a norm cannot become negative'
 return NormAngle(max(self.norm+other.norm, 0), self.angle+other.angle)
 def getPoint(self):
-from math import cos, sin
 return Point(self.norm*cos(self.angle), self.norm*sin(self.angle))
 def predictPositionNoLimit(nTimeSteps, initialPosition, initialVelocity, initialAcceleration = Point(0,0)):
 '''Predicts the position in nTimeSteps at constant speed/acceleration'''
 def multiply(self, alpha):
 return FlowVector(self.position.multiply(alpha), self.velocity.multiply(alpha))
 def plot(self, options = '', **kwargs):
-from matplotlib.pylab import plot
 plot([self.position.x, self.position.x+self.velocity.x], [self.position.y, self.position.y+self.velocity.y], options, **kwargs)
 self.position.plot(options+'x', **kwargs)
 @staticmethod
 def similar(f1, f2, maxDistance2, maxDeltavelocity2):
 self.positions[0].append(self.positions[0][-1])
 self.positions[1].append(self.positions[1][-1])
 @staticmethod
 def _plot(positions, options = '', withOrigin = False, lastCoordinate = None, timeStep = 1, **kwargs):
-from matplotlib.pylab import plot
 if lastCoordinate is None:
 plot(positions[0][::timeStep], positions[1][::timeStep], options, **kwargs)
 elif 0 <= lastCoordinate <= len(positions[0]):
 plot(positions[0][:lastCoordinate:timeStep], positions[1][:lastCoordinate:timeStep], options, **kwargs)
 if withOrigin:
 def getYCoordinates(self):
 return self.positions[1]
 def asArray(self):
-from numpy.core.multiarray import array
 return array(self.positions)
 def xBounds(self):
 # look for function that does min and max in one pass
 return Interval(min(self.getXCoordinates()), max(self.getXCoordinates()))
 def norm(self):
 '''Returns the list of the norms at each instant'''
 #        def add(x, y): return x+y
 #        sq = map(add, [x*x for x in self.positions[0]], [y*y for y in self.positions[1]])
 #        return sqrt(sq)
-from numpy import hypot
 return hypot(self.positions[0], self.positions[1])
 # def cumulatedDisplacement(self):
 #     'Returns the sum of the distances between each successive point'
 #     displacement = 0
 else:
 return None
 def plotCurvilinearPositions(self, lane = None, options = '', withOrigin = False, **kwargs):
 if hasattr(self, 'curvilinearPositions'):
-from matplotlib.pylab import plot
-from numpy import NaN
 if lane is None:
 plot(list(self.getTimeInterval()), self.curvilinearPositions.positions[0], options, **kwargs)
 if withOrigin:
 plot([self.getFirstInstant()], [self.curvilinearPositions.positions[0][0]], 'ro', **kwargs)
 else:
 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):
-from numpy import std
-from scipy.stats import scoreatpercentile
 speeds = framerate*self.getSpeeds()
 coef = utils.linearRegression(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, plot, axis
+from matplotlib.pyplot import figure, axis
 figure(1)
 self.plot()
 axis('equal')
 figure(2)
 plot(list(self.getTimeInterval()), speeds)
 @staticmethod
 def distances(obj1, obj2, instant1, _instant2 = None):
 '''Returns the distances between all features of the 2 objects
 at the same instant instant1
 or at instant1 and instant2'''
-from scipy.spatial.distance import cdist
 if _instant2 is None:
 instant2 = instant1
 else:
 instant2 = _instant2
 positions1 = [f.getPositionAtInstant(instant1).astuple() for f in obj1.features if f.existsAtInstant(instant1)]
 Returns the smallest time difference when the object positions are within collisionDistanceThreshold'''
 #for i in xrange(int(obj1.length())-1):
 #    for j in xrange(int(obj2.length())-1):
 #        inter = segmentIntersection(obj1.getPositionAt(i), obj1.getPositionAt(i+1), obj2.getPositionAt(i), obj2.getPositionAt(i+1))
-from scipy.spatial.distance import cdist
-from numpy import zeros
 positions1 = [p.astuple() for p in obj1.getPositions()]
 positions2 = [p.astuple() for p in obj2.getPositions()]
 pets = zeros((int(obj1.length()), int(obj2.length())))
 for i,t1 in enumerate(obj1.getTimeInterval()):
 for j,t2 in enumerate(obj2.getTimeInterval()):
 '''Computes the trajectory as the mean of all features
 if a feature exists, its position is
 Warning work in progress
 TODO? not use the first/last 1-.. positions'''
-from numpy import array, median
 nFeatures = len(self.features)
 if nFeatures == 0:
 print('Empty object features\nCannot compute smooth trajectory')
 else:
 # compute the relative position vectors
 self.userTypes = {}
 def classifyUserTypeHoGSVMAtInstant(self, img, pedBikeCarSVM, instant, homography, width, height, bikeCarSVM = None, pedBikeSpeedTreshold = float('Inf'), bikeCarSpeedThreshold = float('Inf'), px = 0.2, py = 0.2, pixelThreshold = 800):
 '''Extract the image box around the object and
 applies the SVM model on it'''
-from numpy import array
 croppedImg, yCropMin, yCropMax, xCropMin, xCropMax = imageBox(img, self, instant, homography, width, height, px, py, pixelThreshold)
 if len(croppedImg) > 0: # != []
 hog = array([cvutils.HOG(croppedImg)], dtype = np.float32)
 if self.aggregatedSpeed < pedBikeSpeedTreshold or bikeCarSVM is None:
 self.userTypes[instant] = int(pedBikeCarSVM.predict(hog))

Mercurial Hosting > traffic-intelligence

comparison python/moving.py @ 672:5473b7460375