def __init__(self, cam_id, h5):
''' data2_distorted structure:
/data2d_distorted (Table(3091,)) '2d data'
description := {
0: "camn": UInt16Col(shape=(), dflt=0, pos=0),
1: "frame": UInt64Col(shape=(), dflt=0, pos=1),
2: "timestamp": Float64Col(shape=(), dflt=0.0, pos=2),
3: "cam_received_timestamp": Float64Col(shape=(), dflt=0.0, pos=3),
4: "x": Float32Col(shape=(), dflt=0.0, pos=4),
5: "y": Float32Col(shape=(), dflt=0.0, pos=5),
6: "area": Float32Col(shape=(), dflt=0.0, pos=6),
7: "slope": Float32Col(shape=(), dflt=0.0, pos=7),
8: "eccentricity": Float32Col(shape=(), dflt=0.0, pos=8),
9: "frame_pt_idx": UInt8Col(shape=(), dflt=0, pos=9),
10: "cur_val": UInt8Col(shape=(), dflt=0, pos=10),
11: "mean_val": Float32Col(shape=(), dflt=0.0, pos=11),
12: "sumsqf_val": Float32Col(shape=(), dflt=0.0, pos=12)}
byteorder := 'little'
chunkshape := (585,)
'''
self.cam_id = cam_id
camn2cam_id, cam_id2camns = result_utils.get_caminfo_dicts(h5)
self.camn = cam_id2camns[self.cam_id]
self.fps = result_utils.get_fps( h5 )
self.resolution = getattr(h5.root.images,'sericomyia-mobile.local_3').read().shape
# pull out only the data that is relevant to this camera
# note: multiple rows for individual frames if there were multiple 2D objects detected in that frame
all_data = h5.root.data2d_distorted[:]
this_idx = numpy.nonzero( all_data['camn']==self.camn )[0]
self.data = all_data[this_idx]
def load_data(self, filename, kalman_smoothing=False, dynamic_model=None, fps=None, info={}, save_covariance=False):
# use info to pass information to trajectory instances as a dictionary.
# eg. info={"post_type": "black"}
# save_covariance: set to True if you need access to the covariance data. Keep as False if this is not important for analysis (takes up lots of space)
# set up analyzer
ca = core_analysis.get_global_CachingAnalyzer()
(obj_ids, use_obj_ids, is_mat_file, data_file, extra) = ca.initial_file_load(filename)
data_file.flush()
# data set defaults
if fps is None:
fps = result_utils.get_fps(data_file)
if dynamic_model is None:
try:
dyn_model = extra['dynamic_model_name']
except:
print 'cannot find dynamic model'
print 'using EKF mamarama, units: mm'
dyn_model = 'EKF mamarama, units: mm'
if dynamic_model is not None:
dyn_model = dynamic_model
# if kalman smoothing is on, then we cannot use the EKF model - remove that from the model name
print '** Kalman Smoothing is: ', kalman_smoothing, ' **'
if kalman_smoothing is True:
dyn_model = dyn_model[4:]
print 'using dynamic model: ', dyn_model
print 'framerate: ', fps
print 'loading data.... '
self.dynamic_model = dyn_model
self.fps = fps
# load object id's and save as Trajectory instances
for obj_id in use_obj_ids:
print 'processing: ', obj_id
try:
print obj_id
kalman_rows = ca.load_data( obj_id, data_file,
dynamic_model_name = dyn_model,
use_kalman_smoothing= kalman_smoothing,
frames_per_second= fps)
except:
print 'object id failed to load (probably no data): ', obj_id
continue
# couple object ID dictionary with trajectory objects
trajec_id = str(obj_id) # this is not necessarily redundant with the obj_id, it allows for making a unique trajectory id when merging multiple datasets
tmp = Trajectory(trajec_id, kalman_rows, info=info, fps=fps, save_covariance=save_covariance, extra=extra)
self.trajecs.setdefault(trajec_id, tmp)
return
def __init__(self,kalman_filename):
import flydra.a2.core_analysis as core_analysis
import flydra.analysis.result_utils as result_utils
self.ca = core_analysis.get_global_CachingAnalyzer()
(obj_ids, use_obj_ids, is_mat_file, data_file,
extra) = self.ca.initial_file_load(kalman_filename)
self.data_file = data_file
self.up_dir = None
if 1:
dynamic_model = extra['dynamic_model_name']
print 'detected file loaded with dynamic model "%s"'%dynamic_model
if dynamic_model.startswith('EKF '):
dynamic_model = dynamic_model[4:]
print ' for smoothing, will use dynamic model "%s"'%dynamic_model
self.dynamic_model = dynamic_model
self.fps = result_utils.get_fps( data_file )
self.use_kalman_smoothing = True
self.up_dir = (0,0,1)
def load_data(self, filename, kalman_smoothing=False, dynamic_model=None, fps=None, info={}, save_covariance=False, experiment_length=19*60*60):
# use info to pass information to trajectory instances as a dictionary.
# eg. info={"post_type": "black"}
# save_covariance: set to True if you need access to the covariance data. Keep as False if this is not important for analysis (takes up lots of space)
# set up analyzer
ca = core_analysis.get_global_CachingAnalyzer()
(obj_ids, use_obj_ids, is_mat_file, data_file, extra) = ca.initial_file_load(filename)
data_file.flush()
# data set defaults
if fps is None:
fps = result_utils.get_fps(data_file)
if dynamic_model is None:
try:
dyn_model = extra['dynamic_model_name']
except:
print 'cannot find dynamic model'
print 'using EKF mamarama, units: mm'
dyn_model = 'EKF mamarama, units: mm'
if dynamic_model is not None:
dyn_model = dynamic_model
# if kalman smoothing is on, then we cannot use the EKF model - remove that from the model name
print '** Kalman Smoothing is: ', kalman_smoothing, ' **'
if kalman_smoothing is True:
dyn_model = dyn_model[4:]
print 'using dynamic model: ', dyn_model
print 'framerate: ', fps
print 'loading data.... '
self.dynamic_model = dyn_model
self.fps = fps
time_start = None
# load object id's and save as Trajectory instances
for obj_id in use_obj_ids:
print 'processing: ', obj_id
try:
print obj_id
kalman_rows = ca.load_data( obj_id, data_file,
dynamic_model_name = dyn_model,
use_kalman_smoothing= kalman_smoothing,
frames_per_second= fps)
except:
print 'object id failed to load (probably no data): ', obj_id
continue
# couple object ID dictionary with trajectory objects
filenamebase = os.path.basename(filename)
trajecbase = filenamebase.rstrip('5').rstrip('.h').lstrip('DATA').rstrip('.kalmanized')
trajec_id = trajecbase + '_' + str(obj_id) # filename details + original object id - this is unique
tmp = Trajectory(trajec_id, kalman_rows, info=info, fps=fps, save_covariance=save_covariance, extra=extra)
tmp.h5 = os.path.basename(filename)
if time_start is None:
time_start = tmp.timestamp_epoch
else:
if tmp.timestamp_epoch - time_start > experiment_length:
break
else:
self.trajecs.setdefault(trajec_id, tmp)
self.h5_files_loaded.append(os.path.basename(filename))
return
def load_data (self, filename,
calibration_file = None,
objs = None,
obj_filelist = None,
kalman_smoothing = True,
fps = None,
dynamic_model = None,
load_2d=True,):
self.datasets.append(len(self.datasets)+1)
# raw h5 - this is the 2d raw camera data:
if load_2d is True:
h5 = PT.openFile( filename, mode='r' )
camn2cam_id, cam_id2camns = result_utils.get_caminfo_dicts(h5)
cam_ids = cam_id2camns.keys()
cams2d = []
for cam_id in cam_ids:
cams2d.append( Cam2d(cam_id, h5) )
self.cams2d.append(cams2d)
# set up analyzer
ca = core_analysis.get_global_CachingAnalyzer()
(obj_ids, use_obj_ids, is_mat_file, data_file, extra) = ca.initial_file_load(filename)
# data set defaults
if fps is None:
fps = result_utils.get_fps(data_file)
if dynamic_model is None:
try:
dyn_model = extra['dynamic_model_name']
except:
dyn_model = 'EKF mamarama, units: mm'
if dynamic_model is not None:
dyn_model = dynamic_model
# if kalman smoothing is on, then we cannot use the EKF model - remove that from the model name
print '**Kalman Smoothing is: ', kalman_smoothing, ' **'
if kalman_smoothing is True:
dyn_model = dyn_model[4:]
print 'using dynamic model: ', dyn_model
if objs is None and obj_filelist is None:
print "running through all object id's, this might take a while..."
obj_only = use_obj_ids # this is all the unique object id's
if obj_filelist is not None:
tmp = np.loadtxt(obj_filelist,delimiter=',')
obj_only = np.array(tmp[:,0], dtype='int')
elif objs is not None:
obj_only = np.array(objs)
print 'loading data.... '
for obj_id in obj_only:
try:
kalman_rows = ca.load_data( obj_id, data_file,
dynamic_model_name = dyn_model,
use_kalman_smoothing= kalman_smoothing,
frames_per_second= fps)
except:
print 'object id failed to load (probably no data): ', obj_id
continue
# couple object ID dictionary with trajectory objects
traj_id = (str(self.datasets[-1])+'_'+str(obj_id))
self.trajecs.setdefault(traj_id, ffa.Trajectory(kalman_rows, extra, stimulus = self.stimulus, fps = fps) )
def load_data (self, filename, calibration_file = None, objs = None, obj_filelist = None, kalman_smoothing = True, fps = None, dynamic_model = None, gender = None, post_type=None):
self.datasets.append(len(self.datasets)+1)
self.filename.append(filename)
if calibration_file is not None:
print "Calibration Files not yet supported!!!"
# set up analyzer
ca = core_analysis.get_global_CachingAnalyzer()
(obj_ids, use_obj_ids, is_mat_file, data_file, extra) = ca.initial_file_load(filename)
# data set defaults
if fps is None:
fps = result_utils.get_fps(data_file)
if dynamic_model is None:
try:
dyn_model = extra['dynamic_model_name']
except:
dyn_model = 'EKF mamarama, units: mm'
if dynamic_model is not None:
dyn_model = dynamic_model
# if kalman smoothing is on, then we cannot use the EKF model - remove that from the model name
print '**Kalman Smoothing is: ', kalman_smoothing, ' **'
if kalman_smoothing is True:
dyn_model = dyn_model[4:]
print 'using dynamic model: ', dyn_model
if objs is None and obj_filelist is None:
print "running through all object id's, this might take a while..."
obj_only = use_obj_ids # this is all the unique object id's
if obj_filelist is not None:
tmp = np.loadtxt(obj_filelist,delimiter=',')
obj_only = np.array(tmp[:,0], dtype='int')
elif objs is not None:
if type(objs) is not list:
objs = [objs]
obj_only = np.array(objs)
print fps
print 'loading data.... '
for obj_id in obj_only:
print 'processing: ', obj_id
try:
print obj_id
# kalman rows = [
kalman_rows = ca.load_data( obj_id, data_file,
dynamic_model_name = dyn_model,
use_kalman_smoothing= kalman_smoothing,
frames_per_second= fps)
except:
print 'object id failed to load (probably no data): ', obj_id
continue
#print kalman_rows[0]
# couple object ID dictionary with trajectory objects
traj_id = (str(self.datasets[-1])+'_'+str(obj_id))
self.trajecs.setdefault(traj_id, Trajectory(kalman_rows, extra, stimulus = self.stimulus, fps = fps, post_type=post_type) )
