def camera_capture(file_name):
cap = cv2.VideoCapture(0)
width = int(cap.get(
cv2.CAP_PROP_FRAME_WIDTH)) # get video frames width and height
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = 30.0
size = (width, height)
#Define the codec and create VideoWriter object
fourcc = cv2.FOURCC(*'XVID')
out = cv2.VideoWriter("%s.avi" % file_name, fourcc, fps, size)
while (cap.isOpened()):
#Capture frame by frame
ret, frame = cap.read()
if ret != True:
break
out.write(frame)
#Display the resulting frame
cv2.imshow('frame', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
out.release()
try:
os.remove("%s.mp4" % file_name)
except:
pass
os.rename("%s.avi" % file_name, "%s.mp4" % file_name)
cv2.destroyAllWindows()
def make_video_from_frames(out_vid_path, frames):
if frames[0] is not None:
h, w = frames[0].shape[:2]
fourcc = cv2.FOURCC('m', 'p', '4', 'v')
out = cv2.VideoWriter(out_vid_path,fourcc, 20.0, (w, h), True)
print("Start Making File Video:%s " % out_vid_path)
print("%d Frames to Compress"%len(frames))
progress = progressbar.ProgressBar(widgets=[progressbar.Bar('=', '[', ']'), ' ',progressbar.Percentage(), ' ',progressbar.ETA()])
for i in progress(range(0,len(frames))):
out.write(frames[i])
out.release()
print("Finished Making File Video:%s " % out_vid_path)
def download_and_process_video(save_path, row):
video_id = row['VideoID']
video_path = row['video_path']
full_path = os.path.join(save_path, video_path)
if os.path.exists(full_path):
return
start = row['Start']
end = row['End']
print("Downloading", "http://youtube.com/watch?v=" + video_id)
if os.path.exists('tmp.mp4'):
os.system('rm -f tmp.*')
subprocess.run(
"youtube-dl \'https://www.youtube.com/watch?v=" + video_id +
"' -f \'best[height=360]\' --output 'videos/%(id)s.%(ext)s'",
stdout=subprocess.PIPE)
return
# try: # 다운로드 포기
# youtube = YouTube("http://youtube.com/watch?v="+video_id).stream.filter(subtype='mp4',res='360p').first().download(filename="tmp.mp4")
# except Exception as e:
# print(e)
# return
#ydl_opts = {'outtmpl': 'tmp.%(ext)s','format': 'best[height=360]','postprocessors': [{
# 'key': 'FFmpegVideoConvertor',
# 'preferedformat': 'mp4', # one of avi, flv, mkv,mp4, ogg, webm
# '--strict':'2'
# }]}
#with YoutubeDL(ydl_opts) as ydl:
# ydl.download(["http://youtube.com/watch?v="+video_id])
cap = cv2.VideoCapture('tmp.mp4')
fps = cap.get(cv2.CAP_PROP_FPS)
fourcc = int(cap.get(cv2.FOURCC(*'XVID')))
w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
out = cv2.VideoWriter(full_path, fourcc, fps, (w, h))
start_frame = int(fps * start)
end_frame = int(fps * end)
frame_count = 0
while frame_count < end_frame:
ret, frame = cap.read()
frame_count += 1
if frame_count >= start_frame:
out.write(frame)
cap.release()
out.release()
def save(self,
file_name,
to32=True,
order='F',
imagej=False,
bigtiff=True,
excitation_lambda=488.0,
compress=0,
q_max=99.75,
q_min=1,
var_name_hdf5='mov',
sess_desc='some_description',
identifier='some identifier',
imaging_plane_description='some imaging plane description',
emission_lambda=520.0,
indicator='OGB-1',
location='brain',
starting_time=0.,
experimenter='Dr Who',
lab_name=None,
institution=None,
experiment_description='Experiment Description',
session_id='Session ID'):
"""
Save the timeseries in single precision. Supported formats include
TIFF, NPZ, AVI, MAT, HDF5/H5, MMAP, and NWB
Args:
file_name: str
name of file. Possible formats are tif, avi, npz, mmap and hdf5
to32: Bool
whether to transform to 32 bits
order: 'F' or 'C'
C or Fortran order
var_name_hdf5: str
Name of hdf5 file subdirectory
q_max, q_min: float in [0, 100]
percentile for maximum/minimum clipping value if saving as avi
(If set to None, no automatic scaling to the dynamic range [0, 255] is performed)
Raises:
Exception 'Extension Unknown'
"""
name, extension = os.path.splitext(file_name)[:2]
extension = extension.lower()
logging.debug("Parsing extension " + str(extension))
if extension in ['.tif', '.tiff', '.btf']:
with tifffile.TiffWriter(file_name, bigtiff=bigtiff,
imagej=imagej) as tif:
for i in range(self.shape[0]):
if i % 200 == 0:
logging.debug(str(i) + ' frames saved')
curfr = self[i].copy()
if to32 and not ('float32' in str(self.dtype)):
curfr = curfr.astype(np.float32)
tif.save(curfr, compress=compress)
elif extension == '.npz':
if to32 and not ('float32' in str(self.dtype)):
input_arr = self.astype(np.float32)
else:
input_arr = np.array(self)
np.savez(file_name,
input_arr=input_arr,
start_time=self.start_time,
fr=self.fr,
meta_data=self.meta_data,
file_name=self.file_name)
elif extension == '.avi':
codec = None
try:
codec = cv2.FOURCC('I', 'Y', 'U', 'V')
except AttributeError:
codec = cv2.VideoWriter_fourcc(*'IYUV')
if q_max is None or q_min is None:
data = self.astype(np.uint8)
else:
if q_max < 100:
maxmov = np.nanpercentile(self[::max(1,
len(self) // 100)],
q_max)
else:
maxmov = np.nanmax(self)
if q_min > 0:
minmov = np.nanpercentile(self[::max(1,
len(self) // 100)],
q_min)
else:
minmov = np.nanmin(self)
data = 255 * (self - minmov) / (maxmov - minmov)
np.clip(data, 0, 255, data)
data = data.astype(np.uint8)
y, x = data[0].shape
vw = cv2.VideoWriter(file_name,
codec,
self.fr, (x, y),
isColor=True)
for d in data:
vw.write(cv2.cvtColor(d, cv2.COLOR_GRAY2BGR))
vw.release()
elif extension == '.mat':
if self.file_name[0] is not None:
f_name = self.file_name
else:
f_name = ''
if to32 and not ('float32' in str(self.dtype)):
input_arr = self.astype(np.float32)
else:
input_arr = np.array(self)
if self.meta_data[0] is None:
savemat(
file_name, {
'input_arr': np.rollaxis(input_arr, axis=0, start=3),
'start_time': self.start_time,
'fr': self.fr,
'meta_data': [],
'file_name': f_name
})
else:
savemat(
file_name, {
'input_arr': np.rollaxis(input_arr, axis=0, start=3),
'start_time': self.start_time,
'fr': self.fr,
'meta_data': self.meta_data,
'file_name': f_name
})
elif extension in ('.hdf5', '.h5'):
with h5py.File(file_name, "w") as f:
if to32 and not ('float32' in str(self.dtype)):
input_arr = self.astype(np.float32)
else:
input_arr = np.array(self)
dset = f.create_dataset(var_name_hdf5, data=input_arr)
dset.attrs["fr"] = self.fr
dset.attrs["start_time"] = self.start_time
try:
dset.attrs["file_name"] = [
a.encode('utf8') for a in self.file_name
]
except:
logging.warning('No file saved')
if self.meta_data[0] is not None:
logging.debug("Metadata for saved file: " +
str(self.meta_data))
dset.attrs["meta_data"] = cpk.dumps(self.meta_data)
elif extension == '.mmap':
base_name = name
T = self.shape[0]
dims = self.shape[1:]
if to32 and not ('float32' in str(self.dtype)):
input_arr = self.astype(np.float32)
else:
input_arr = np.array(self)
input_arr = np.transpose(input_arr,
list(range(1,
len(dims) + 1)) + [0])
input_arr = np.reshape(input_arr, (np.prod(dims), T), order='F')
fname_tot = memmap_frames_filename(base_name, dims, T, order)
fname_tot = os.path.join(os.path.split(file_name)[0], fname_tot)
big_mov = np.memmap(fname_tot,
mode='w+',
dtype=np.float32,
shape=(np.uint64(np.prod(dims)), np.uint64(T)),
order=order)
big_mov[:] = np.asarray(input_arr, dtype=np.float32)
big_mov.flush()
del big_mov, input_arr
return fname_tot
elif extension == '.nwb':
if to32 and not ('float32' in str(self.dtype)):
input_arr = self.astype(np.float32)
else:
input_arr = np.array(self)
# Create NWB file
nwbfile = NWBFile(sess_desc,
identifier,
datetime.now(tzlocal()),
experimenter=experimenter,
lab=lab_name,
institution=institution,
experiment_description=experiment_description,
session_id=session_id)
# Get the device
device = Device('imaging_device')
nwbfile.add_device(device)
# OpticalChannel
optical_channel = OpticalChannel('OpticalChannel',
'main optical channel',
emission_lambda=emission_lambda)
imaging_plane = nwbfile.create_imaging_plane(
name='ImagingPlane',
optical_channel=optical_channel,
description=imaging_plane_description,
device=device,
excitation_lambda=excitation_lambda,
imaging_rate=self.fr,
indicator=indicator,
location=location)
# Images
image_series = TwoPhotonSeries(name=var_name_hdf5,
dimension=self.shape[1:],
data=input_arr,
imaging_plane=imaging_plane,
starting_frame=[0],
starting_time=starting_time,
rate=self.fr)
nwbfile.add_acquisition(image_series)
with NWBHDF5IO(file_name, 'w') as io:
io.write(nwbfile)
return file_name
else:
logging.error("Extension " + str(extension) + " unknown")
raise Exception('Extension Unknown')
def save(self, file_name, to32=True, order='F'):
"""
Save the timeseries in various formats
parameters:
----------
file_name: str
name of file. Possible formats are tif, avi, npz and hdf5
to32: Bool
whether to transform to 32 bits
order: 'F' or 'C'
C or Fortran order
Raise:
-----
raise Exception('Extension Unknown')
"""
name, extension = os.path.splitext(file_name)[:2]
print(extension)
if extension == '.tif': # load avi file
try:
from tifffile import imsave
print('tifffile package not found, using skimage instead for imsave')
except:
from skimage.external.tifffile import imsave
if to32:
np.clip(self, np.percentile(self, 1),
np.percentile(self, 99.99999), self)
minn, maxx = np.min(self), np.max(self)
data = 65536 * (self - minn) / (maxx - minn)
data = data.astype(np.int32)
imsave(file_name, self.astype(np.float32))
else:
imsave(file_name, self)
elif extension == '.npz':
np.savez(file_name, input_arr=self, start_time=self.start_time,
fr=self.fr, meta_data=self.meta_data, file_name=self.file_name)
elif extension == '.avi':
codec = None
try:
codec = cv2.FOURCC('I', 'Y', 'U', 'V')
except AttributeError:
codec = cv2.VideoWriter_fourcc(*'IYUV')
np.clip(self, np.percentile(self, 1),
np.percentile(self, 99), self)
minn, maxx = np.min(self), np.max(self)
data = 255 * (self - minn) / (maxx - minn)
data = data.astype(np.uint8)
y, x = data[0].shape
vw = cv2.VideoWriter(file_name, codec, self.fr,
(x, y), isColor=True)
for d in data:
vw.write(cv2.cvtColor(d, cv2.COLOR_GRAY2BGR))
vw.release()
elif extension == '.mat':
if self.file_name[0] is not None:
f_name = self.file_name
else:
f_name = ''
if self.meta_data[0] is None:
savemat(file_name, {'input_arr': np.rollaxis(
self, axis=0, start=3), 'start_time': self.start_time, 'fr': self.fr, 'meta_data': [], 'file_name': f_name})
else:
savemat(file_name, {'input_arr': np.rollaxis(
self, axis=0, start=3), 'start_time': self.start_time, 'fr': self.fr, 'meta_data': self.meta_data, 'file_name': f_name})
elif extension == '.hdf5':
with h5py.File(file_name, "w") as f:
dset = f.create_dataset("mov", data=np.asarray(self))
dset.attrs["fr"] = self.fr
dset.attrs["start_time"] = self.start_time
try:
dset.attrs["file_name"] = [
a.encode('utf8') for a in self.file_name]
except:
print('No file name saved')
if self.meta_data[0] is not None:
print(self.meta_data)
dset.attrs["meta_data"] = cpk.dumps(self.meta_data)
elif extension == '.mmap':
base_name = name
T = self.shape[0]
dims = self.shape[1:]
Yr = np.transpose(self, list(range(1, len(dims) + 1)) + [0])
Yr = np.reshape(Yr, (np.prod(dims), T), order='F')
fname_tot = base_name + '_d1_' + str(dims[0]) + '_d2_' + str(dims[1]) + '_d3_' + str(
1 if len(dims) == 2 else dims[2]) + '_order_' + str(order) + '_frames_' + str(T) + '_.mmap'
fname_tot = os.path.join(os.path.split(file_name)[0], fname_tot)
big_mov = np.memmap(fname_tot, mode='w+', dtype=np.float32,
shape=(np.prod(dims), T), order=order)
big_mov[:] = np.asarray(Yr, dtype=np.float32)
big_mov.flush()
del big_mov
return fname_tot
else:
print(extension)
raise Exception('Extension Unknown')
def save(self, file_name, to32=True, order='F',imagej=False, bigtiff=True, software='CaImAn', compress=0):
"""
Save the timeseries in various formats
Args:
file_name: str
name of file. Possible formats are tif, avi, npz, mmap and hdf5
to32: Bool
whether to transform to 32 bits
order: 'F' or 'C'
C or Fortran order
Raises:
Exception 'Extension Unknown'
"""
name, extension = os.path.splitext(file_name)[:2]
extension = extension.lower()
logging.debug("Parsing extension " + str(extension))
if extension == '.tif': # load avi file
with tifffile.TiffWriter(file_name, bigtiff=bigtiff, imagej=imagej) as tif:
for i in range(self.shape[0]):
if i % 200 == 0:
logging.debug(str(i) + ' frames saved')
curfr = self[i].copy()
if to32 and not('float32' in str(self.dtype)):
curfr = curfr.astype(np.float32)
tif.save(curfr, compress=compress)
elif extension == '.npz':
if to32 and not('float32' in str(self.dtype)):
input_arr = self.astype(np.float32)
else:
input_arr = np.array(self)
np.savez(file_name, input_arr=input_arr, start_time=self.start_time,
fr=self.fr, meta_data=self.meta_data, file_name=self.file_name)
elif extension == '.avi':
codec = None
try:
codec = cv2.FOURCC('I', 'Y', 'U', 'V')
except AttributeError:
codec = cv2.VideoWriter_fourcc(*'IYUV')
np.clip(self, np.percentile(self, 1),
np.percentile(self, 99), self)
minn, maxx = np.min(self), np.max(self)
data = 255 * (self - minn) / (maxx - minn)
data = data.astype(np.uint8)
y, x = data[0].shape
vw = cv2.VideoWriter(file_name, codec, self.fr,
(x, y), isColor=True)
for d in data:
vw.write(cv2.cvtColor(d, cv2.COLOR_GRAY2BGR))
vw.release()
elif extension == '.mat':
if self.file_name[0] is not None:
f_name = self.file_name
else:
f_name = ''
if to32 and not('float32' in str(self.dtype)):
input_arr = self.astype(np.float32)
else:
input_arr = np.array(self)
if self.meta_data[0] is None:
savemat(file_name, {'input_arr': np.rollaxis(
input_arr, axis=0, start=3), 'start_time': self.start_time, 'fr': self.fr, 'meta_data': [], 'file_name': f_name})
else:
savemat(file_name, {'input_arr': np.rollaxis(
input_arr, axis=0, start=3), 'start_time': self.start_time, 'fr': self.fr, 'meta_data': self.meta_data, 'file_name': f_name})
elif extension in ('.hdf5', '.h5'):
with h5py.File(file_name, "w") as f:
if to32 and not('float32' in str(self.dtype)):
input_arr = self.astype(np.float32)
else:
input_arr = np.array(self)
dset = f.create_dataset("mov", data=input_arr)
dset.attrs["fr"] = self.fr
dset.attrs["start_time"] = self.start_time
try:
dset.attrs["file_name"] = [
a.encode('utf8') for a in self.file_name]
except:
logging.warning('No file saved')
if self.meta_data[0] is not None:
logging.debug("Metadata for saved file: " + str(self.meta_data))
dset.attrs["meta_data"] = cpk.dumps(self.meta_data)
elif extension == '.mmap':
base_name = name
T = self.shape[0]
dims = self.shape[1:]
if to32 and not('float32' in str(self.dtype)):
input_arr = self.astype(np.float32)
else:
input_arr = np.array(self)
input_arr = np.transpose(input_arr, list(range(1, len(dims) + 1)) + [0])
input_arr = np.reshape(input_arr, (np.prod(dims), T), order='F')
fname_tot = base_name + '_d1_' + str(dims[0]) + '_d2_' + str(dims[1]) + '_d3_' + str(
1 if len(dims) == 2 else dims[2]) + '_order_' + str(order) + '_frames_' + str(T) + '_.mmap'
fname_tot = os.path.join(os.path.split(file_name)[0], fname_tot)
big_mov = np.memmap(fname_tot, mode='w+', dtype=np.float32,
shape=(np.uint64(np.prod(dims)), np.uint64(T)), order=order)
big_mov[:] = np.asarray(input_arr, dtype=np.float32)
big_mov.flush()
del big_mov, input_arr
return fname_tot
else:
logging.error("Extension " + str(extension) + " unknown")
raise Exception('Extension Unknown')
input_dir = sys.argv[1]
output_dir = sys.argv[2]
if output_dir.endswith('/'):
output_dir = output_dir[:-1]
i = 0
total = 0
for root, dirs, files in os.walk(input_dir):
videos = filter(lambda x: x.lower().endswith('.avi') or x.lower().endswith('.mp4'), files)
total += len( videos)
if cv2.__version__[0] == '2':
fourcc = cv2.cv.CV_FOURCC(*'HFYU') # Huffman lossless
else:
fourcc = cv2.FOURCC(*'HFYU')
for root, dirs, files in os.walk(input_dir):
videos = filter(lambda x: x.lower().endswith('.avi') or x.lower().endswith('.mp4'), files)
if len(videos) > 0:
videos = sorted(videos)
for j, video in enumerate(videos):
in_file = join(root, video)
out_file = join(root.replace(input_dir, output_dir, 1), video)
out_dir = os.path.dirname(out_file)
print "(%d/%d) Generating to %s" % (i+j+1, total, out_file)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
threshold = MSE_THRESHOLD
while True:
wid = int(img.shape[1]) #3
hei = int(img.shape[0]) #4
total_size = len(input_files)
else:
try:
param_input = int(param_input)
cap = cv2.VideoCapture(param_input)
except ValueError:
cap = cv2.VideoCapture(param_input)
int(cap.get(cv2.CAP_PROP_FPS))
pass
wid = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) #3
hei = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) #4
if args.output and not args.folders:
fourcc = cv2.FOURCC(*'MPEG')
wrt = cv2.VideoWriter(param_output,fourcc,fps,(wid,hei))
if args.delay:
delay=100
output = np.zeros(shape=(hei,wid), dtype=np.uint8)
thresh = np.zeros(shape=(hei,wid,3), dtype=np.float32)
cf1 = np.zeros(shape=(hei,wid), dtype=np.uint8)
cf2 = np.zeros(shape=(hei,wid), dtype=np.uint8)
cf3 = np.zeros(shape=(hei,wid), dtype=np.uint8)
f1 = np.zeros(shape=(hei,wid), dtype=np.uint8)
f2 = np.zeros(shape=(hei,wid), dtype=np.uint8)
f3 = np.zeros(shape=(hei,wid), dtype=np.uint8)
