repo/traffic-intelligence: trafficintelligence/storage.py comparison

comparison trafficintelligence/storage.py @ 1077:3939ae415be0

Merging

author	Wendlasida
date	Fri, 20 Jul 2018 14:03:34 -0400
parents	67144f26609e d4d052a05337
children	e53c6e87bb3f

comparison

equal deleted inserted replaced

-:108c5dc4e34a
+:3939ae415be0
 cursor.execute('SELECT COUNT(*) FROM SQLITE_MASTER WHERE type = \'table\' AND name = \''+tableName+'\'')
 return cursor.fetchone()[0] == 1
 except sqlite3.OperationalError as error:
 printDBError(error)
+def tableNames(filename):
+'Lists the names of the tables in the SQLite file'
+if Path(filename).is_file():
+with sqlite3.connect(filename) as connection:
+try:
+cursor = connection.cursor()
+cursor.execute('SELECT name FROM sqlite_master WHERE type = \'table\'')
+return [row[0] for row in cursor]
+except sqlite3.OperationalError as error:
+printDBError(error)
+return []
 def createTrajectoryTable(cursor, tableName):
 if tableName.endswith('positions') or tableName.endswith('velocities'):
 cursor.execute("CREATE TABLE IF NOT EXISTS "+tableName+" (trajectory_id INTEGER, frame_number INTEGER, x_coordinate REAL, y_coordinate REAL, PRIMARY KEY(trajectory_id, frame_number))")
 else:
 print('Unallowed name {} for trajectory table'.format(tableName))
 if object, features can be loaded with withFeatures or nLongestObjectFeatures used to select the n longest features
 The number loaded is either the first objectNumbers objects,
 or the indices in objectNumbers from the database'''
 objects = []
-with sqlite3.connect(filename) as connection:
+if Path(filename).is_file():
-objects = loadTrajectoriesFromTable(connection, 'positions', trajectoryType, objectNumbers, timeStep)
+with sqlite3.connect(filename) as connection:
-objectVelocities = loadTrajectoriesFromTable(connection, 'velocities', trajectoryType, objectNumbers, timeStep)
+objects = loadTrajectoriesFromTable(connection, 'positions', trajectoryType, objectNumbers, timeStep)
+objectVelocities = loadTrajectoriesFromTable(connection, 'velocities', trajectoryType, objectNumbers, timeStep)
-if len(objectVelocities) > 0:
-for o,v in zip(objects, objectVelocities):
+if len(objectVelocities) > 0:
-if o.getNum() == v.getNum():
+for o,v in zip(objects, objectVelocities):
-o.velocities = v.positions
+if o.getNum() == v.getNum():
-o.velocities.duplicateLastPosition() # avoid having velocity shorter by one position than positions
+o.velocities = v.positions
-else:
+o.velocities.duplicateLastPosition() # avoid having velocity shorter by one position than positions
-print('Could not match positions {0} with velocities {1}'.format(o.getNum(), v.getNum()))
-if trajectoryType == 'object':
-cursor = connection.cursor()
-try:
-# attribute feature numbers to objects
-queryStatement = 'SELECT trajectory_id, object_id FROM objects_features'
-if objectNumbers is not None:
-queryStatement += ' WHERE object_id '+getObjectCriteria(objectNumbers)
-queryStatement += ' ORDER BY object_id' # order is important to group all features per object
-logging.debug(queryStatement)
-cursor.execute(queryStatement)
-featureNumbers = {}
-for row in cursor:
-objId = row[1]
-if objId not in featureNumbers:
-featureNumbers[objId] = [row[0]]
 else:
-featureNumbers[objId].append(row[0])
+print('Could not match positions {0} with velocities {1}'.format(o.getNum(), v.getNum()))
-for obj in objects:
+if trajectoryType == 'object':
-obj.featureNumbers = featureNumbers[obj.getNum()]
+cursor = connection.cursor()
+try:
-# load userType
+# attribute feature numbers to objects
-attributes = loadObjectAttributesFromTable(cursor, objectNumbers, True)
+queryStatement = 'SELECT trajectory_id, object_id FROM objects_features'
-for obj in objects:
+if objectNumbers is not None:
-userType, nObjects = attributes[obj.getNum()]
+queryStatement += ' WHERE object_id '+getObjectCriteria(objectNumbers)
-obj.setUserType(userType)
+queryStatement += ' ORDER BY object_id' # order is important to group all features per object
-obj.setNObjects(nObjects)
+logging.debug(queryStatement)
+cursor.execute(queryStatement)
-# add features
-if withFeatures:
+featureNumbers = {}
+for row in cursor:
+objId = row[1]
+if objId not in featureNumbers:
+featureNumbers[objId] = [row[0]]
+else:
+featureNumbers[objId].append(row[0])
 for obj in objects:
-obj.features = loadTrajectoriesFromSqlite(filename, 'feature', obj.featureNumbers, timeStep = timeStep)
+obj.featureNumbers = featureNumbers[obj.getNum()]
-elif nLongestFeaturesPerObject is not None:
+# load userType
+attributes = loadObjectAttributesFromTable(cursor, objectNumbers, True)
 for obj in objects:
-queryStatement = 'SELECT trajectory_id, max(frame_number)-min(frame_number) AS length FROM positions WHERE trajectory_id '+getObjectCriteria(obj.featureNumbers)+' GROUP BY trajectory_id ORDER BY length DESC'
+userType, nObjects = attributes[obj.getNum()]
-logging.debug(queryStatement)
+obj.setUserType(userType)
-cursor.execute(queryStatement)
+obj.setNObjects(nObjects)
-obj.features = loadTrajectoriesFromSqlite(filename, 'feature', [row[0] for i,row in enumerate(cursor) if i<nLongestFeaturesPerObject], timeStep = timeStep)
+# add features
-except sqlite3.OperationalError as error:
+if withFeatures:
-printDBError(error)
+for obj in objects:
+obj.features = loadTrajectoriesFromSqlite(filename, 'feature', obj.featureNumbers, timeStep = timeStep)
+elif nLongestFeaturesPerObject is not None:
+for obj in objects:
+queryStatement = 'SELECT trajectory_id, max(frame_number)-min(frame_number) AS length FROM positions WHERE trajectory_id '+getObjectCriteria(obj.featureNumbers)+' GROUP BY trajectory_id ORDER BY length DESC'
+logging.debug(queryStatement)
+cursor.execute(queryStatement)
+obj.features = loadTrajectoriesFromSqlite(filename, 'feature', [row[0] for i,row in enumerate(cursor) if i<nLongestFeaturesPerObject], timeStep = timeStep)
+except sqlite3.OperationalError as error:
+printDBError(error)
 return objects
 def loadObjectFeatureFrameNumbers(filename, objectNumbers = None):
 'Loads the feature frame numbers for each object'
 with sqlite3.connect(filename) as connection:
 (format of SQLite output by the ground truth annotation tool
 or Urban Tracker
 Load descriptions?'''
 objects = []
