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

comparison python/storage.py @ 938:fbf12382f3f8

replaced db connection using with

author	Nicolas Saunier <nicolas.saunier@polymtl.ca>
date	Mon, 17 Jul 2017 16:11:18 -0400
parents	0e63a918a1ca
children	b1e8453c207c

comparison

equal deleted inserted replaced

-:b67a784beb69
+:fbf12382f3f8
 printDBError(error)
 def deleteFromSqlite(filename, dataType):
 'Deletes (drops) some tables in the filename depending on type of data'
 if path.isfile(filename):
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 if dataType == 'object':
 dropTables(connection, ['objects', 'objects_features'])
 elif dataType == 'interaction':
 dropTables(connection, ['interactions', 'indicators'])
 elif dataType == 'bb':
 dropTables(connection, ['bounding_boxes'])
 elif dataType == 'pois':
 dropTables(connection, ['gaussians2d', 'objects_pois'])
 elif dataType == 'prototype':
 dropTables(connection, ['prototypes', 'objects_prototypes'])
 else:
 print('Unknown data type {} to delete from database'.format(dataType))
-connection.close()
 else:
 print('{} does not exist'.format(filename))
 def tableExists(connection, tableName):
 'indicates if the table exists in the database'
 try:
-#connection = sqlite3.connect(filename)
 cursor = connection.cursor()
 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 createIndex(connection, tableName, columnName, unique = False):
 '''Creates an index for the column in the table
 I will make querying with a condition on this column faster'''
 try:
-#connection = sqlite3.connect(filename)
 cursor = connection.cursor()
 s = "CREATE "
 if unique:
 s += "UNIQUE "
 cursor.execute(s+"INDEX IF NOT EXISTS "+tableName+"_"+columnName+"_index ON "+tableName+"("+columnName+")")
 def loadTrajectoriesFromSqlite(filename, trajectoryType, objectNumbers = None, withFeatures = False, timeStep = None, tablePrefix = None):
 '''Loads the trajectories (in the general sense,
 either features, objects (feature groups) or bounding box series)
 The number loaded is either the first objectNumbers objects,
 or the indices in objectNumbers from the database'''
-connection = sqlite3.connect(filename)
+objects = []
+with sqlite3.connect(filename) as connection:
 if tablePrefix is None:
 prefix = ''
 else:
 prefix = tablePrefix + '_'
 objects = loadTrajectoriesFromTable(connection, prefix+'positions', trajectoryType, objectNumbers, timeStep)
 objectVelocities = loadTrajectoriesFromTable(connection, prefix+'velocities', trajectoryType, objectNumbers, timeStep)
 if len(objectVelocities) > 0:
 for o,v in zip(objects, objectVelocities):
 if o.getNum() == v.getNum():
 o.velocities = v.positions
 o.velocities.duplicateLastPosition() # avoid having velocity shorter by one position than positions
-else:
-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
-userTypes = loadUserTypesFromTable(cursor, objectNumbers)
+queryStatement = 'SELECT trajectory_id, object_id FROM objects_features'
-for obj in objects:
+if objectNumbers is not None:
-obj.userType = userTypes[obj.getNum()]
+queryStatement += ' WHERE object_id '+getObjectCriteria(objectNumbers)
+queryStatement += ' ORDER BY object_id' # order is important to group all features per object
-if withFeatures:
+logging.debug(queryStatement)
-nFeatures = 0
+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])
 for obj in objects:
-nFeatures = max(nFeatures, max(obj.featureNumbers))
+obj.featureNumbers = featureNumbers[obj.getNum()]
-features = loadTrajectoriesFromSqlite(filename, 'feature', nFeatures+1, timeStep = timeStep)
+# load userType
+userTypes = loadUserTypesFromTable(cursor, objectNumbers)
 for obj in objects:
