--- a/python/prediction.py	Fri Jul 21 12:11:55 2017 -0400
+++ b/python/prediction.py	Fri Jul 21 17:52:56 2017 -0400
@@ -7,7 +7,7 @@
 import math, random
 from copy import copy
 import numpy as np
-from multiprocessing import Pool
+#from multiprocessing import Pool
 
 
 class PredictedTrajectory(object):
@@ -64,7 +64,7 @@
     (applying a constant ratio equal 
     to the ratio of the user instantaneous speed and the trajectory closest speed)'''
 
-    def __init__(self, initialPosition, initialVelocity, prototype, constantSpeed = False, probability = 1.):
+    def __init__(self, initialPosition, initialVelocity, prototype, constantSpeed = False, nFramesIgnore = 3, probability = 1.):
         ''' prototype is a MovingObject
 
         Prediction at constant speed will not work for unrealistic trajectories 
@@ -72,6 +72,7 @@
         but is good for realistic motion (eg features)'''
         self.prototype = prototype
         self.constantSpeed = constantSpeed
+        self.nFramesIgnore = nFramesIgnore
         self.probability = probability
         self.predictedPositions = {0: initialPosition}
         self.closestPointIdx = prototype.getPositions().getClosestPoint(initialPosition)
@@ -92,10 +93,10 @@
                 while i < trajLength and traj.getCumulativeDistance(i) < traveledDistance:
                     i += 1
                 if i == trajLength:
-                    v = self.prototype.getVelocityAt(-1)
+                    v = self.prototype.getVelocityAt(-1-self.nFramesIgnore)
                     self.predictedPositions[nTimeSteps] = deltaPosition.rotate(v.angle()-self.theta)+traj[i-1]+v*((traveledDistance-traj.getCumulativeDistance(i-1))/v.norm2())
                 else:
-                    v = self.prototype.getVelocityAt(i-1)
+                    v = self.prototype.getVelocityAt(min(i-1, int(self.prototype.length())-1-self.nFramesIgnore))
                     self.predictedPositions[nTimeSteps] = deltaPosition.rotate(v.angle()-self.theta)+traj[i-1]+(traj[i]-traj[i-1])*((traveledDistance-traj.getCumulativeDistance(i-1))/traj.getDistance(i-1))
             else:
                 traj = self.prototype.getPositions()
@@ -103,10 +104,10 @@
                 nSteps = self.ratio*nTimeSteps+self.closestPointIdx
                 i = int(np.floor(nSteps))
                 if nSteps < trajLength-1:
-                    v = self.prototype.getVelocityAt(i)
+                    v = self.prototype.getVelocityAt(min(i, int(self.prototype.length())-1-self.nFramesIgnore))
                     self.predictedPositions[nTimeSteps] = deltaPosition.rotate(v.angle()-self.theta)+traj[i]+(traj[i+1]-traj[i])*(nSteps-i)
                 else:
-                    v = self.prototype.getVelocityAt(-1)
+                    v = self.prototype.getVelocityAt(-1-self.nFramesIgnore)
                     self.predictedPositions[nTimeSteps] = deltaPosition.rotate(v.angle()-self.theta)+traj[-1]+v*(nSteps-trajLength+1)
         return self.predictedPositions[nTimeSteps]
 
@@ -306,7 +307,7 @@
     def generatePredictedTrajectories(self, obj, instant):
         return []
 
-    def computeCrossingsCollisions(self, obj1, obj2, collisionDistanceThreshold, timeHorizon, computeCZ = False, debug = False, timeInterval = None, nProcesses = 1):
+    def computeCrossingsCollisions(self, obj1, obj2, collisionDistanceThreshold, timeHorizon, computeCZ = False, debug = False, timeInterval = None):#, nProcesses = 1):
         '''Computes all crossing and collision points at each common instant for two road users. '''
         collisionPoints={}
         crossingZones={}
@@ -314,23 +315,23 @@
             commonTimeInterval = timeInterval
         else:
             commonTimeInterval = obj1.commonTimeInterval(obj2)
-        if nProcesses == 1:
-            for i in list(commonTimeInterval)[:-1]: # do not look at the 1 last position/velocities, often with errors
-                i, cp, cz = computeCrossingsCollisionsAtInstant(self, i, obj1, obj2, collisionDistanceThreshold, timeHorizon, computeCZ, debug)
-                if len(cp) != 0:
-                    collisionPoints[i] = cp
-                if len(cz) != 0:
-                    crossingZones[i] = cz
-        else:
-            pool = Pool(processes = nProcesses)
-            jobs = [pool.apply_async(computeCrossingsCollisionsAtInstant, args = (self, i, obj1, obj2, collisionDistanceThreshold, timeHorizon, computeCZ, debug)) for i in list(commonTimeInterval)[:-1]]
-            for j in jobs:
-                i, cp, cz = j.get()
-                if len(cp) != 0:
-                    collisionPoints[i] = cp
-                if len(cz) != 0:
-                    crossingZones[i] = cz
-            pool.close()
+        #if nProcesses == 1:
+        for i in list(commonTimeInterval)[:-1]: # do not look at the 1 last position/velocities, often with errors
+            i, cp, cz = computeCrossingsCollisionsAtInstant(self, i, obj1, obj2, collisionDistanceThreshold, timeHorizon, computeCZ, debug)
+            if len(cp) != 0:
+                collisionPoints[i] = cp
+            if len(cz) != 0:
+                crossingZones[i] = cz
+        # else:
+        #     pool = Pool(processes = nProcesses)
+        #     jobs = [pool.apply_async(computeCrossingsCollisionsAtInstant, args = (self, i, obj1, obj2, collisionDistanceThreshold, timeHorizon, computeCZ, debug)) for i in list(commonTimeInterval)[:-1]]
+        #     for j in jobs:
+        #         i, cp, cz = j.get()
+        #         if len(cp) != 0:
+        #             collisionPoints[i] = cp
+        #         if len(cz) != 0:
+        #             crossingZones[i] = cz
+        #     pool.close()
         return collisionPoints, crossingZones
 
     def computeCollisionProbability(self, obj1, obj2, collisionDistanceThreshold, timeHorizon, debug = False, timeInterval = None):
@@ -558,18 +559,16 @@
         self.constantSpeed = constantSpeed
         self.useFeatures = useFeatures
 
+    def getLcss(self):
+        return self.lcss
+        
     def addPredictedTrajectories(self, predictedTrajectories, obj, instant):
-        if not hasattr(obj, 'prototypeSimilarities'):
-            obj.prototypeSimilarities = []
-            for proto in self.prototypes:
-                self.lcss.similarities(proto.getMovingObject().getPositions().asArray().T, obj.getPositions().asArray().T)
-                similarities = self.lcss.similarityTable[-1, :-1].astype(float)
-                obj.prototypeSimilarities.append(similarities/np.minimum(np.arange(1.,len(similarities)+1), proto.getMovingObject().length()*np.ones(len(similarities))))
+        obj.computeTrajectorySimilarities(self.prototypes, self.lcss)
         for proto, similarities in zip(self.prototypes, obj.prototypeSimilarities):
             if similarities[instant-obj.getFirstInstant()] >= self.minSimilarity:
                 initialPosition = obj.getPositionAtInstant(instant)
                 initialVelocity = obj.getVelocityAtInstant(instant)
-                predictedTrajectories.append(PredictedTrajectoryPrototype(initialPosition, initialVelocity, proto.getMovingObject(), constantSpeed = self.constantSpeed, probability = proto.getNMatchings())) 
+                predictedTrajectories.append(PredictedTrajectoryPrototype(initialPosition, initialVelocity, proto.getMovingObject(), constantSpeed = self.constantSpeed, probability = proto.getNMatchings()))
         
     def generatePredictedTrajectories(self, obj, instant):
         predictedTrajectories = []