-with sqlite3.connect(filename) as connection:
+if Path(filename).is_file():
-if objectType == 'bb':
+with sqlite3.connect(filename) as connection:
-topCorners = loadTrajectoriesFromTable(connection, 'bounding_boxes', 'bbtop', objectNumbers, timeStep)
+if objectType == 'bb':
-bottomCorners = loadTrajectoriesFromTable(connection, 'bounding_boxes', 'bbbottom', objectNumbers, timeStep)
+topCorners = loadTrajectoriesFromTable(connection, 'bounding_boxes', 'bbtop', objectNumbers, timeStep)
-userTypes = loadObjectAttributesFromTable(connection.cursor(), objectNumbers) # string format is same as object
+bottomCorners = loadTrajectoriesFromTable(connection, 'bounding_boxes', 'bbbottom', objectNumbers, timeStep)
+userTypes = loadObjectAttributesFromTable(connection.cursor(), objectNumbers) # string format is same as object
-for t, b in zip(topCorners, bottomCorners):
-num = t.getNum()
+for t, b in zip(topCorners, bottomCorners):
-if t.getNum() == b.getNum():
+num = t.getNum()
-annotation = moving.BBMovingObject(num, t.getTimeInterval(), t, b, userTypes[num])
+if t.getNum() == b.getNum():
-objects.append(annotation)
+annotation = moving.BBMovingObject(num, t.getTimeInterval(), t, b, userTypes[num])
-else:
+objects.append(annotation)
-print ('Unknown type of bounding box {}'.format(objectType))
+else:
+print ('Unknown type of bounding box {}'.format(objectType))
 return objects
 def saveInteraction(cursor, interaction):
 roadUserNumbers = list(interaction.getRoadUserNumbers())
 cursor.execute('INSERT INTO interactions VALUES({}, {}, {}, {}, {})'.format(interaction.getNum(), roadUserNumbers[0], roadUserNumbers[1], interaction.getFirstInstant(), interaction.getLastInstant()))
 def loadInteractionsFromSqlite(filename):
 '''Loads interaction and their indicators
 TODO choose the interactions to load'''
 interactions = []