-obj.setFeatures(features)
+obj.userType = userTypes[obj.getNum()]
-except sqlite3.OperationalError as error:
+if withFeatures:
-printDBError(error)
+nFeatures = 0
-objects = []
+for obj in objects:
+nFeatures = max(nFeatures, max(obj.featureNumbers))
-connection.close()
+features = loadTrajectoriesFromSqlite(filename, 'feature', nFeatures+1, timeStep = timeStep)
+for obj in objects:
+obj.setFeatures(features)
+except sqlite3.OperationalError as error:
+printDBError(error)
 return objects
 def loadObjectFeatureFrameNumbers(filename, objectNumbers = None):
 'Loads the feature frame numbers for each object'
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 try:
 queryStatement = 'SELECT OF.object_id, TL.trajectory_id, TL.length FROM (SELECT trajectory_id, max(frame_number)-min(frame_number) AS length FROM positions GROUP BY trajectory_id) TL, objects_features OF WHERE TL.trajectory_id = OF.trajectory_id'
 if objectNumbers is not None:
 queryStatement += ' AND object_id '+getObjectCriteria(objectNumbers)
 queryStatement += ' ORDER BY OF.object_id, TL.length DESC'
 logging.debug(queryStatement)
 cursor.execute(queryStatement)
 objectFeatureNumbers = {}
 for row in cursor:
 objId = row[0]
 if objId in objectFeatureNumbers:
 objectFeatureNumbers[objId].append(row[1])
 else:
 objectFeatureNumbers[objId] = [row[1]]
 return objectFeatureNumbers
 except sqlite3.OperationalError as error:
 printDBError(error)
 return None
 def addCurvilinearTrajectoriesFromSqlite(filename, objects):
 '''Adds curvilinear positions (s_coordinate, y_coordinate, lane)
 from a database to an existing MovingObject dict (indexed by each objects's num)'''
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 try:
 cursor.execute('SELECT * from curvilinear_positions order by trajectory_id, frame_number')
 except sqlite3.OperationalError as error:
 printDBError(error)
 return []
 missingObjectNumbers = []
 objNum = None
 for row in cursor:
 if objNum != row[0]:
 objNum = row[0]
+if objNum in objects:
+objects[objNum].curvilinearPositions = moving.CurvilinearTrajectory()
+else:
+missingObjectNumbers.append(objNum)
 if objNum in objects:
-objects[objNum].curvilinearPositions = moving.CurvilinearTrajectory()
+objects[objNum].curvilinearPositions.addPositionSYL(row[2],row[3],row[4])
-else:
+if len(missingObjectNumbers) > 0:
-missingObjectNumbers.append(objNum)
+print('List of missing objects to attach corresponding curvilinear trajectories: {}'.format(missingObjectNumbers))
-if objNum in objects:
-objects[objNum].curvilinearPositions.addPositionSYL(row[2],row[3],row[4])
-if len(missingObjectNumbers) > 0:
-print('List of missing objects to attach corresponding curvilinear trajectories: {}'.format(missingObjectNumbers))
 def saveTrajectoriesToTable(connection, objects, trajectoryType, tablePrefix = None):
 'Saves trajectories in table tableName'
 cursor = connection.cursor()
 # Parse feature and/or object structure and commit to DB
 '''Writes features, ie the trajectory positions (and velocities if exist)
 with their instants to a specified sqlite file
 Either feature positions (and velocities if they exist)
 or curvilinear positions will be saved at a time'''
-connection = sqlite3.connect(outputFilename)
+with sqlite3.connect(outputFilename) as connection:
 try:
 saveTrajectoriesToTable(connection, objects, trajectoryType, None)
 except sqlite3.OperationalError as error:
 printDBError(error)
-connection.close()
+def setRoadUserTypes(filename, objects):
+'''Saves the user types of the objects in the sqlite database stored in filename
+The objects should exist in the objects table'''
+with sqlite3.connect(filename) as connection:
+cursor = connection.cursor()
+for obj in objects:
+cursor.execute('update objects set road_user_type = {} WHERE object_id = {}'.format(obj.getUserType(), obj.getNum()))
+connection.commit()
 def loadBBMovingObjectsFromSqlite(filename, objectType = 'bb', objectNumbers = None, timeStep = None):
 '''Loads bounding box moving object from an SQLite
 (format of SQLite output by the ground truth annotation tool
 or Urban Tracker
 Load descriptions?'''
