Ejemplo n.º 1
0
def buildFeature(obj, featureID, num=1):
    featureList = getFeatures(obj, featureID)
    tmp = {}
    delta = {}
    for i in featureList:
        for t in xrange(i[1], i[2] + 1):
            tmp[t] = [i[0], i[3]]
    newTraj = moving.Trajectory()

    for instant in obj.getTimeInterval():
        newTraj.addPosition(
            tmp[instant][0].getPositionAtInstant(instant) + tmp[instant][1])
    newFeature = moving.MovingObject(
        num, timeInterval=obj.getTimeInterval(), positions=newTraj)
    return newFeature
Ejemplo n.º 2
0
def smoothObject(obj,
                 newNum,
                 minLengthParam=0.7,
                 smoothing=False,
                 plotResults=True,
                 halfWidth=3,
                 _computeVelocities=True,
                 optimize=True,
                 create=False):
    '''Computes a smoother trajectory for the object
    and optionnally smoother velocities
    
    The object should have its features in obj.features
    TODO: check whether features are necessary'''
    if not obj.hasFeatures():
        print(
            'Object {} has an empty list of features: please load and add them using obj.setFeatures(features)'
            .format(obj.getNum()))
        from sys import exit
        exit()

    featureList = [
        i for i, f in enumerate(obj.getFeatures())
        if f.length() >= minLengthParam * obj.length()
    ]
    if featureList == []:
        featureList.append(
            utils.argmaxDict(
                {i: f.length()
                 for i, f in enumerate(obj.getFeatures())}))
        create = True
    newObjects = []
    for featureID in featureList:  # featureID should be the index in the list of obj.features
        newObjects.append(
            smoothObjectTrajectory(obj,
                                   featureID,
                                   newNum,
                                   smoothing=smoothing,
                                   halfWidth=halfWidth,
                                   create=create))

    newTranslated = moving.Trajectory()
    newInterval = []
    for t in obj.getTimeInterval():
        xCoord = []
        yCoord = []
        for i in newObjects:
            if i.existsAtInstant(t):
                p1 = i.getPositionAtInstant(t)
                xCoord.append(p1.x)
                yCoord.append(p1.y)
        if xCoord != []:
            tmp = moving.Point(median(xCoord), median(yCoord))
            newInterval.append(t)
            newTranslated.addPosition(tmp)

    newObj = moving.MovingObject(newNum,
                                 timeInterval=moving.TimeInterval(
                                     min(newInterval), max(newInterval)),
                                 positions=newTranslated)

    if _computeVelocities:
        tmpTraj = moving.Trajectory()
        velocities = computeVelocities(newObj, True, 5)
        for i in sorted(velocities.keys()):
            tmpTraj.addPosition(velocities[i])
        newObj.velocities = tmpTraj
    else:
        newObj.velocities = obj.velocities

    if optimize:
        csj1 = sumSquaredJerk(obj, fromPosition=True)
        csj2 = sumSquaredJerk(newObj, fromPosition=True)
        if csj1 < csj2:
            newObj = obj
            newObj.velocities = obj.velocities
        if _computeVelocities and csj1 >= csj2:
            csj3 = sumSquaredJerk(obj, fromPosition=False)
            csj4 = sumSquaredJerk(newObj, fromPosition=False)
            if csj4 <= csj3:
                newObj.velocities = obj.velocities

    newObj.featureNumbers = obj.featureNumbers
    newObj.features = obj.getFeatures()
    newObj.userType = obj.userType

    if plotResults:
        plt.figure()
        plt.title('objects_id = {}'.format(obj.num))
        for i in featureList:
            obj.getFeature(i).plot('cx-')
        obj.plot('rx-')
        newObj.plot('gx-')
    return newObj
Ejemplo n.º 3
0
def smoothObjectTrajectory(obj,
                           featureID,
                           newNum,
                           smoothing=False,
                           halfWidth=3,
                           create=False):
    results = []
    bearing = {}
    if create:
        feature = buildFeature(obj, featureID, num=1)  # why num=1
    else:
        feature = obj.getFeature(featureID)
    for t in feature.getTimeInterval():
        p1 = feature.getPositionAtInstant(t)
        p2 = obj.getPositionAtInstant(t)
        if t != feature.getLastInstant():
            p3 = feature.getPositionAtInstant(t + 1)
        else:
            p1 = feature.getPositionAtInstant(t - 1)
            p3 = feature.getPositionAtInstant(t)
        bearing[t] = getBearing(p1, p2, p3)[1]
        results.append(getBearing(p1, p2, p3))

    medianResults = median(results, 0)
    dist = medianResults[0]
    angle = medianResults[3]

    for i in sorted(bearing.keys()):
        bearing[i] = bearing[i] + angle

    if smoothing:
        bearingInput = []
        for i in sorted(bearing.keys()):
            bearingInput.append(bearing[i])
        import utils
        bearingOut = utils.filterMovingWindow(bearingInput, halfWidth)
        for t, i in enumerate(sorted(bearing.keys())):
            bearing[i] = bearingOut[t]

        #solve a smoothing problem in case of big drop in computing bearing (0,360)
        for t, i in enumerate(sorted(bearing.keys())):
            if i != max(bearing.keys()) and abs(bearingInput[t] -
                                                bearingInput[t + 1]) >= 340:
                for x in xrange(max(i - halfWidth, min(bearing.keys())),
                                min(i + halfWidth, max(bearing.keys())) + 1):
                    bearing[x] = bearingInput[t - i + x]

    translated = moving.Trajectory()
    for t in feature.getTimeInterval():
        p1 = feature.getPositionAtInstant(t)
        p1.x = p1.x + dist * sin(bearing[t] * pi / 180)
        p1.y = p1.y + dist * cos(bearing[t] * pi / 180)
        translated.addPosition(p1)

    #modify first and last un-smoothed positions (half width)
    if smoothing:
        d1 = translated[halfWidth] - feature.positions[halfWidth]
        d2 = translated[-halfWidth - 1] - feature.positions[-halfWidth - 1]
        for i in xrange(halfWidth):
            p1 = feature.getPositionAt(i) + d1
            p2 = feature.getPositionAt(-i - 1) + d2
            translated.setPosition(i, p1)
            translated.setPosition(-i - 1, p2)

    newObj = moving.MovingObject(newNum,
                                 timeInterval=feature.getTimeInterval(),
                                 positions=translated)
    return newObj