-with sqlite3.connect(filename) as connection:
+if Path(filename).is_file():
-cursor = connection.cursor()
+with sqlite3.connect(filename) as connection:
-try:
+cursor = connection.cursor()
-cursor.execute('SELECT INT.id, INT.object_id1, INT.object_id2, INT.first_frame_number, INT.last_frame_number, IND.indicator_type, IND.frame_number, IND.value from interactions INT, indicators IND WHERE INT.id = IND.interaction_id ORDER BY INT.id, IND.indicator_type, IND.frame_number')
+try:
-interactionNum = -1
+cursor.execute('SELECT INT.id, INT.object_id1, INT.object_id2, INT.first_frame_number, INT.last_frame_number, IND.indicator_type, IND.frame_number, IND.value from interactions INT, indicators IND WHERE INT.id = IND.interaction_id ORDER BY INT.id, IND.indicator_type, IND.frame_number')
-indicatorTypeNum = -1
+interactionNum = -1
-tmpIndicators = {}
+indicatorTypeNum = -1
-for row in cursor:
+tmpIndicators = {}
-if row[0] != interactionNum:
+for row in cursor:
-interactionNum = row[0]
+if row[0] != interactionNum:
-interactions.append(events.Interaction(interactionNum, moving.TimeInterval(row[3],row[4]), row[1], row[2]))
+interactionNum = row[0]
-interactions[-1].indicators = {}
+interactions.append(events.Interaction(interactionNum, moving.TimeInterval(row[3],row[4]), row[1], row[2]))
-if indicatorTypeNum != row[5] or row[0] != interactionNum:
+interactions[-1].indicators = {}
-indicatorTypeNum = row[5]
+if indicatorTypeNum != row[5] or row[0] != interactionNum:
-indicatorName = events.Interaction.indicatorNames[indicatorTypeNum]
+indicatorTypeNum = row[5]
-indicatorValues = {row[6]:row[7]}
+indicatorName = events.Interaction.indicatorNames[indicatorTypeNum]
-interactions[-1].indicators[indicatorName] = indicators.SeverityIndicator(indicatorName, indicatorValues, mostSevereIsMax = not indicatorName in events.Interaction.timeIndicators)
+indicatorValues = {row[6]:row[7]}
-else:
+interactions[-1].indicators[indicatorName] = indicators.SeverityIndicator(indicatorName, indicatorValues, mostSevereIsMax = not indicatorName in events.Interaction.timeIndicators)
-indicatorValues[row[6]] = row[7]
+else:
-interactions[-1].indicators[indicatorName].timeInterval.last = row[6]
+indicatorValues[row[6]] = row[7]
-except sqlite3.OperationalError as error:
+interactions[-1].indicators[indicatorName].timeInterval.last = row[6]
-printDBError(error)
+except sqlite3.OperationalError as error:
-return []
+printDBError(error)
+return []
 return interactions
 # load first and last object instants
 # CREATE TEMP TABLE IF NOT EXISTS object_instants AS SELECT OF.object_id, min(frame_number) as first_instant, max(frame_number) as last_instant from positions P, objects_features OF WHERE P.trajectory_id = OF.trajectory_id group by OF.object_id order by OF.object_id
 def createBoundingBoxTable(filename, invHomography = None):
 connection.commit()
 def loadBoundingBoxTableForDisplay(filename):
 '''Loads bounding boxes from bounding_boxes table for display over trajectories'''
 boundingBoxes = {} # list of bounding boxes for each instant