-connection = sqlite3.connect(filename)
 objects = []
+with sqlite3.connect(filename) as connection:
 if objectType == 'bb':
 topCorners = loadTrajectoriesFromTable(connection, 'bounding_boxes', 'bbtop', objectNumbers, timeStep)
 bottomCorners = loadTrajectoriesFromTable(connection, 'bounding_boxes', 'bbbottom', objectNumbers, timeStep)
 userTypes = loadUserTypesFromTable(connection.cursor(), objectNumbers) # string format is same as object
 for t, b in zip(topCorners, bottomCorners):
 num = t.getNum()
 if t.getNum() == b.getNum():
 annotation = moving.BBMovingObject(num, t.getTimeInterval(), t, b, userTypes[num])
 objects.append(annotation)
 else:
 print ('Unknown type of bounding box {}'.format(objectType))
-connection.close()
 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 saveInteractionsToSqlite(filename, interactions):
 'Saves the interactions in the table'
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 try:
 createInteractionTable(cursor)
 for inter in interactions:
 saveInteraction(cursor, inter)
 except sqlite3.OperationalError as error:
 printDBError(error)
 connection.commit()
-connection.close()
 def saveIndicator(cursor, interactionNum, indicator):
 for instant in indicator.getTimeInterval():
 if indicator[instant]:
 cursor.execute('INSERT INTO indicators VALUES({}, {}, {}, {})'.format(interactionNum, events.Interaction.indicatorNameToIndices[indicator.getName()], instant, indicator[instant]))
 def saveIndicatorsToSqlite(filename, interactions, indicatorNames = events.Interaction.indicatorNames):
 'Saves the indicator values in the table'
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 try:
 createInteractionTable(cursor)
 createIndicatorTable(cursor)
 for inter in interactions:
 saveInteraction(cursor, inter)
 for indicatorName in indicatorNames:
 indicator = inter.getIndicator(indicatorName)
 if indicator is not None:
 saveIndicator(cursor, inter.getNum(), indicator)
 except sqlite3.OperationalError as error:
 printDBError(error)
 connection.commit()
-connection.close()
 def loadInteractionsFromSqlite(filename):
 '''Loads interaction and their indicators
 TODO choose the interactions to load'''
 interactions = []
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 try:
 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')
 interactionNum = -1
 indicatorTypeNum = -1
 tmpIndicators = {}
 for row in cursor:
 if row[0] != interactionNum:
 interactionNum = row[0]
 interactions.append(events.Interaction(interactionNum, moving.TimeInterval(row[3],row[4]), row[1], row[2]))
 interactions[-1].indicators = {}
 if indicatorTypeNum != row[5] or row[0] != interactionNum:
 indicatorTypeNum = row[5]
 indicatorName = events.Interaction.indicatorNames[indicatorTypeNum]
 indicatorValues = {row[6]:row[7]}
 interactions[-1].indicators[indicatorName] = indicators.SeverityIndicator(indicatorName, indicatorValues, mostSevereIsMax = not indicatorName in events.Interaction.timeIndicators)
 else:
 indicatorValues[row[6]] = row[7]
 interactions[-1].indicators[indicatorName].timeInterval.last = row[6]
 except sqlite3.OperationalError as error:
 printDBError(error)
 return []
-connection.close()
 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):
 '''Create the table to store the object bounding boxes in image space
 '''
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 try:
 cursor.execute('CREATE TABLE IF NOT EXISTS bounding_boxes (object_id INTEGER, frame_number INTEGER, x_top_left REAL, y_top_left REAL, x_bottom_right REAL, y_bottom_right REAL,  PRIMARY KEY(object_id, frame_number))')
 cursor.execute('INSERT INTO bounding_boxes SELECT object_id, frame_number, min(x), min(y), max(x), max(y) from '
 '(SELECT object_id, frame_number, (x*{}+y*{}+{})/w as x, (x*{}+y*{}+{})/w as y from '
 '(SELECT OF.object_id, P.frame_number, P.x_coordinate as x, P.y_coordinate as y, P.x_coordinate*{}+P.y_coordinate*{}+{} as w from positions P, objects_features OF WHERE P.trajectory_id = OF.trajectory_id)) '.format(invHomography[0,0], invHomography[0,1], invHomography[0,2], invHomography[1,0], invHomography[1,1], invHomography[1,2], invHomography[2,0], invHomography[2,1], invHomography[2,2])+
 'GROUP BY object_id, frame_number')
 except sqlite3.OperationalError as error:
 printDBError(error)
 connection.commit()
