Ejemplo n.º 1
0
def calculateIndicatorPipe(pairs, predParam, timeHorizon=75,collisionDistanceThreshold=1.8):  
    collisionPoints, crossingZones = prediction.computeCrossingsCollisions(pairs.roadUser1, pairs.roadUser2, predParam, collisionDistanceThreshold, timeHorizon)      
    #print pairs.num    
    # Ignore empty collision points
    empty = 1
    for i in collisionPoints:
        if(collisionPoints[i] != []):
            empty = 0
    if(empty == 1):
        pairs.hasCP = 0
    else:
        pairs.hasCP = 1
    pairs.CP = collisionPoints
    
    # Ignore empty crossing zones
    empty = 1
    for i in crossingZones:
        if(crossingZones[i] != []):
            empty = 0
    if(empty == 1):
        pairs.hasCZ = 0
    else:
        pairs.hasCZ = 1
    pairs.CZ = crossingZones
    return pairs
Ejemplo n.º 2
0
 def calculateIndicators(self,predParam,threads=1,timeHorizon=75,collisionDistanceThreshold=1.8):       
     if(threads > 1):
         pool = multiprocessing.Pool(threads)
         self.pairs = pool.map(calculateIndicatorPipe_star, itertools.izip(self.pairs, itertools.repeat(predParam)))
         pool.close()
     else:
         #prog = Tools.ProgressBar(0, len(self.pairs), 77) #Removed in traffic-intelligenc port
         for j in xrange(len(self.pairs)):
             #prog.updateAmount(j) #Removed in traffic-intelligenc port
             collisionPoints, crossingZones = prediction.computeCrossingsCollisions(self.pairs[j].roadUser1, self.pairs[j].roadUser2, predParam, collisionDistanceThreshold, timeHorizon)      
             
             # Ignore empty collision points
             empty = 1
             for i in collisionPoints:
                 if(collisionPoints[i] != []):
                     empty = 0
             if(empty == 1):
                 self.pairs[j].hasCP = 0
             else:
                 self.pairs[j].hasCP = 1
             self.pairs[j].CP = collisionPoints
             
             # Ignore empty crossing zones
             empty = 1
             for i in crossingZones:
                 if(crossingZones[i] != []):
                     empty = 0
             if(empty == 1):
                 self.pairs[j].hasCZ = 0
             else:
                 self.pairs[j].hasCZ = 1
             self.pairs[j].CZ = crossingZones       
             
     for j in self.pairs:
         self.interactionCount = self.interactionCount + len(j.CP)
     self.CPcount = len(self.getCPlist())
     self.Czcount = len(self.getCZlist())
    print(videoFilename)
    utils.mkdir(utils.cleanFilename(videoFilename))

    # collision points, crossing zones, TTC and PET computations
    objects = ubc_utils.loadTrajectories(dirname+ videoFilename+'-objects.txt')
    features = ubc_utils.loadTrajectories(dirname+ videoFilename+'-features.txt') # needed only if using the feature positions
    time = strftime('%Y-%m-%d-%H-%M-%S')
    for roadUserNumbers in interactingRoadUsers[videoFilename]:
        objects[roadUserNumbers[0]].setFeatures(features)
        objects[roadUserNumbers[1]].setFeatures(features)

    # choose the motion prediction methods to test: the list is [constantVelocityPredictionParameters, normalAdaptationPredictionParameters, featurePredictionParameters]
    for params in [constantVelocityPredictionParameters]:
        print(params.name)
        outCP = openResultFile(videoFilename, params, time, '-collision-points.csv')
        outCZ = openResultFile(videoFilename, params, time, '-crossing-zones.csv')

        for roadUsers in interactingRoadUsers[videoFilename]:
            collisionPoints, crossingZones = prediction.computeCrossingsCollisions(objects[roadUserNumbers[0]], objects[roadUserNumbers[1]], params, collisionDistanceThreshold, timeHorizon, outCP, outCZ)#, True, moving.TimeInterval(60,63)

        outCP.close()
        outCZ.close()

    # compute probability of unsuccessful evasive action
    # choose the motion prediction methods to test: the list is [evasiveActionPredictionParameters, featureEvasiveActionPredictionParameters]
    for params in []:
        outProba = openResultFile(videoFilename, params, time, '-probability-collision.csv')
        for roadUsers in interactingRoadUsers[videoFilename]:
            collisionProbabilities = prediction.computeCollisionProbability(objects[roadUsers[0]], objects[roadUsers[1]], params, collisionDistanceThreshold, timeHorizon, outProba) # True, moving.TimeInterval(90,93) # for last example
        outProba.close()