-with sqlite3.connect(filename) as connection:
+if Path(filename).is_file():
-cursor = connection.cursor()
+with sqlite3.connect(filename) as connection:
-try:
+cursor = connection.cursor()
-cursor.execute('SELECT name FROM sqlite_master WHERE type=\'table\' AND name=\'bounding_boxes\'')
+try:
-result = cursor.fetchall()
+cursor.execute('SELECT name FROM sqlite_master WHERE type=\'table\' AND name=\'bounding_boxes\'')
-if len(result) > 0:
+result = cursor.fetchall()
-cursor.execute('SELECT * FROM bounding_boxes')
+if len(result) > 0:
-for row in cursor:
+cursor.execute('SELECT * FROM bounding_boxes')
-boundingBoxes.setdefault(row[1], []).append([moving.Point(row[2], row[3]), moving.Point(row[4], row[5])])
+for row in cursor:
-except sqlite3.OperationalError as error:
+boundingBoxes.setdefault(row[1], []).append([moving.Point(row[2], row[3]), moving.Point(row[4], row[5])])
-printDBError(error)
+except sqlite3.OperationalError as error:
-return boundingBoxes
+printDBError(error)
 return boundingBoxes
 #########################
 # saving and loading for scene interpretation: POIs and Prototypes
 #########################
 except sqlite3.OperationalError as error:
 printDBError(error)
 connection.commit()
 def loadPrototypeAssignmentsFromSqlite(filename, objectType):
-with sqlite3.connect(filename) as connection:
+prototypeAssignments = {}
-cursor = connection.cursor()
+if Path(filename).is_file():
-try:
+with sqlite3.connect(filename) as connection:
-tableName, objectIdColumnName = prototypeAssignmentNames(objectType)
+cursor = connection.cursor()
-cursor.execute('SELECT * FROM '+tableName)
+try:
-prototypeAssignments = {}
+tableName, objectIdColumnName = prototypeAssignmentNames(objectType)
-for row in cursor:
+cursor.execute('SELECT * FROM '+tableName)
-p = moving.Prototype(row[1], row[2], row[3])
+for row in cursor:
-if p in prototypeAssignments:
+p = moving.Prototype(row[1], row[2], row[3])
-prototypeAssignments[p].append(row[0])
+if p in prototypeAssignments:
-else:
+prototypeAssignments[p].append(row[0])
-prototypeAssignments[p] = [row[0]]
+else:
-return prototypeAssignments
+prototypeAssignments[p] = [row[0]]
-except sqlite3.OperationalError as error:
+return prototypeAssignments
-printDBError(error)
+except sqlite3.OperationalError as error:
+printDBError(error)
+return prototypeAssignments
 def loadPrototypesFromSqlite(filename, withTrajectories = True):
 'Loads prototype ids and matchings (if stored)'
 prototypes = []