-connection.close()
 def loadBoundingBoxTableForDisplay(filename):
 '''Loads bounding boxes from bounding_boxes table for display over trajectories'''
-connection = sqlite3.connect(filename)
-cursor = connection.cursor()
 boundingBoxes = {} # list of bounding boxes for each instant
-try:
+with sqlite3.connect(filename) as connection:
-cursor.execute('SELECT name FROM sqlite_master WHERE type=\'table\' AND name=\'bounding_boxes\'')
+cursor = connection.cursor()
-result = cursor.fetchall()
+try:
-if len(result) > 0:
+cursor.execute('SELECT name FROM sqlite_master WHERE type=\'table\' AND name=\'bounding_boxes\'')
-cursor.execute('SELECT * FROM bounding_boxes')
+result = cursor.fetchall()
-for row in cursor:
+if len(result) > 0:
-boundingBoxes.setdefault(row[1], []).append([moving.Point(row[2], row[3]), moving.Point(row[4], row[5])])
+cursor.execute('SELECT * FROM bounding_boxes')
-except sqlite3.OperationalError as error:
+for row in cursor:
-printDBError(error)
+boundingBoxes.setdefault(row[1], []).append([moving.Point(row[2], row[3]), moving.Point(row[4], row[5])])
-return boundingBoxes
+except sqlite3.OperationalError as error:
-connection.close()
+printDBError(error)
+return boundingBoxes
 return boundingBoxes
 #########################
 # saving and loading for scene interpretation: POIs and Prototypes
 #########################
 def savePrototypesToSqlite(filename, prototypes):
 '''save the prototypes (a prototype is defined by a filename, a number and type'''
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 try:
 cursor.execute('CREATE TABLE IF NOT EXISTS prototypes (prototype_filename VARCHAR, prototype_id INTEGER, trajectory_type VARCHAR CHECK (trajectory_type IN (\"feature\", \"object\")), nmatchings INTEGER, PRIMARY KEY (prototype_filename, prototype_id, trajectory_type))')
 for p in prototypes:
 cursor.execute('INSERT INTO prototypes VALUES(?,?,?,?)', (p.getFilename(), p.getNum(), p.getTrajectoryType(), p.getNMatchings()))
 except sqlite3.OperationalError as error:
 printDBError(error)
 connection.commit()
-connection.close()
 def savePrototypeAssignmentsToSqlite(filename, objects, labels, prototypes):
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 try:
 cursor.execute('CREATE TABLE IF NOT EXISTS objects_prototypes (object_id INTEGER, prototype_filename VARCHAR, prototype_id INTEGER, trajectory_type VARCHAR CHECK (trajectory_type IN (\"feature\", \"object\")), PRIMARY KEY(object_id, prototype_filename, prototype_id, trajectory_type))')
 for obj, label in zip(objects, labels):
 proto = prototypes[label]
 cursor.execute('INSERT INTO objects_prototypes VALUES(?,?,?,?)', (obj.getNum(), proto.getFilename(), proto.getNum(), proto.getTrajectoryType()))
 except sqlite3.OperationalError as error:
 printDBError(error)
 connection.commit()
-connection.close()
 def loadPrototypesFromSqlite(filename, withTrajectories = True):
 'Loads prototype ids and matchings (if stored)'
-connection = sqlite3.connect(filename)
-cursor = connection.cursor()
 prototypes = []
