def from_args(cls, cine_fname, h5_fname=None, *args, **kwargs):
self = cls()
'''Sets up the object based on arguments
'''
cls._verify_params(kwargs)
self.params = kwargs
try:
self.bck_img = self.params.pop('bck_img')
except KeyError:
self.bck_img = None
self.cine_fname = cine_fname
self.cine_ = cine.Cine('/'.join(self.cine_fname))
if self.bck_img is None:
# not passed in, try the data base
if self.db is not None:
self.bck_img = self.db.get_background_img(self.cine_.hash)
# if that fails too, run it
if self.bck_img is None:
self.bck_img = infra.gen_bck_img('/'.join(self.cine_fname))
# if we have a data base, shove in the data
if self.db is not None:
self.db.store_background_img(self.cine_.hash, self.bck_img)
return self
def from_hdf_file(cls, cine_base_path, h5_fname):
''' Sets up object to process data based on MD in an hdf file.
'''
self = cls()
tmp_file = h5py.File('/'.join(h5_fname), 'r')
keys_lst = list(tmp_file.attrs.keys())
lc_req_args = ['tck0', 'tck1', 'tck2']
h5_req_args = ['cine_path', 'cine_fname']
cls._verify_params(keys_lst, extra_req=(lc_req_args + h5_req_args))
self.params = dict(tmp_file.attrs)
for k in lc_req_args:
del self.params[k]
self.cine_fname = FilePath(cine_base_path,
self.params.pop('cine_path'),
self.params.pop('cine_fname'))
self.cine_ = cine.Cine('/'.join(self.cine_fname))
if 'bck_img' in list(tmp_file.keys()):
self.bck_img = tmp_file['bck_img'][:]
else:
self.bck_img = infra.gen_bck_img('/'.join(self.cine_fname))
seed_curve = infra.SplineCurve.from_hdf(tmp_file)
tmp_file.close()
return self, seed_curve
def make_frames(root_dir, video_path, fn_for_movie='video.mp4', color_by='phase', cmap='isolum_rainbow'):
save_directory = os.path.join(root_dir, 'movie_frames_' + color_by + '_' + cmap)
mod_list = [16, 8, 4, 2, 1]
if not os.path.exists(save_directory):
os.mkdir(save_directory)
try:
c = cine.Cine(video_path)
except:
c = []
path = os.path.join(root_dir, 'com_data.hdf5')
data = h5py.File(path, 'r')
keys = data.keys()
length = len(data['times'])
neighborhood = 75
for j in xrange(len(mod_list)):
avg_x = []
avg_y = []
for i in xrange(length):
frame_name = os.path.join(save_directory, '%05d.png' % i)
if i % mod_list[j] == 0 and not (os.path.isfile(frame_name)):
if True:
if i < neighborhood:
lb = 0
else:
lb = i - neighborhood
if length - 5 < i + neighborhood:
ub = length - 5
else:
ub = i + neighborhood
xs, ys = get_average_positions(data, keys, range=[lb, ub])
avg_x.append(xs)
avg_y.append(ys)
time, pts = get_frame_points_and_time(data, keys, i)
if len(c) > 0:
frame = c[i].astype('f')
else:
frame = np.zeros((600, 600))
plot_on_frame(frame, time, pts, np.array([xs, ys]).T, save_name=frame_name, plotting_mag=5,
color_by=color_by, cmap=cmap)
if mod_list[j] == 1 and i >= length - 2:
call(["ffmpeg", "-r", "50", "-start_number", str(0), "-i", save_directory + "/%05d.png", "-f", "mp4",
save_directory + "h264", "-pix_fmt", "yuv420p", os.path.join(save_directory, fn_for_movie)])
def __init__(self, input_file, frame_rate=40.):
# first determine the file type (cine, tiff, png, etc)
self.file_type = input_file.split('.')[-1]
if self.file_type == 'cine':
self.cine = True
self.data = cine.Cine(input_file)
self.num_frames = len(self.data)
else:
self.cine = False
file_names = thf.find_files_by_extension(input_file,
'.png',
tot=True)
data = []
for i in xrange(20):
file = file_names[i]
data_single = mpimg.imread(file)
data_single = self.rgb2gray(data_single)
data_single = data_single[:, 100:1400]
data.append(data_single)
print np.shape(data_single)
print file
self.data = data
self.num_frames = len(self.data)
# print 'data = ', self.data
# print 'type(data) = ', type(self.data)
# print 'data[0] = ', self.data[0]
# print 'type(data[0]) = ', type(self.data[0])
# sys.exit()
self._mean_value = 0
self.min_radius = 17
self.max_radius = 22
self.min_dist = 20
self._min_value = 0.05
self._max_value = 0.7
self._pix = 6
self._centroid_clipmin = 0.0
self._centroid_clipmax = 1.0
self.current_frame = []
self.previous_frame = None
self.average_frame = None
self.variance_frame = None
self.normfactor_frame = None
self.maxdiff_frame = None
self.roi = None
self.frame_current_points = []
self.reference_points = None
self.reference_mask = None
self.ref_masks = []
self.circles = []
self.current_time = 0
self.frame_rate = frame_rate
self._adjust_min_max_val()
self._set_dummy_frame()
def gen_bck_img(fname):
'''Computes the background image'''
c_test = cine.Cine(fname)
bck_img = reduce(lambda x, y: x + y, c_test,
np.zeros(c_test.get_frame(0).shape))
print(c_test.len())
bck_img /= c_test.len()
# hack to deal with
bck_img[bck_img == 0] = .001
return bck_img
def get_cine_hashes(base_path, search_path):
'''returs all paths and cine hash values under the search path'''
cine_fnames = []
for dirpath, dirnames, fnames in os.walk(base_path + '/' + search_path):
cine_fnames.extend([
FilePath(base_path, dirpath[len(base_path) + 1:], f)
for f in fnames if 'cine' in f
])
cine_fnames.sort(key=lambda x: x[-1])
cine_hash = [cine.Cine(cn.format).hash for cn in cine_fnames]
return list(zip(cine_fnames, cine_hash))
def disp_frame(fname, n, bck_img=None):
'''Displays a given frame from the file'''
c_test = cine.Cine(fname)
lfimg = c_test.get_frame(n)
if bck_img is None:
bck_img = np.ones(lfimg.shape)
fig = plt.figure()
ax = fig.add_axes([.1, .1, .8, .8])
im = ax.imshow(lfimg / bck_img)
im.set_clim([.5, 1.5])
ax.set_title(n)
plt.draw()
def setup_spline_fitter(fname, bck_img=None):
''' gets the initial path '''
clims = [.5, 1.5]
# open the first frame and find the initial circle
c_test = cine.Cine(fname)
lfimg = c_test.get_frame(0)
if bck_img is None:
bck_img = np.ones(lfimg.shape)
clims = None
fig = plt.figure()
ax = fig.add_axes([.1, .1, .8, .8])
im = ax.imshow(lfimg / bck_img, cmap='cubehelix')
if clims is not None:
im.set_clim(clims)
ef = spline_fitter(ax)
plt.draw()
return ef
def update_average_cache(base_path):
cine_fnames = []
for dirpath, dirnames, fnames in os.walk(base_path + '/' + 'leidenfrost'):
cine_fnames.extend([
FilePath(base_path, dirpath[len(base_path) + 1:], f)
for f in fnames if 'cine' in f
])
db = ldb.LFmongodb()
for cn in cine_fnames:
if 'cine' not in cn[-1]:
continue
cine_hash = cine.Cine(cn.format).hash
bck_img = db.get_background_img(cine_hash)
if bck_img is None:
bck_img = gen_bck_img(cn.format)
db.store_background_img(cine_hash, bck_img)
def play_movie(fname, bck_img=None):
'''plays the movie with correction'''
def update_img(num, F, bck_img, im, txt):
im.set_data(F.get_frame(num) / bck_img)
txt.set_text(str(num))
F = cine.Cine(fname)
if bck_img is None:
bck_img = np.ones(F.get_frame(0).shape)
fig = plt.figure()
ax = fig.add_subplot(111)
im = ax.imshow(F.get_frame(0) / bck_img)
fr_num = ax.text(0.05, 0.05, 0, transform=ax.transAxes)
im.set_clim([.75, 1.25])
prof_ani = animation.FuncAnimation(fig,
update_img,
len(F),
fargs=(F, bck_img, im, fr_num),
interval=50)
plt.show()
return prof_ani
dest='background_amplitude',
type=float,
default=0.22,
help=
'fraction of max laser brightness that is background instead of gaussian peak; set to 1 for no brightness correction, 0 for fitting to a straight gaussian [default: 0.22 != 0 because of spherical-aberation/best fit]'
)
args = parser.parse_args()
for fn in args.input:
base, ext = os.path.splitext(fn)
if ext.lower().startswith('.tif'):
sys.setrecursionlimit(10**5)
source = cine.Tiff(fn)
else:
source = cine.Cine(fn)
try:
args.real_bpp = source.real_bpp
except:
args.real_bpp = soure[0].dtype.itemsize * 8
max_frame = (len(source) - args.skip) // args.depth
saved_frames = eval_slice(args.range, max_frame)
print '%s (%d frames):' % (fn, len(saved_frames))
frame_offsets = array(eval_slice(args.displayframes, args.depth))
if args.threads == 1:
results = []
"frames per volume (depth) must either be specified with '-d' or part of the file name (e.g.: 'XXX_100fpv_YYY')"
)
else:
frames_per_volume = args.depth
#print frames_per_volume
#display_range = slice(*[if_int(x) for x in args.displayframes.split(':')])
#DATA = Image4D(args.input, args.depth, brighten=args.brightness, clip=args.clip, series=args.series, offset=args.offset, display_range=display_range)
#output = args.output if args.output else os.path.splitext(args.input)[0] + '.s4d'
if ext.lower().startswith('.tif'):
sys.setrecursionlimit(10**5)
source = cine.Tiff(input)
else:
source = cine.Cine(input)
max_frame = (len(source) - args.skip) // frames_per_volume
saved_frames = eval_slice(args.range, max_frame)
print '%30s -> %-30s (%d frames)...' % (input, output,
len(saved_frames))
sys.stdout.flush()
#continue
output = Sparse4D(
output, 'w', {
'source': input,
'frames per volume': frames_per_volume,
'min clip': args.min_val,
def convert_file(ifn, ofn=None, clip=0, max_frame=None, overwrite=False):
if ofn is None:
ofn = os.path.splitext(ifn)[0] + '.sparse'
if not overwrite and os.path.exists(ofn):
print "%s exists... skipping. (use --overwrite to override)" % ofn
return
c = cine.Cine(ifn)
header = {}
for key, t in all_fields:
val = getattr(c, key)
if type(val) == str and '\x00' in val: val = val[:val.index('\x00')]
#print '%20s: %s' % (key, repr(val))
header[key] = repr(val)
header['original'] = ifn
header['clip'] = str(clip)
if (not max_frame) or (max_frame > len(c)): max_frame = len(c)
p = -1
ifp, ifnn = os.path.split(ifn)
ofp, ofnn = os.path.split(ofn)
max_len = 70
print ifn
print ' -> ' + ofn
# msg = ' --> %s' %(ofn if ofp != ifp else ofnn)
# if len(msg) > max_len: msg = msg[:max_len-3] + '...'
# print msg,
# sys.stdout.flush()
s = cine.Sparse(ofn, 'w', header, max_blocks=max_frame)
max_val = iinfo(c[0].dtype).max
gtot = 0
ctot = 0
stot = 0
for i in range(max_frame):
st = time.time()
f = c[i]
gtot += (time.time() - st)
st = time.time()
f = nclip(f, clip, max_val) - clip
ctot += (time.time() - st)
st = time.time()
s.append_array(f)
stot += (time.time() - st)
pn = i * 100 // max_frame
if pn != p:
print '\r %3d%% (load:%6d s, clip:%6d s, save:%6d s)' % (pn, gtot, ctot, stot),
sys.stdout.flush()
#print gtot, ctot, stot
p = pn
print '\r done. (load:%6d s, clip:%6d s, save:%6d s)' % (gtot, ctot, stot)
s.close()
def __init__(self,
fname,
cine_base_path=None,
mode='r',
i_disk_dict=None,
*args,
**kwargs):
"""
Parameters
----------
fname: `Leidenfrost.FilePath`
Fully qualified path to the hdf file to open
cine_base_path: str or `None`
If not `None`, base path to find the raw cine files
h5_buffer_bas_path: str or `None`
If not `None`, base path for buffering the h5 file
cine_buffer_base_path: str or `None`
If not `None`, base path for buffering the cine file
"""
self._iter_cur_item = -1
self.file = None
if mode == 'rw':
self.file = h5py.File(fname.format, 'r+')
self.writeable = True
else:
self.file = h5py.File(fname.format, 'r')
self.writeable = False
self.num_frames = len([k for k in self.file.keys() if 'frame' in k])
self._prams = HdfBEPram(False, True)
self.proc_prams = dict(self.file.attrs)
if cine_base_path is not None:
self.cine_fname = FilePath(cine_base_path,
self.file.attrs['cine_path'],
self.file.attrs['cine_fname'])
self.cine = cine.Cine('/'.join(self.cine_fname))
else:
self.cine_fname = None
self.cine = None
try:
# hard code the mongodb
self.db = db.LFmongodb(i_disk_dict=i_disk_dict)
except:
print('gave up and the DB')
# this eats _ALL_ exceptions
self.db = None
self._procid = None
if self.db is not None:
self._procid = self.db.get_proc_id(fname)
self.bck_img = None
if self.db is not None and self.cine is not None:
self.bck_img = self.db.get_background_img(self.cine.hash)
# if that fails too, run it
if self.bck_img is None and self.cine is not None:
self.gen_back_img()
# if we have a data base, shove in the data
if self.db is not None and self.bck_img is not None:
self.db.store_background_img(self.cine.hash, self.bck_img)
if 'ver' not in self.file.attrs or self.file.attrs['ver'] < b'0.1.5':
self._frame_str = 'frame_{:05d}'
else:
self._frame_str = 'frame_{:07d}'
self._cal_val = None
self._cal_val_unit = None
self._first_frame = None
self._last_frame = None
except:
print(' !! no .3dsetup file, either specify with -s or place in source directory')
continue
else:
setupfile = args.setup
setup_str = open(setupfile, 'rt').read()
setup = eval_vals(setup_str)
for rf in __REQUIRED_FIELDS:
if rf not in setup:
print("ERROR: field '%s' missing from setup file! (%s)" % (rf, setupfile))
sys.exit()
if ee == '.cine':
input = cine.Cine(fn)
bit_depth = input.real_bpp
bottom_clip = setup['bottom_clip']
u1_top = setup['u1_top']
else:
input = cine.Sparse(fn)
bit_depth = try_eval(input.header['real_bpp'])
bottom_clip = 0
u1_top = setup['u1_top'] - try_eval(input.header.get('clip', 0)) #Clip was already applied in sparsing
num_frames = len(input) // setup['cine_depth']
test_frame = input[0]
header = {'original_bitdepth':bit_depth, 'original_file':fn, 'bottom_clip':bottom_clip, '3dsetup':setup_str, 'use_3dsetup_perspective':True, 'dtype':args.type, 'frame size': test_frame.shape}
#print header
def __init__(self, cine_fname=None, bck_img=None):
self.back_img = bck_img
self.cine_fname = cine_fname
self.cine = cine.Cine(cine_fname)
self.frames = {}
pass
def track_and_save(fn, vid_dirs, img_ker_string):
'tracking...'
start_time = time.time()
img_ker = mpimg.imread(img_ker_string)
c = cine.Cine(fn)
tot_frames = len(c)
com_data = []
gamma = 2.2
ff = 0
lf = tot_frames
lf = int(lf)
ff = int(ff)
rd_s = '/Volumes/labshared3/Lisa'
output_dir_i = fn.split('.')[0]
output_dir_i2 = output_dir_i.split('/')
output_dir = rd_s + '/' + time.strftime("%Y_%m_%d") + '_video_tracks_'
if not os.path.exists(output_dir): os.mkdir(output_dir)
output_dir = rd_s + '/' + time.strftime(
"%Y_%m_%d"
) + '_video_tracks_' + '/' + vid_dirs + '_' + output_dir_i2[-1] + '/'
if not os.path.exists(output_dir): os.mkdir(output_dir)
com_data = []
tot_frames = lf
val = 0.8 * max(c[ff].astype(float).flatten())
points = zeros([tot_frames - ff, 2], dtype='f')
for i in range(tot_frames - ff):
if i == 0:
minval = .04 * val
maxval = 0.13 * val
else:
minval = 0.04 * val
maxval = 0.13 * val
frame = (clip(c[ff + i].astype('f'), minval, maxval) -
minval) / (maxval - minval)
if i == 0:
cine.asimage(frame).save(output_dir + 'original.png')
print 'saved original', output_dir
fr = ndimage.convolve(frame, img_ker, mode='reflect', cval=0.0)
minval = 0. * max(fr.flatten())
maxval = 1 * max(fr.flatten())
fr = (clip(fr, minval, maxval) - minval) / (maxval - minval)
points = find_track(fr, frame, output_dir)
pix = 7
fig = plt.figure()
img = Image.open(output_dir + 'original.png')
img = array(img)
for j in range(len(points)):
img[points[j, 1] - pix:points[j, 1] + pix,
points[j, 0] - pix:points[j, 0] + pix] = array(
ImageOps.invert(
Image.fromarray(
np.uint8(img[points[j, 1] - pix:points[j, 1] +
pix, points[j, 0] -
pix:points[j, 0] + pix]))))
plt.imshow(img, cmap=cm.Greys_r)
plt.savefig(output_dir + 'tracked_areas.png')
points = track_points(frame.astype('f'), points, pix, i,
tot_frames - ff, output_dir).astype(float)
t = array([[ff + i, points[j, 0], points[j, 1]]
for j in range(len(points))])
com_data.append(t)
com_data = array(com_data)
sh1, sh2, sh3 = shape(com_data)
com_data = com_data.flatten()
com_data = reshape(com_data, [sh1 * sh2, 3])
num_times = len(com_data[::, 0])
for i in range(num_times):
com_data[i, 0] = c.get_time(int(com_data[i, 0]))
dump_pickled_data(output_dir, 'com_data', com_data)
c.close()
end_time = time.time()
total_time = end_time - start_time
print 'tracked ', tot_frames, 'frames in', total_time, 'seconds'
return com_data, output_dir
