def findObject(frameNum, x, y,): import cv2 from numpy import array from numpy.core import dot from numpy.lib.function_base import append from numpy.linalg.linalg import inv from numpy import loadtxt homographyFilename = "laurier-homography.txt" homography = inv(loadtxt(homographyFilename)) databaseFilename = "laurier.sqlite" trajectoryType = "object" cap = cv2.VideoCapture('laurier.avi') width = cap.get(3) height = cap.get(4) cap.release() objects = storage.loadTrajectoriesFromSqlite(databaseFilename, trajectoryType) features = storage.loadTrajectoriesFromSqlite(databaseFilename, "feature") px = 0.2 py = 0.2 pixelThreshold = 800 for obj in objects: if obj.existsAtInstant(frameNum): obj.setFeatures(features) if obj.hasFeatures(): u = [] v = [] for f in obj.getFeatures(): if f.existsAtInstant(frameNum): projectedPosition = f.getPositionAtInstant(frameNum).project(homography) u.append(projectedPosition.x) v.append(projectedPosition.y) xmin = min(u) xmax = max(u) ymin = min(v) ymax = max(v) xMm = px * (xmax - xmin) yMm = py * (ymax - ymin) a = max(ymax - ymin + (2 * yMm), xmax - (xmin + 2 * xMm)) yCropMin = int(max(0, .5 * (ymin + ymax - a))) yCropMax = int(min(height - 1, .5 * (ymin + ymax + a))) xCropMin = int(max(0, .5 * (xmin + xmax - a))) xCropMax = int(min(width - 1, .5 * (xmin + xmax + a))) if yCropMax != yCropMin and xCropMax != xCropMin and (yCropMax - yCropMin) * (xCropMax - xCropMin) > pixelThreshold: if x > xCropMin and x < xCropMax and y > yCropMin and y < yCropMax: print obj.getNum()
def test_ex1(self): import storage objects = storage.loadTrajectoriesFromSqlite('../samples/laurier.sqlite', 'object') speed = objects[0].getVelocityAtInstant(10).norm2() timeInterval = objects[0].getTimeInterval() speeds = [objects[0].getVelocityAtInstant(t).norm2() for t in range(timeInterval.first, timeInterval.last)] speeds = [v.norm2() for v in objects[0].getVelocities()] from matplotlib.pyplot import plot, close, axis plot(range(timeInterval.first, timeInterval.last+1), speeds) close('all') objects[0].plot() axis('equal') features = storage.loadTrajectoriesFromSqlite('../samples/laurier.sqlite', 'feature') objects[0].setFeatures(features) for f in objects[0].features: f.plot() axis('equal')
def extract_trajectories(sqlite_filename): import storage objects = storage.loadTrajectoriesFromSqlite(sqlite_filename,'object') object_positions = [] a = 0 for o in objects: instant = o.timeInterval[0] for p in o.positions: object_positions.append([a,instant,p.x,p.y]) instant += 1 a += 1 return object_positions
def extract_trajectories(sqlite_filename): import storage objects = storage.loadTrajectoriesFromSqlite(sqlite_filename, 'object') object_positions = [] a = 0 for o in objects: instant = o.timeInterval[0] for p in o.positions: object_positions.append([a, instant, p.x, p.y]) instant += 1 a += 1 return object_positions
params.nPredictedTrajectories, accelerationDistribution, steeringDistribution, params.useFeaturesForPrediction) elif predictionMethod == 'ps': predictionParameters = prediction.PointSetPredictionParameters(params.maxPredictedSpeed) # no else required, since parameters is required as argument # evasiveActionPredictionParameters = prediction.EvasiveActionPredictionParameters(params.maxPredictedSpeed, # params.nPredictedTrajectories, # params.minExtremeAcceleration, # params.maxExtremeAcceleration, # params.maxExtremeSteering, # params.useFeaturesForPrediction) objects = storage.loadTrajectoriesFromSqlite(params.databaseFilename,'object') if params.useFeaturesForPrediction: features = storage.loadTrajectoriesFromSqlite(params.databaseFilename,'feature') # needed if normal adaptation for obj in objects: obj.setFeatures(features) interactions = events.createInteractions(objects) for inter in interactions: inter.computeIndicators() inter.computeCrossingsCollisions(predictionParameters, params.collisionDistance, params.predictionTimeHorizon, params.crossingZones, nProcesses = args.nProcesses) storage.saveIndicators(params.databaseFilename, interactions) if args.displayCollisionPoints: plt.figure() allCollisionPoints = []
__author__ = 'Akhil' import cv2 import storage from numpy.linalg.linalg import inv from numpy import loadtxt import cvutils databaseFilename = "laurier.sqlite" objectNumber = [0] trajectoryType = "feature" objects = storage.loadTrajectoriesFromSqlite(databaseFilename, trajectoryType) obj = objects[0] print obj.existsAtInstant(5) homographyFilename = "laurier-homography.txt" homography = inv(loadtxt(homographyFilename)) fNo = 10 p = [150, 80] def projectArray(homography, points): from numpy.core import dot from numpy.lib.function_base import append if points.shape[0] != 2: raise Exception('points of dimension {0} {1}'.format(points.shape[0], points.shape[1])) if (homography is not None) and homography.size>0: augmentedPoints = append(points,[[1]*points.shape[1]], 0) prod = dot(homography, augmentedPoints)
def create_trajectory_video(video_path, db_filename, homography_path, output_path, first_frame=0, last_frame=None, video_type='object', objects_to_label=None, bounding_boxes=False): ''' Creates a video of tracked trajectories. video_path: a path to the video on which to overlay db_filename: path to the database of tracked objects and features homography_path: the path to the homography.txt of the project output_path: The path of the video to be created. Please be sure that the output video format works on your system! (mp4 doesn't work on Windows AFAIK) first_frame: frame to start at last_frame: frame to end at video_type: either 'object' or 'feature' bounding_boxes: boolean indicating whether to show bounding boxes for objects ''' capture = cv2.VideoCapture(video_path) width = int(capture.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)) height = int(capture.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)) capture.set(cv2.cv.CV_CAP_PROP_POS_FRAMES, first_frame) frame_num = first_frame framerate = get_framerate(video_path) print('Loading objects, please wait...') objects = loadTrajectoriesFromSqlite(db_filename, video_type, objectNumbers=objects_to_label, withFeatures=bounding_boxes) homography = inv(loadtxt(homography_path)) ret = True objectToDeleteIds = [] out = get_video_writer(output_path, framerate, width, height) while ret: if last_frame is not None and frame_num > last_frame: break ret, img = capture.read() if ret: if frame_num % 100 == 0: print('frame {0}'.format(frame_num)) if len(objectToDeleteIds) > 0: objects = [ o for o in objects if o.getNum() not in objectToDeleteIds ] objectToDeleteIds = [] # plot objects for obj in objects: if obj.existsAtInstant(frame_num): # Only draw for objects that should be labeled, if passed in if objects_to_label is not None and obj.getNum( ) not in objects_to_label: continue if obj.getLastInstant() == frame_num: objectToDeleteIds.append(obj.getNum()) # Project the positions with homography if not hasattr(obj, 'projectedPositions'): obj.projectedPositions = obj.positions.project( homography) # Plot it's trajectory until now cvPlot(img, obj.projectedPositions, colors[obj.getNum()], frame_num - obj.getFirstInstant()) # Plot the object's bounds if it has features if obj.hasFeatures(): imgcrop, yCropMin, yCropMax, xCropMin, xCropMax = imageBox( img, obj, frame_num, homography, width, height) cv2.rectangle(img, (xCropMin, yCropMin), (xCropMax, yCropMax), green, 1) # Put object id and type if it's an object video # If it's a feature video, there's too many numbers, let's ignore it. if video_type == 'object': objDescription = '{} '.format(obj.num) if userTypeNames[obj.userType] != 'unknown': objDescription += userTypeNames[ obj.userType][0].upper() cv2.putText( img, objDescription, obj.projectedPositions[ frame_num - obj.getFirstInstant()].asint().astuple(), cv2.FONT_HERSHEY_PLAIN, 3, colors[obj.getNum()], thickness=4) # Write image out.write(img) frame_num += 1 capture.release() out.release() cv2.destroyAllWindows()
__author__ = 'Akhil' import cv2 import storage import sqlite3 import cvutils import itertools import shutil from numpy.linalg.linalg import inv from numpy import loadtxt homographyFilename = "laurier-homography.txt" homography = inv(loadtxt(homographyFilename)) databaseFilename = "laurier.sqlite" newFilename = "corrected.sqlite" cObjects = storage.loadTrajectoriesFromSqlite(newFilename, "object") objects = storage.loadTrajectoriesFromSqlite(databaseFilename, "object") features = storage.loadTrajectoriesFromSqlite(databaseFilename, "feature") drawing = False # true if mouse is pressed cArray = [] # stores new trajectory positions (temporary) fNo = 0 # stores the frame number objTag = None # stores selected object's id edit = False # turns on edit mode if true trace = [] # holds the trace coordinates def findObject(frameNum, x=None, y=None): global objects, features, objTag box = [] for obj in objects: if obj.existsAtInstant(frameNum):
undistortedImageMultiplication = params.undistortedImageMultiplication undistort = params.undistort firstFrameNum = params.firstFrameNum else: homography = None undistort = False intrinsicCameraMatrix = None distortionCoefficients = [] undistortedImageMultiplication = None firstFrameNum = 0 if not args.configFilename and args.videoFilename is not None: videoFilename = args.videoFilename if not args.configFilename and args.databaseFilename is not None: databaseFilename = args.databaseFilename if not args.configFilename and args.homographyFilename is not None: homography = inv(loadtxt(args.homographyFilename)) if not args.configFilename and args.intrinsicCameraMatrixFilename is not None: intrinsicCameraMatrix = loadtxt(args.intrinsicCameraMatrixFilename) if not args.configFilename and args.distortionCoefficients is not None: distortionCoefficients = args.distortionCoefficients if not args.configFilename and args.undistortedImageMultiplication is not None: undistortedImageMultiplication = args.undistortedImageMultiplication if args.firstFrameNum is not None: firstFrameNum = args.firstFrameNum objects = storage.loadTrajectoriesFromSqlite(databaseFilename, args.trajectoryType) boundingBoxes = storage.loadBoundingBoxTableForDisplay(databaseFilename) cvutils.displayTrajectories(videoFilename, objects, boundingBoxes, homography, firstFrameNum, args.lastFrameNum, rescale = args.rescale, nFramesStep = args.nFramesStep, saveAllImages = args.saveAllImages, undistort = (undistort or args.undistort), intrinsicCameraMatrix = intrinsicCameraMatrix, distortionCoefficients = distortionCoefficients, undistortedImageMultiplication = undistortedImageMultiplication)
parser.add_argument('-g', dest = 'groundTruthDatabaseFilename', help = 'name of the Sqlite database containing the ground truth', required = True) parser.add_argument('-o', dest = 'homographyFilename', help = 'name of the filename for the homography (if tracking was done using the homography)') parser.add_argument('-m', dest = 'matchingDistance', help = 'matching distance between tracker and ground truth trajectories', required = True, type = float) parser.add_argument('--mask', dest = 'maskFilename', help = 'filename of the mask file used to define the where objects were tracked') parser.add_argument('-f', dest = 'firstInstant', help = 'first instant for measurement', required = True, type = int) parser.add_argument('-l', dest = 'lastInstant', help = 'last instant for measurement', required = True, type = int) parser.add_argument('--display', dest = 'display', help = 'display the ground truth to object matches (graphically)', action = 'store_true') parser.add_argument('-i', dest = 'videoFilename', help = 'name of the video file (for display)') args = parser.parse_args() if args.homographyFilename is not None: homography = loadtxt(args.homographyFilename) else: homography = None objects = storage.loadTrajectoriesFromSqlite(args.trackerDatabaseFilename, 'object') if args.maskFilename is not None: maskObjects = [] from matplotlib.pyplot import imread mask = imread(args.maskFilename) if len(mask) > 1: mask = mask[:,:,0] for obj in objects: maskObjects += obj.getObjectsInMask(mask, inv(homography), 2) # TODO add option to keep object if at least one feature in mask objects = maskObjects annotations = storage.loadGroundTruthFromSqlite(args.groundTruthDatabaseFilename) for a in annotations: a.computeCentroidTrajectory(homography)
# filtering.py database_file_name fps import numpy as np import sys import os import gen2_tools sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'TI')) import storage database_file_name = sys.argv[1] # sqlite file fps = float(sys.argv[2]) print 'loading database...' objects = storage.loadTrajectoriesFromSqlite(database_file_name, 'object') print 'filtering...' for obj in objects: obj_speed = obj.getSpeeds() obj_speed.sort() obj_max_speed = obj_speed[int(.95 * len(obj))] * fps * 3.6 # in kmph obj_positions = obj.getPositions() first_last_position_distance = ((obj_positions[0].x - obj_positions[-1].x) ** 2 + (obj_positions[0].y - obj_positions[-1].y) ** 2) ** .5 if first_last_position_distance < 2: # remove any object that moved less than 2m obj.userType = gen2_tools.userType2Num('unknown') elif obj.userType == gen2_tools.userType2Num('car'): if obj_max_speed < 5: obj.userType = gen2_tools.userType2Num('unknown') elif obj_max_speed < 2: obj.userType = gen2_tools.userType2Num('unknown') storage.setRoadUserTypes(database_file_name, objects)
'pedestrian': lambda s: norm(params.meanPedestrianSpeed, params.stdPedestrianSpeed).pdf(s), 'bicycle': lambda s: lognorm(params.scaleCyclistSpeed, loc = 0., scale = np.exp(params.locationCyclistSpeed)).pdf(s)} # numpy lognorm shape, loc, scale: shape for numpy is scale (std of the normal) and scale for numpy is location (mean of the normal) if args.plotSpeedDistribution: import matplotlib.pyplot as plt plt.figure() for k in speedProbabilities: plt.plot(np.arange(0.1, args.maxSpeedDistributionPlot, 0.1), [speedProbabilities[k](s/3.6/25) for s in np.arange(0.1, args.maxSpeedDistributionPlot, 0.1)], label = k) plt.xlabel('Speed (km/h)') plt.ylabel('Probability') plt.legend() plt.title('Probability Density Function') plt.show() sys.exit() objects = storage.loadTrajectoriesFromSqlite(databaseFilename, 'object', args.nObjects, withFeatures = True) #features = storage.loadTrajectoriesFromSqlite(databaseFilename, 'feature') intervals = [] for obj in objects: #obj.setFeatures(features) intervals.append(obj.getTimeInterval()) timeInterval = moving.unionIntervals(intervals) capture = cv2.VideoCapture(videoFilename) width = int(capture.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)) height = int(capture.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)) pastObjects = [] if params.undistort: # setup undistortion [map1, map2] = computeUndistortMaps(width, height, undistortedImageMultiplication, intrinsicCameraMatrix, distortionCoefficients) if capture.isOpened():
parser.add_argument('--metric', dest = 'metric', help = 'metric for the similarity of trajectory points', default = 'cityblock') # default is manhattan distance parser.add_argument('-s', dest = 'minSimilarity', help = 'minimum similarity to put a trajectory in a cluster', type = float, required = True) parser.add_argument('-c', dest = 'minClusterSize', help = 'minimum cluster size', type = int, default = None) parser.add_argument('--display', dest = 'display', help = 'display trajectories', action = 'store_true') # default is manhattan distance args = parser.parse_args() # TODO parameters (random init?) and what to learn from: objects, features, longest features from objects # TODO add possibility to cluter with velocities trajectoryType = args.trajectoryType if args.trajectoryType == 'objectfeatures': trajectoryType = 'object' #features = storage.loadTrajectoriesFromSqlite(databaseFilename, args.trajectoryType) objects = storage.loadTrajectoriesFromSqlite(args.databaseFilename, trajectoryType, withFeatures = (args.trajectoryType == 'objectfeatures'), objectNumbers = args.nTrajectories) if args.trajectoryType == 'objectfeatures': features = [] for o in objects: tmp = utils.sortByLength(o.getFeatures(), reverse = True) features += tmp[:min(len(tmp), 3)] objects = features trajectories = [o.getPositions().asArray().T for o in objects] lcss = utils.LCSS(metric = args.metric, epsilon = args.epsilon) nTrajectories = len(trajectories) similarities = -np.ones((nTrajectories, nTrajectories)) # for i in xrange(nTrajectories):
help='display trajectories', action='store_true') # default is manhattan distance args = parser.parse_args() # TODO parameters (random init?) and what to learn from: objects, features, longest features from objects # TODO add possibility to cluter with velocities trajectoryType = args.trajectoryType if args.trajectoryType == 'objectfeatures': trajectoryType = 'object' #features = storage.loadTrajectoriesFromSqlite(databaseFilename, args.trajectoryType) objects = storage.loadTrajectoriesFromSqlite( args.databaseFilename, trajectoryType, withFeatures=(args.trajectoryType == 'objectfeatures'), objectNumbers=args.nTrajectories) if args.trajectoryType == 'objectfeatures': features = [] for o in objects: tmp = utils.sortByLength(o.getFeatures(), reverse=True) features += tmp[:min(len(tmp), 3)] objects = features trajectories = [o.getPositions().asArray().T for o in objects] lcss = utils.LCSS(metric=args.metric, epsilon=args.epsilon) nTrajectories = len(trajectories)