-objects = []
+with sqlite3.connect(filename) as connection:
-try:
+cursor = connection.cursor()
-cursor.execute('SELECT * FROM prototypes')
+objects = []
-for row in cursor:
+try:
-prototypes.append(moving.Prototype(row[0], row[1], row[2], row[3]))
+cursor.execute('SELECT * FROM prototypes')
-if withTrajectories:
+for row in cursor:
-for p in prototypes:
+prototypes.append(moving.Prototype(row[0], row[1], row[2], row[3]))
-p.setMovingObject(loadTrajectoriesFromSqlite(p.getFilename(), p.getTrajectoryType(), [p.getNum()])[0])
+if withTrajectories:
-# loadingInformation = {} # complicated slightly optimized
+for p in prototypes:
-# for p in prototypes:
+p.setMovingObject(loadTrajectoriesFromSqlite(p.getFilename(), p.getTrajectoryType(), [p.getNum()])[0])
-#     dbfn = p.getFilename()
+# loadingInformation = {} # complicated slightly optimized
-#     trajType = p.getTrajectoryType()
+# for p in prototypes:
-#     if (dbfn, trajType) in loadingInformation:
+#     dbfn = p.getFilename()
-#         loadingInformation[(dbfn, trajType)].append(p)
+#     trajType = p.getTrajectoryType()
-#     else:
+#     if (dbfn, trajType) in loadingInformation:
-#         loadingInformation[(dbfn, trajType)] = [p]
+#         loadingInformation[(dbfn, trajType)].append(p)
-# for k, v in loadingInformation.iteritems():
+#     else:
-#     objects += loadTrajectoriesFromSqlite(k[0], k[1], [p.getNum() for p in v])
+#         loadingInformation[(dbfn, trajType)] = [p]
-except sqlite3.OperationalError as error:
+# for k, v in loadingInformation.iteritems():
-printDBError(error)
+#     objects += loadTrajectoriesFromSqlite(k[0], k[1], [p.getNum() for p in v])
-connection.close()
+except sqlite3.OperationalError as error:
+printDBError(error)
 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'''
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 if gmmType not in ['beginning', 'end']:
 print('Unknown POI type {}. Exiting'.format(gmmType))
 import sys
 sys.exit()
 try:
 cursor.execute('CREATE TABLE IF NOT EXISTS gaussians2d (poi_id INTEGER, id INTEGER, type VARCHAR, x_center REAL, y_center REAL, covariance VARCHAR, covariance_type VARCHAR, weight, precisions_cholesky VARCHAR, PRIMARY KEY(poi_id, id))')
 for i in xrange(gmm.n_components):
 cursor.execute('INSERT INTO gaussians2d VALUES(?,?,?,?,?,?,?,?,?)', (gmmId, i, gmmType, gmm.means_[i][0], gmm.means_[i][1], str(gmm.covariances_[i].tolist()), gmm.covariance_type, gmm.weights_[i], str(gmm.precisions_cholesky_[i].tolist())))
 connection.commit()
 except sqlite3.OperationalError as error:
 printDBError(error)
-connection.close()
 def savePOIAssignmentsToSqlite(filename, objects):
 'save the od fields of objects'
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 try:
 cursor.execute('CREATE TABLE IF NOT EXISTS objects_pois (object_id INTEGER, origin_poi_id INTEGER, destination_poi_id INTEGER, PRIMARY KEY(object_id))')
 for o in objects:
 cursor.execute('INSERT INTO objects_pois VALUES(?,?,?)', (o.getNum(), o.od[0], o.od[1]))
 connection.commit()
 except sqlite3.OperationalError as error:
 printDBError(error)
-connection.close()
 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
-connection = sqlite3.connect(filename)
-cursor = connection.cursor()
 pois = []
-try:
+with sqlite3.connect(filename) as connection:
-cursor.execute('SELECT * from gaussians2d')
+cursor = connection.cursor()
-gmmId = None
+try:
-gmm = []
+cursor.execute('SELECT * from gaussians2d')
-for row in cursor:
+gmmId = None
-if gmmId is None or row[0] != gmmId:
+gmm = []
-if len(gmm) > 0:
+for row in cursor:
-tmp = mixture.GaussianMixture(len(gmm), covarianceType)
+if gmmId is None or row[0] != gmmId:
-tmp.means_ = array([gaussian['mean'] for gaussian in gmm])
+if len(gmm) > 0:
-tmp.covariances_ = array([gaussian['covar'] for gaussian in gmm])
+tmp = mixture.GaussianMixture(len(gmm), covarianceType)
-tmp.weights_ = array([gaussian['weight'] for gaussian in gmm])
+tmp.means_ = array([gaussian['mean'] for gaussian in gmm])
-tmp.gmmTypes = [gaussian['type'] for gaussian in gmm]
+tmp.covariances_ = array([gaussian['covar'] for gaussian in gmm])
-tmp.precisions_cholesky_ = array([gaussian['precisions'] for gaussian in gmm])
+tmp.weights_ = array([gaussian['weight'] for gaussian in gmm])
-pois.append(tmp)
+tmp.gmmTypes = [gaussian['type'] for gaussian in gmm]
-gaussian = {'type': row[2],
+tmp.precisions_cholesky_ = array([gaussian['precisions'] for gaussian in gmm])
-'mean': row[3:5],
+pois.append(tmp)
-'covar': array(literal_eval(row[5])),
+gaussian = {'type': row[2],
-'weight': row[7],
+'mean': row[3:5],
-'precisions': array(literal_eval(row[8]))}
+'covar': array(literal_eval(row[5])),
-gmm = [gaussian]
+'weight': row[7],
-covarianceType = row[6]
+'precisions': array(literal_eval(row[8]))}
-gmmId = row[0]
+gmm = [gaussian]
-else:
+covarianceType = row[6]
-gmm.append({'type': row[2],
+gmmId = row[0]
-'mean': row[3:5],
+else:
-'covar': array(literal_eval(row[5])),
+gmm.append({'type': row[2],
-'weight': row[7],
+'mean': row[3:5],
-'precisions': array(literal_eval(row[8]))})
+'covar': array(literal_eval(row[5])),
-if len(gmm) > 0:
+'weight': row[7],
-tmp = mixture.GaussianMixture(len(gmm), covarianceType)
+'precisions': array(literal_eval(row[8]))})
-tmp.means_ = array([gaussian['mean'] for gaussian in gmm])
+if len(gmm) > 0:
-tmp.covariances_ = array([gaussian['covar'] for gaussian in gmm])
+tmp = mixture.GaussianMixture(len(gmm), covarianceType)
-tmp.weights_ = array([gaussian['weight'] for gaussian in gmm])
+tmp.means_ = array([gaussian['mean'] for gaussian in gmm])
-tmp.gmmTypes = [gaussian['type'] for gaussian in gmm]
+tmp.covariances_ = array([gaussian['covar'] for gaussian in gmm])
-tmp.precisions_cholesky_ = array([gaussian['precisions'] for gaussian in gmm])
+tmp.weights_ = array([gaussian['weight'] for gaussian in gmm])
-pois.append(tmp)
+tmp.gmmTypes = [gaussian['type'] for gaussian in gmm]
-except sqlite3.OperationalError as error:
+tmp.precisions_cholesky_ = array([gaussian['precisions'] for gaussian in gmm])
-printDBError(error)
+pois.append(tmp)
-connection.close()
+except sqlite3.OperationalError as error:
+printDBError(error)
 return pois
 #########################
 # saving and loading for scene interpretation (Mohamed Gomaa Mohamed's PhD)
 #########################
 cursor.execute('update objects set startRouteID = {} WHERE object_id = {}'.format(obj.startRouteID, obj.getNum()))
 cursor.execute('update objects set endRouteID = {} WHERE object_id = {}'.format(obj.endRouteID, obj.getNum()))
 connection.commit()
 connection.close()
-def setRoadUserTypes(filename, objects):
-'''Saves the user types of the objects in the sqlite database stored in filename
-The objects should exist in the objects table'''
-connection = sqlite3.connect(filename)
-cursor = connection.cursor()
-for obj in objects:
-cursor.execute('update objects set road_user_type = {} WHERE object_id = {}'.format(obj.getUserType(), obj.getNum()))
-connection.commit()
-connection.close()
 #########################
 # txt files
 #########################
 def openCheck(filename, option = 'r', quitting = False):
 '''Open file filename in read mode by default
 and checks it is open'''
 try:
 return open(filename, option)
 except IOError:
-print 'File %s could not be opened.' % filename
+print 'File {} could not be opened.'.format(filename)
 if quitting:
 from sys import exit
 exit()
 return None
 out.close()
 shutil.os.remove(sqlScriptFilename)
 def loadObjectNumbersInLinkFromVissimFile(filename, linkIds):
 '''Finds the ids of the objects that go through any of the link in the list linkIds'''
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 queryStatement = 'SELECT DISTINCT trajectory_id FROM curvilinear_positions where link_id IN ('+','.join([str(id) for id in linkIds])+')'
 try:
 cursor.execute(queryStatement)
 return [row[0] for row in cursor]
 except sqlite3.OperationalError as error:
 printDBError(error)
 def getNObjectsInLinkFromVissimFile(filename, linkIds):
 '''Returns the number of objects that traveled through the link ids'''
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 queryStatement = 'SELECT link_id, COUNT(DISTINCT trajectory_id) FROM curvilinear_positions where link_id IN ('+','.join([str(id) for id in linkIds])+') GROUP BY link_id'
 try:
 cursor.execute(queryStatement)
 return {row[0]:row[1] for row in cursor}
 except sqlite3.OperationalError as error:
 printDBError(error)
 def loadTrajectoriesFromVissimFile(filename, simulationStepsPerTimeUnit, objectNumbers = None, warmUpLastInstant = None, usePandas = False, nDecimals = 2, lowMemory = True):
 '''Reads data from VISSIM .fzp trajectory file
 simulationStepsPerTimeUnit is the number of simulation steps per unit of time used by VISSIM (second)
 for example, there seems to be 10 simulation steps per simulated second in VISSIM,
 if (warmUpLastInstant is None or instant >= warmUpLastInstant) and objNum in objects:
 objects[objNum].timeInterval.last = instant
 objects[objNum].curvilinearPositions.addPositionSYL(s, y, lane)
 line = readline(inputfile, '*$')
 elif filename.endswith(".sqlite"):