-with sqlite3.connect(filename) as connection:
+if Path(filename).is_file():
-cursor = connection.cursor()
+with sqlite3.connect(filename) as connection:
-objects = []
+cursor = connection.cursor()
-try:
+objects = []
-cursor.execute('SELECT * FROM prototypes')
+try:
-for row in cursor:
+cursor.execute('SELECT * FROM prototypes')
-prototypes.append(moving.Prototype(row[0], row[1], row[2], row[3]))
+for row in cursor:
-if withTrajectories:
+prototypes.append(moving.Prototype(row[0], row[1], row[2], row[3]))
-for p in prototypes:
+if withTrajectories:
-p.setMovingObject(loadTrajectoriesFromSqlite(p.getFilename(), p.getTrajectoryType(), [p.getNum()])[0])
+for p in prototypes:
-# loadingInformation = {} # complicated slightly optimized
+p.setMovingObject(loadTrajectoriesFromSqlite(p.getFilename(), p.getTrajectoryType(), [p.getNum()])[0])
-# for p in prototypes:
+# loadingInformation = {} # complicated slightly optimized
-#     dbfn = p.getFilename()
+# for p in prototypes:
-#     trajType = p.getTrajectoryType()
+#     dbfn = p.getFilename()
-#     if (dbfn, trajType) in loadingInformation:
+#     trajType = p.getTrajectoryType()
-#         loadingInformation[(dbfn, trajType)].append(p)
+#     if (dbfn, trajType) in loadingInformation:
-#     else:
+#         loadingInformation[(dbfn, trajType)].append(p)
-#         loadingInformation[(dbfn, trajType)] = [p]
+#     else:
-# for k, v in loadingInformation.iteritems():
+#         loadingInformation[(dbfn, trajType)] = [p]
-#     objects += loadTrajectoriesFromSqlite(k[0], k[1], [p.getNum() for p in v])
+# for k, v in loadingInformation.iteritems():
-except sqlite3.OperationalError as error:
+#     objects += loadTrajectoriesFromSqlite(k[0], k[1], [p.getNum() for p in v])
-printDBError(error)
+except sqlite3.OperationalError as error:
-if len(set([p.getTrajectoryType() for p in prototypes])) > 1:
+printDBError(error)
-print('Different types of prototypes in database ({}).'.format(set([p.getTrajectoryType() for p in prototypes])))
+if len(set([p.getTrajectoryType() for p in prototypes])) > 1:
+print('Different types of prototypes in database ({}).'.format(set([p.getTrajectoryType() for p in prototypes])))
 return prototypes
 def savePOIsToSqlite(filename, gmm, gmmType, gmmId):
 '''Saves a Gaussian mixture model (of class sklearn.mixture.GaussianMixture)
 gmmType is a type of GaussianMixture, learnt either from beginnings or ends of trajectories'''
 def loadPOIsFromSqlite(filename):
 'Loads all 2D Gaussians in the database'
 from sklearn import mixture # todo if not avalaible, load data in duck-typed class with same fields
 from ast import literal_eval
 pois = []
-with sqlite3.connect(filename) as connection:
+if Path(filename).is_file():
-cursor = connection.cursor()
+with sqlite3.connect(filename) as connection:
-try:
+cursor = connection.cursor()
-cursor.execute('SELECT * from gaussians2d')
+try:
-gmmId = None
+cursor.execute('SELECT * from gaussians2d')
-gmm = []
+gmmId = None
-for row in cursor:
+gmm = []
-if gmmId is None or row[0] != gmmId:
+for row in cursor:
-if len(gmm) > 0:
+if gmmId is None or row[0] != gmmId:
-tmp = mixture.GaussianMixture(len(gmm), covarianceType)
+if len(gmm) > 0:
-tmp.means_ = array([gaussian['mean'] for gaussian in gmm])
+tmp = mixture.GaussianMixture(len(gmm), covarianceType)
-tmp.covariances_ = array([gaussian['covar'] for gaussian in gmm])
+tmp.means_ = array([gaussian['mean'] for gaussian in gmm])
-tmp.weights_ = array([gaussian['weight'] for gaussian in gmm])
+tmp.covariances_ = array([gaussian['covar'] for gaussian in gmm])
-tmp.gmmTypes = [gaussian['type'] for gaussian in gmm]
+tmp.weights_ = array([gaussian['weight'] for gaussian in gmm])
-tmp.precisions_cholesky_ = array([gaussian['precisions'] for gaussian in gmm])
+tmp.gmmTypes = [gaussian['type'] for gaussian in gmm]
-pois.append(tmp)
+tmp.precisions_cholesky_ = array([gaussian['precisions'] for gaussian in gmm])
-gaussian = {'type': row[2],
+pois.append(tmp)
-'mean': row[3:5],
+gaussian = {'type': row[2],
-'covar': array(literal_eval(row[5])),
+'mean': row[3:5],
-'weight': row[7],
+'covar': array(literal_eval(row[5])),
-'precisions': array(literal_eval(row[8]))}
+'weight': row[7],
-gmm = [gaussian]
+'precisions': array(literal_eval(row[8]))}
-covarianceType = row[6]
+gmm = [gaussian]
-gmmId = row[0]
+covarianceType = row[6]
-else:
+gmmId = row[0]
-gmm.append({'type': row[2],
+else:
-'mean': row[3:5],
+gmm.append({'type': row[2],
-'covar': array(literal_eval(row[5])),
+'mean': row[3:5],
-'weight': row[7],
+'covar': array(literal_eval(row[5])),
-'precisions': array(literal_eval(row[8]))})
+'weight': row[7],
-if len(gmm) > 0:
+'precisions': array(literal_eval(row[8]))})
-tmp = mixture.GaussianMixture(len(gmm), covarianceType)
+if len(gmm) > 0:
-tmp.means_ = array([gaussian['mean'] for gaussian in gmm])
+tmp = mixture.GaussianMixture(len(gmm), covarianceType)
-tmp.covariances_ = array([gaussian['covar'] for gaussian in gmm])
+tmp.means_ = array([gaussian['mean'] for gaussian in gmm])
-tmp.weights_ = array([gaussian['weight'] for gaussian in gmm])
+tmp.covariances_ = array([gaussian['covar'] for gaussian in gmm])
-tmp.gmmTypes = [gaussian['type'] for gaussian in gmm]
+tmp.weights_ = array([gaussian['weight'] for gaussian in gmm])
-tmp.precisions_cholesky_ = array([gaussian['precisions'] for gaussian in gmm])
+tmp.gmmTypes = [gaussian['type'] for gaussian in gmm]
-pois.append(tmp)
+tmp.precisions_cholesky_ = array([gaussian['precisions'] for gaussian in gmm])
-except sqlite3.OperationalError as error:
+pois.append(tmp)
-printDBError(error)
+except sqlite3.OperationalError as error:
+printDBError(error)
 return pois
 #########################
 # saving and loading for scene interpretation (Mohamed Gomaa Mohamed's PhD)
 #########################
 self.scaleCyclistSpeed = config.getfloat(self.sectionHeader, 'cyc-speed-scale')
 self.meanVehicleSpeed = config.getfloat(self.sectionHeader, 'mean-veh-speed')
 self.stdVehicleSpeed = config.getfloat(self.sectionHeader, 'std-veh-speed')
 def __init__(self, filename = None):
