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

comparison python/moving.py @ 939:a2f3f3ca241e

work in progress

author	Nicolas Saunier <nicolas.saunier@polymtl.ca>
date	Mon, 17 Jul 2017 17:56:52 -0400
parents	b67a784beb69
children	b1e8453c207c

comparison

equal deleted inserted replaced

-:fbf12382f3f8
+:a2f3f3ca241e
 if clockwise:
 return Point(self.y, -self.x)
 else:
 return Point(-self.y, self.x)
-def multiply(self, alpha):
+def __mul__(self, alpha):
 'Warning, returns a new Point'
 return Point(self.x*alpha, self.y*alpha)
 def divide(self, alpha):
 'Warning, returns a new Point'
 print('qx={0}, qy={1}, p0x={2}, p0y={3}, p1x={4}, p1y={5}...'.format(qx, qy, p0x, p0y, p1x, p1y))
 import pdb; pdb.set_trace()
 return Point(X,Y)
 def getSYfromXY(p, splines, goodEnoughSplineDistance = 0.5):
-''' Snap a point p to it's nearest subsegment of it's nearest spline (from the list splines).
+''' Snap a point p to its nearest subsegment of it's nearest spline (from the list splines).
 A spline is a list of points (class Point), most likely a trajectory.
 Output:
 =======
 [spline index,
 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'''
-return initialVelocity + initialAcceleration.multiply(nTimeSteps),initialPosition+initialVelocity.multiply(nTimeSteps) + initialAcceleration.multiply(nTimeSteps**2*0.5)
+return initialVelocity + initialAcceleration.__mul__(nTimeSteps),initialPosition+initialVelocity.__mul__(nTimeSteps) + initialAcceleration.__mul__(nTimeSteps**2*0.5)
 def predictPosition(position, speedOrientation, control, maxSpeed = None):
 '''Predicts the position (moving.Point) at the next time step with given control input (deltaSpeed, deltaTheta)
 speedOrientation is the other encoding of velocity, (speed, orientation)
 speedOrientation and control are NormAngle'''
 self.velocity = velocity
 def __add__(self, other):
 return FlowVector(self.position+other.position, self.velocity+other.velocity)
-def multiply(self, alpha):
+def __mul__(self, alpha):
-return FlowVector(self.position.multiply(alpha), self.velocity.multiply(alpha))
+return FlowVector(self.position.__mul__(alpha), self.velocity.__mul__(alpha))
 def plot(self, options = '', **kwargs):
 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)
 det = float(dp34.y*dp12.x-dp34.x*dp12.y)
 if det == 0.:
 return None
 else:
 ua = (dp34.x*(p1.y-p3.y)-dp34.y*(p1.x-p3.x))/det
-return p1+dp12.multiply(ua)
+return p1+dp12.__mul__(ua)
 # def intersection(p1, p2, dp1, dp2):
 #     '''Returns the intersection point between the two lines
 #     defined by the respective vectors (dp) and origin points (p)'''
 #     from numpy import matrix
 return None
 else:
 return Trajectory([[a-b for a,b in zip(self.getXCoordinates(),traj2.getXCoordinates())],
 [a-b for a,b in zip(self.getYCoordinates(),traj2.getYCoordinates())]])
-def multiply(self, alpha):
+def __mul__(self, alpha):
 '''Returns a new trajectory of the same length'''
 return Trajectory([[alpha*x for x in self.getXCoordinates()],
 [alpha*y for y in self.getYCoordinates()]])
 def differentiate(self, doubleLastPosition = False):
 i = -1
 for p2 in self:
 distances2.append(Point.distanceNorm2(p1, p2))
 if distances2[-1] < minDist2:
 minDist2 = distances2[-1]
-i = len(distances)-1
+i = len(distances2)-1
-if maxDist2 is None or (maxDist2 is not None and minDist2 < maxDist2):
+if maxDist2 is not None and minDist2 < maxDist2:
+return None
+else:
 return i
-else:
-return None
 def similarOrientation(self, refDirection, cosineThreshold, minProportion = 0.5):
 '''Indicates whether the minProportion (<=1.) (eg half) of the trajectory elements (vectors for velocity)
 have a cosine with refDirection is smaller than cosineThreshold'''
 count = 0
 if obj.existsAtInstant(t):
 if obj.hasFeatures():
 n = len([f for f in obj.getFeatures() if f.existsAtInstant(t)])
 else:
 n = 1.
-p += obj.getPositionAtInstant(t).multiply(n)
+p += obj.getPositionAtInstant(t).__mul__(n)
 nTotal += n
 assert nTotal>0, 'there should be at least one point for each instant'
 positions.addPosition(p.divide(nTotal))
 # velocities: if any
 if hasattr(obj1, 'velocities') and hasattr(obj2, 'velocities'):
 if obj.existsAtInstant(t):
 if obj.hasFeatures():
 n = len([f for f in obj.getFeatures() if f.existsAtInstant(t)])
 else:
 n = 1.
-p += obj.getVelocityAtInstant(t).multiply(n)
+p += obj.getVelocityAtInstant(t).__mul__(n)
 nTotal += n
 assert n>0, 'there should be at least one point for each instant'
 velocities.addPosition(p.divide(nTotal))
 else:
 velocities = None
 super(BBMovingObject, self).__init__(num, timeInterval, userType = userType)
 self.topLeftPositions = topLeftPositions.getPositions()
 self.bottomRightPositions = bottomRightPositions.getPositions()
 def computeCentroidTrajectory(self, homography = None):
-self.positions = self.topLeftPositions.add(self.bottomRightPositions).multiply(0.5)
+self.positions = self.topLeftPositions.add(self.bottomRightPositions).__mul__(0.5)
 if homography is not None:
 self.positions = self.positions.homographyProject(homography)
 def matches(self, obj, instant, matchingDistance):
 '''Indicates if the annotation matches obj (MovingObject)

Mercurial > hg > nsaunier > traffic-intelligence

comparison python/moving.py @ 939:a2f3f3ca241e