-connection = sqlite3.connect(filename)
+with sqlite3.connect(filename) as connection:
 cursor = connection.cursor()
 queryStatement = 'SELECT t, trajectory_id, link_id, lane_id, s_coordinate, y_coordinate FROM curvilinear_positions'
 if objectNumbers is not None:
 queryStatement += ' WHERE trajectory_id '+getObjectCriteria(objectNumbers)
 queryStatement += ' ORDER BY trajectory_id, t'
 try:
 cursor.execute(queryStatement)
 for row in cursor:
 objNum = row[1]
 instant = row[0]*simulationStepsPerTimeUnit
 s = row[4]
 y = row[5]
 lane = '{}_{}'.format(row[2], row[3])
 if objNum not in objects:
 if warmUpLastInstant is None or instant >= warmUpLastInstant:
 if objectNumbers is None or len(objects) < objectNumbers:
 objects[objNum] = moving.MovingObject(num = objNum, timeInterval = moving.TimeInterval(instant, instant))
 objects[objNum].curvilinearPositions = moving.CurvilinearTrajectory()
 if (warmUpLastInstant is None or instant >= warmUpLastInstant) and objNum in objects:
 objects[objNum].timeInterval.last = instant
 objects[objNum].curvilinearPositions.addPositionSYL(s, y, lane)
 except sqlite3.OperationalError as error:
 printDBError(error)
 else:
 print("File type of "+filename+" not supported (only .sqlite and .fzp files)")
 return objects.values()
 def selectPDLanes(data, lanes = None):

Mercurial Hosting > traffic-intelligence

comparison python/storage.py @ 938:fbf12382f3f8