-if filename is not None and Path(filename).exists():
+self.configFilename = filename
+if filename is not None and Path(filename).is_file():
 self.loadConfigFile(filename)
 else:
 print('Configuration filename {} could not be loaded.'.format(filename))
 def convertToFrames(self, frameRate, speedRatio = 3.6):
 self.sectionHeader = config.sections()[0]
 # Tracking/display parameters
 self.videoFilename = utils.getRelativeFilename(parentPath, config.get(self.sectionHeader, 'video-filename'))
 self.databaseFilename = utils.getRelativeFilename(parentPath, config.get(self.sectionHeader, 'database-filename'))
 self.homographyFilename = utils.getRelativeFilename(parentPath, config.get(self.sectionHeader, 'homography-filename'))
-if Path(self.homographyFilename).exists():
+if Path(self.homographyFilename).is_file():
 self.homography = loadtxt(self.homographyFilename)
 else:
 self.homography = None
 self.intrinsicCameraFilename = utils.getRelativeFilename(parentPath, config.get(self.sectionHeader, 'intrinsic-camera-filename'))
-if Path(self.intrinsicCameraFilename).exists():
+if Path(self.intrinsicCameraFilename).is_file():
 self.intrinsicCameraMatrix = loadtxt(self.intrinsicCameraFilename)
 else:
 self.intrinsicCameraMatrix = None
 distortionCoefficients = getValuesFromINIFile(filename, 'distortion-coefficients', '=')
 self.distortionCoefficients = [float(x) for x in distortionCoefficients]
 self.minFeatureDisplacement = config.getfloat(self.sectionHeader, 'min-feature-displacement')
 self.updateTimer = config.getint(self.sectionHeader, 'tracker-reload-time')
 def __init__(self, filename = None):
-if filename is not None and Path(filename).exists():
+self.configFilename = filename
+if filename is not None and Path(filename).is_file():
 self.loadConfigFile(filename)
 else:
 print('Configuration filename {} could not be loaded.'.format(filename))
-self.configFilename = filename
 def processVideoArguments(args):
 '''Loads information from configuration file
 then checks what was passed on the command line
 for override (eg video filename and database filename'''

Mercurial Hosting > traffic-intelligence

comparison trafficintelligence/storage.py @ 1077:3939ae415be0