def train():
videofile_path = ['videos/ostrich.mp4'
] #Enter a folder OR a list of videos to analyze.
if not os.path.isfile(videofile_path[0]):
sys.exit("File {} not found!!".format(videofile_path[0]))
path_config_file = '/home/braincreator/Pose_estimation/DeepLabCut/examples/ostrich/Testing-Shan-2019-08-07/config.yaml'
print("\n" + "=" * 80 + "\n\t\t\t\tTRAINING\n" + "=" * 80)
print("\nCreating Training dataset from labeled frames...\n")
deeplabcut.create_training_dataset(path_config_file)
print("\nDataset created, Next stop Training!\n\n")
deeplabcut.train_network(path_config_file,
shuffle=1,
saveiters=2000,
displayiters=500,
gputouse=None,
maxiters=50000)
print("\nEvauating network:\n" + "=" * 50)
deeplabcut.evaluate_network(path_config_file, plotting=True)
print("\n" + "=" * 80 + "\n\t\t\t\tANALYZE\n" + "=" * 80)
deeplabcut.analyze_videos(path_config_file,
videofile_path,
gputouse=None,
videotype='.mp4')
print("\n" + "=" * 80 + "\n\t\t\t\tCreating video\n" + "=" * 80)
deeplabcut.create_labeled_video(path_config_file,
videofile_path,
outputframerate=5,
draw_skeleton=True)
def analyze_videos_CLARA(config_path, v, crp):
import deeplabcut
deeplabcut.analyze_videos(config_path,
v,
videotype='.mp4',
save_as_csv=True,
cropping=crp)
def train_dlc(path):
os.chdir(path)
folders = [name for name in os.listdir(path) if os.path.isdir(name) and name[0].isdigit()]
num_folder = len(folders)
for i in range(len(folders)):
start = time()
if os.path.exists(r"%s\%s\labeled-data"%(path, folders[i])) and os.path.exists(r"%s\%s\config.yaml"%(path, folders[i])) \
and os.path.exists(r"%s\%s\dlc-models\iteration-0"%(path, folders[i])) == False and get_size(r"%s\%s\labeled-data"%(path, folders[i])) > 0:
path_config_file = r"%s\%s\config.yaml" %(path, folders[i])
deeplabcut.check_labels(path_config_file)
deeplabcut.create_training_dataset(path_config_file)
deeplabcut.train_network(path_config_file, shuffle = 1, autotune = True, displayiters = 5000, saveiters = 5000, maxiters = 200000)
deeplabcut.analyze_videos(path_config_file, r"%s\%s\videos"%(path, folders[i]), videotype = '.mp4', save_as_csv = True)
print("%s training has been done, %s left"%(folders[i], num_folder - i))
elif os.path.exists(r"%s\%s\dlc-models\iteration-0"%(path, folders[i])):
path_config_file = r"%s\%s\config.yaml" %(path, folders[i])
print("%s model has been trained, do you want to retrain it? y/n"%(folders[i]))
feedback = input()
if feedback == "y":
deeplabcut.train_network(path_config_file, shuffle = 1, autotune = True, displayiters = 5000, saveiters = 5000, maxiters = 200000)
# If model was previously trained, read config.yaml to retrieve
deeplabcut.analyze_videos(path_config_file, r"%s\%s\videos"%(path, folders[i]), videotype='.mp4', save_as_csv=True)
print("%s training has been done, %s left"%(folders[i], num_folder - i))
else:
print("labeled-data folder not found OR empty OR config not found")
print("Running time for %s is %s sec" %(folders[i], time() - start))
def task(gpuNo):
deeplabcut.analyze_videos(config_path,
videolists,
shuffle=1,
save_as_csv=True,
videotype=".mp4",
gputouse=gpuNo)
def step4B_analyze(result, session, **kwargs):
networks = listdirs(kwargs['networks'])
network=None
indicator = 'L'
if kwargs['hand']==1:
indicator = 'R'
for onenetwork in networks:
if onenetwork[0] == indicator:
network = onenetwork
if network == None:
print("Can't find network for {}, {}".format(result, session))
sys.exit(1)
networkconfig = os.path.join(kwargs['networks'], network,'config.yaml')
analyze_folder = os.path.abspath(os.path.join(kwargs['videos_clipped'], result))
video_dlcout_2D_folder = os.path.abspath(os.path.join(kwargs['video_dlcout_2D'],result))
os.makedirs(video_dlcout_2D_folder, exist_ok=True)
deeplabcut.analyze_videos(networkconfig,
analyze_folder,
videotype='mp4',
shuffle=1,
gputouse=kwargs['gpu'],
save_as_csv=True,
destfolder=video_dlcout_2D_folder)
def process_motion_tracking(self, config, create_labelled_video=False):
"""
Run DeepLabCut motion tracking on behavioural videos.
"""
# bloated so imported when needed
import deeplabcut # pylint: disable=import-error
self.extract_videos()
config = Path(config).expanduser()
if not config.exists():
raise PixelsError(f"Config at {config} not found.")
for recording in self.files:
if 'camera_data' in recording:
video = self.interim / recording['camera_data'].with_suffix(
'.avi')
if not video.exists():
raise PixelsError(
f"Path {video} should exist but doesn't... discuss.")
deeplabcut.analyze_videos(config, [video])
deeplabcut.plot_trajectories(config, [video])
if create_labelled_video:
deeplabcut.create_labeled_video(config, [video])
def run_analysis_videos(cam_video_paths,filtertype='arima', windowlength=20, p_bound=0.9, ARdegree=0,
MAdegree=2,alpha=0.1):
"""
Function to analyze an experimental video using pre-trained deeplabcut neural networks to predict specified
joint locations from raw video files obtained during an experiment.
Additionally, DeepLabCut can filter data using (S)ARIMAX models. For more information, please see
https://github.com/DeepLabCut/DeepLabCut
Information is saved inside the video file to a .csv file necessary for 3-D reconstruction.
Parameters
----------
cam_video_paths : list of file paths for each individual camera
Returns
-------
"""
# set up network and get it ready
config_path = '/clusterfs/bebb/users/bnelson/DLC/CatScan-Brett-2020-07-27/config.yaml'
shuffle = 5 # shuffle of the network to use
print("Starting to extract files..")
# analyze each video path
deeplabcut.analyze_videos(config_path, cam_video_paths, videotype='mp4', shuffle=shuffle,
save_as_csv=True)
deeplabcut.filterpredictions(config_path, cam_video_paths, videotype='.mp4',shuffle=shuffle,
filtertype=filtertype, windowlength=windowlength,
p_bound=p_bound, ARdegree=ARdegree, MAdegree=MAdegree,alpha=alpha, save_as_csv=True)
return
def process_session(config, session_path):
pipeline_videos_raw = config['pipeline']['videos_raw']
pipeline_pose = config['pipeline']['pose_2d']
video_ext = config['video_extension']
config_name = os.path.join(config['model_folder'], 'config.yaml')
source_folder = os.path.join(session_path, pipeline_videos_raw)
outdir = os.path.join(session_path, pipeline_pose)
videos = glob(os.path.join(source_folder, '*.' + video_ext))
videos = sorted(videos, key=natural_keys)
if len(videos) > 0:
os.makedirs(outdir, exist_ok=True)
for video in videos:
basename = os.path.basename(video)
basename, ext = os.path.splitext(basename)
dataname = os.path.join(outdir, basename + '.h5')
print(dataname)
if os.path.exists(dataname):
continue
else:
import deeplabcut
trap = io.StringIO()
with redirect_stdout(trap):
deeplabcut.analyze_videos(config_name, [video],
videotype=ext,
save_as_csv=False,
destfolder=outdir)
rename_dlc_files(outdir, basename)
def generate_track_h5(config_path,untracked_videos,suffix=".mp4"):
os.environ["DLClight"]='True' # all the child process have this env but not its father process
if (platform.system()=="Linux"):
import deeplabcut
deeplabcut.analyze_videos(config_path,untracked_videos,shuffle=1,save_as_csv=True,videotype=suffix)
deeplabcut.plot_trajectories(config_path,untracked_videos)
deeplabcut.create_labeled_video(config_path,untracked_videos)
def track(config_file, video, dest_fld):
analyze_videos(config_file, [video],
gputouse=0,
destfolder=dest_fld,
videotype='.mp4',
save_as_csv=False,
dynamic=(False, .5, 10))
filterpredictions(config_file, [video], filtertype='median')
def repeatAnalyzeVideos(path_config_file, path):
for curDir, dirs, files in os.walk(path):
for file in files:
if file.endswith(str_videotype):
path_videos = os.path.join(curDir, file)
print(path_videos)
deeplabcut.analyze_videos(path_config_file, [path_videos],
shuffle=1,
videotype=str_videotype,
save_as_csv=True,
gputouse=Ngputouse)
def deeplabcut_detection(config_dir, video_dir):
"""Detect snout and tailbase coordinated with Deeplabcut model
config_dir: path to config file
video_dir: path to video input
return:
features_mouse1: coordinates of snout and tailbase of mouse 1
features_mouse2: coordinates of snout and tailbase of mouse 2
"""
deeplabcut.analyze_videos(config_dir, video_dir, videotype='.avi')
dlc_output = [
f for f in os.listdir(os.path.dirname(video_dir[0]))
if f.endswith('.h5')
]
# mouse1
mouse1_dlc = pd.read_hdf(
os.path.join(os.path.dirname(video_dir[0]), dlc_output[0]))
features_mouse1 = mouse1_dlc.values[:, [0, 1, 9, 10]]
features_mouse1 = np.round(features_mouse1, 2)
features_mouse1_df = pd.DataFrame({
'snout_x':
np.round(mouse1_dlc.values[:, 0], 2),
'snout_y':
np.round(mouse1_dlc.values[:, 1], 2),
'tailbase_x':
np.round(mouse1_dlc.values[:, 9], 2),
'tailbase_y':
np.round(mouse1_dlc.values[:, 10], 2)
})
features_mouse1_df.to_csv(os.path.join(os.path.dirname(video_dir[0]),
'features_mouse1_dlc.csv'),
index=False)
mouse2_dlc = pd.read_hdf(
os.path.join(os.path.dirname(video_dir[0]), dlc_output[1]))
features_mouse2 = mouse2_dlc.values[:, [0, 1, 9, 10]]
features_mouse2 = np.round(features_mouse2, 2)
features_mouse2_df = pd.DataFrame({
'snout_x':
np.round(mouse2_dlc.values[:, 0], 2),
'snout_y':
np.round(mouse2_dlc.values[:, 1], 2),
'tailbase_x':
np.round(mouse2_dlc.values[:, 9], 2),
'tailbase_y':
np.round(mouse2_dlc.values[:, 10], 2)
})
features_mouse2_df.to_csv(os.path.join(os.path.dirname(video_dir[0]),
'features_mouse2_dlc.csv'),
index=False)
return features_mouse1, features_mouse2
def process_session(config, session_path):
pipeline_videos_raw = config['pipeline']['videos_raw']
pipeline_pose = config['pipeline']['pose_2d']
video_ext = config['video_extension']
config_name = os.path.join(config['model_folder'], 'config.yaml')
source_folder = os.path.join(session_path, pipeline_videos_raw)
outdir = os.path.join(session_path, pipeline_pose)
videos = glob(os.path.join(source_folder, '*.' + video_ext))
videos = sorted(videos, key=natural_keys)
if len(videos) > 0:
os.makedirs(outdir, exist_ok=True)
videos_to_process = []
for video in videos:
basename = os.path.basename(video)
basename, ext = os.path.splitext(basename)
dataname = os.path.join(outdir, basename + '.h5')
if os.path.exists(dataname):
continue
else:
rename_dlc_files(
outdir, basename) # try renaming in case it processed before
if os.path.exists(dataname):
print(video)
continue
else:
videos_to_process.append(video)
if len(videos_to_process) > 0:
import deeplabcut
trap = io.StringIO()
for i in range(0, len(videos_to_process), 5):
batch = videos_to_process[i:i + 5]
for video in batch:
print(video)
with redirect_stdout(trap):
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
deeplabcut.analyze_videos(config_name,
batch,
videotype=video_ext,
save_as_csv=False,
destfolder=outdir,
TFGPUinference=False)
for video in batch:
basename = os.path.basename(video)
basename, ext = os.path.splitext(basename)
rename_dlc_files(outdir, basename)
def DLCPredictBehavior(config, input_file, output):
"""
Takes a video of animal behaviour and predicts body movements based on a supplied DeepLabCut body movement model.
:param config: The path to the DeepLabCut configuration file.
:param input_file: The folder containing the behavioural images to be analyzed.
:param output: The folder to which we save the predicted body movements.
"""
video_array = []
img_array = []
print(input_file)
for filename in glob.glob(os.path.join(input_file, "*.mp4")):
video_array.append(os.path.join(input_file, filename))
for _ in glob.glob(os.path.join(input_file, "*.png")):
_nsre = re.compile("([0-9]+)")
return [
int(text) if text.isdigit() else text.lower()
for text in re.split(_nsre, s)
]
img = cv2.imread(filename)
height, width, layers = img.shape
size = (width, height)
img_array.append(img)
if len(img_array) > 0:
video_output_path = os.path.join(output, "dlc_output", "behavior")
video_name = os.path.join(video_output_path, "behavior_video.mp4")
video_output_path = [video_output_path]
video_name = [video_name]
if not os.path.isdir(video_output_path[0]):
os.mkdir(video_output_path[0])
out = cv2.VideoWriter(video_name, cv2.VideoWriter_fourcc(*"MP4V"), 30,
size)
for i in range(len(img_array)):
out.write(img_array[i])
out.release()
elif len(video_array) > 0:
video_output_path = video_array
video_name = video_array
deeplabcut.analyze_videos(config,
video_output_path,
videotype=".mp4",
save_as_csv=True,
destfolder=output)
deeplabcut.create_labeled_video(config,
video_name,
filtered=True,
destfolder=output)
cv2.destroyAllWindows()
def anaslyse_deeplabcut(my_download_flag, my_download_list):
time.sleep(2)
print(my_download_flag)
while my_download_flag or len(my_download_list) > 0:
if len(my_download_list) > 0:
directory = my_download_list[0]
# print(directory)
if os.path.exists(directory):
deeplabcut.analyze_videos(self.path_config_file, [directory], save_as_csv=True)
if self.generate_labeled_video:
deeplabcut.create_labeled_video(self.path_config_file, [directory])
os.remove(directory)
my_download_list.remove(directory)
def s02_detect_rois():
"""
step 2 run DLC to detect ROIS
returns: df_crop, dataframe used to crop video
"""
out = deeplabcut.analyze_videos(dlc_params['roi_detect'], [str(tfile['mp4_sub'])])
# deeplabcut.create_labeled_video(config_path_roi_detection, files_mp4)
tfile['h5_sub'] = next(tpath.glob(f'*{out}*.h5'), None)
return pd.read_hdf(tfile['h5_sub'])
def train():
videofile_path = ['videos/ostrich.mp4'
] #Enter a folder OR a list of videos to analyze.
if not os.path.isfile(videofile_path[0]):
sys.exit("File {} not found!!".format(videofile_path[0]))
path_config_file = '/home/braincreator/Pose_estimation/DeepLabCut/examples/ostrich/Testing-Shan-2019-08-07/config.yaml'
print("\n" + "=" * 80 + "\n\t\t\t\tANALYZE\n" + "=" * 80)
deeplabcut.analyze_videos(path_config_file,
videofile_path,
gputouse=None,
videotype='.mp4')
print("\n" + "=" * 80 + "\n\t\t\t\tCreating video\n" + "=" * 80)
deeplabcut.create_labeled_video(path_config_file,
videofile_path,
outputframerate=5,
draw_skeleton=True)
def runDeepLabCut(Inputfilepath,OutputFilepath):
'''Function inputs are filepath to videos to be tracked by DLC and the folder to save the output to
Videos are copied to output folder, than processed in DLC based on the dlc config path
DLC output is saved in outputfilepath and the output is also converted to npy and saved as well
'''
#####################Copy Videos to DLC Folder############
for dir in [Inputfilepath]:#Iterates through input folder
for video in os.listdir(dir):#Iterates through each video in folder
#ffmpeg call to copy videos to dlc folder
subprocess.call(['ffmpeg', '-i', Inputfilepath+'/'+video, OutputFilepath+'/'+video])
#################### DeepLabCut ############################
for dir in [OutputFilepath]:# Loop through dlc folder
for video in os.listdir(dir):
#Analyze the videos through deeplabcut
deeplabcut.analyze_videos(baseProjectPath+'/'+DLCconfigPath, [OutputFilepath +'/'+ video], save_as_csv=True)
deeplabcut.plot_trajectories(baseProjectPath+'/'+DLCconfigPath,[OutputFilepath +'/'+ video])
for dir in [OutputFilepath]:#Loop through dlc folder
for video in dir:# for each video in folder
#Create a DLC video
deeplabcut.create_labeled_video(baseProjectPath+'/'+DLCconfigPath, glob.glob(os.path.join(OutputFilepath ,'*mp4')))
#If there is not a folder for dlc npy output, create one
if not os.path.exists(OutputFilepath + 'DLCnpy'):
os.mkdir(OutputFilepath+ 'DLCnpy')
#Load all dlc csv output files
csvfiles = glob.glob(OutputFilepath+'/*csv')
#For loop gets csv data from all cameras
j=0
for data in csvfiles:
datapoints = pd.read_csv(data) # read in the csv data
print(datapoints)
parsedDlcData = datapoints.iloc[3:,7:10].values#the last element in the array is the P value
#print(parsedDlcData)
print(parsedDlcData)
np.save(OutputFilepath+'/DLCnpy/dlc_'+cam_names[j]+'.npy',parsedDlcData)#Save data
j+=1
def analyze_videos(self,event):
shuffle = self.shuffle.GetValue()
trainingsetindex = self.trainingset.GetValue()
if self.csv.GetStringSelection() == "Yes":
save_as_csv = True
else:
save_as_csv = False
if self.cfg['cropping']:
crop = self.cfg['x1'], self.cfg['x2'], self.cfg['y1'], self.cfg['y2']
else:
crop = None
if self.dynamic.GetStringSelection() == "No":
dynamic = (False, .5, 10)
else:
dynamic = (True, .5, 10)
if self.filter.GetStringSelection() == "No":
filter = None
else:
filter = True
# if self.draw_skeleton.GetStringSelection() == "Yes":
# self.draw = True
# else:
# self.draw = True
# print(self.config,self.filelist,self.videotype.GetValue(),shuffle,trainingsetindex,gputouse=None,save_as_csv=save_as_csv,destfolder=self.destfolder,cropping=cropping)
deeplabcut.analyze_videos(self.config, self.filelist, videotype=self.videotype.GetValue(), shuffle=shuffle,
trainingsetindex=trainingsetindex, gputouse=None, save_as_csv=save_as_csv,
destfolder=self.destfolder, crop=crop, dynamic=dynamic)
if self.filter.GetStringSelection() == "Yes":
deeplabcut.filterpredictions(self.config, self.filelist, videotype=self.videotype.GetValue(), shuffle=shuffle, trainingsetindex=trainingsetindex, filtertype='median', windowlength=5, p_bound=0.001, ARdegree=3, MAdegree=1, alpha=0.01, save_as_csv=True, destfolder=self.destfolder)
if self.create_labeled_videos.GetStringSelection() == "Yes":
deeplabcut.create_labeled_video(self.config,self.filelist,self.videotype.GetValue(),shuffle=shuffle, trainingsetindex=trainingsetindex, draw_skeleton= self.draw,trailpoints = self.trail_points.GetValue(), filtered=True)
if self.trajectory.GetStringSelection() == "Yes":
deeplabcut.plot_trajectories(self.config, self.filelist, displayedbodyparts=self.bodyparts,
videotype=self.videotype.GetValue(), shuffle=shuffle, trainingsetindex=trainingsetindex, filtered=True, showfigures=False, destfolder=self.destfolder)
def predict_images(images, dlccfg, dbfile):
viddir = mkdtemp()
try:
print('Writing temp video files in dir ' + viddir)
images2avidir(images, viddir)
print('Finished video writing')
except:
shutil.rmtree(viddir)
print('Failed video writing')
raise
destdir = mkdtemp()
try:
print('Running DLC. Results will be stored in ' + destdir)
dlc.analyze_videos(dlccfg, [viddir], destfolder=destdir)
print('Finished DLC run')
except:
shutil.rmtree(viddir)
shutil.rmtree(destdir)
print('DLC failed')
raise
print('Storing prediction in ' + dbfile)
try:
for tracklet in images.keys():
h5file = sorted(glob(join(destdir, tracklet) + '*.h5'),
key=os.path.getmtime)[-1]
df = pd.read_hdf(h5file)
df.to_hdf(dbfile, key=tracklet, mode='a')
except:
shutil.rmtree(viddir)
shutil.rmtree(destdir)
print('Failed storing results')
raise
# clean
print('Cleaning up')
shutil.rmtree(destdir)
shutil.rmtree(viddir)
def deeplabcut(video):
import deeplabcut
import os
import glob
from shutil import copy2
path_config = '/home/in/aeed/plus_maize/Plus_Maiz-Amr-2018-12-25/config.yaml'
deeplabcut.analyze_videos(path_config, [video], save_as_csv=True)
deeplabcut.create_labeled_video(path_config, [video], trailpoints=10)
h5_file = os.path.abspath(glob.glob('plus_maze_*.h5')[0])
labeled_video = os.path.abspath(glob.glob('plus_maze_*_labeled.mp4')[0])
pickle = os.path.abspath(glob.glob('plus_maze_*.pickle')[0])
csv_file = os.path.abspath(glob.glob('plus_maze_*.csv')[0])
# I failed to force deeplabcut to put the output in the workflow directory, so I am copying them
# like a caveman
subj_no = os.getcwd()[-3:]
experiment_dir = '/home/in/aeed/Work/October_Acquistion/'
working_dir = 'Plus_Maze_workingdir'
copy2(
h5_file, '%s%s/Plus_Maze_workflow/_subject_id_%s/DeepLabCut/' %
(experiment_dir, working_dir, subj_no))
copy2(
labeled_video, '%s%s/Plus_Maze_workflow/_subject_id_%s/DeepLabCut/' %
(experiment_dir, working_dir, subj_no))
copy2(
pickle, '%s%s/Plus_Maze_workflow/_subject_id_%s/DeepLabCut/' %
(experiment_dir, working_dir, subj_no))
copy2(
csv_file, '%s%s/Plus_Maze_workflow/_subject_id_%s/DeepLabCut/' %
(experiment_dir, working_dir, subj_no))
return h5_file, labeled_video
def process_gpu_batch(config_name, videos, outdir, gpu=None):
for video in videos:
basename = os.path.basename(video)
basename, ext = os.path.splitext(basename)
dataname = os.path.join(outdir, basename + ".h5")
print(dataname)
if os.path.exists(dataname):
continue
else:
trap = io.StringIO()
with redirect_stdout(trap):
deeplabcut.analyze_videos(
config_name,
[video],
videotype=ext,
save_as_csv=True,
destfolder=outdir,
gputouse=gpu,
)
rename_dlc_files(outdir, basename)
def main():
path_to_DLC_network = sys.argv[1]
path_to_video = sys.argv[2]
shuffle = 8
config = os.path.join(path_to_DLC_network, 'config.yaml')
# run (to be updated with new folder structures)
if len(sys.argv) == 3:
# only process specified video
video_name = sys.argv[3]
file = os.path.join(path_to_video, video_name)
deeplabcut.analyze_videos(config, [file],
shuffle=shuffle,
videotype='mp4',
save_as_csv=True)
deeplabcut.filterpredictions(config, [file],
shuffle=shuffle,
videotype='mp4')
deeplabcut.create_labeled_video(config, [file],
shuffle=shuffle,
videotype='mp4',
filtered=True)
else:
files = getvideos(path_to_video)
for file in files:
deeplabcut.analyze_videos(config, [file],
shuffle=shuffle,
videotype='mp4',
save_as_csv=True)
deeplabcut.filterpredictions(config, [file],
shuffle=shuffle,
videotype='mp4')
deeplabcut.create_labeled_video(config, [file],
shuffle=shuffle,
videotype='mp4',
filtered=True)
def process_peter(videos,
model_folder,
out_folder,
video_type='avi'):
os.makedirs(out_folder, exist_ok=True)
config_name = os.path.join(model_folder, 'config.yaml')
import deeplabcut
trap = io.StringIO()
for i in range(0, len(videos), 5):
batch = videos[i:i + 5]
with redirect_stdout(trap):
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
deeplabcut.analyze_videos(config_name,
batch,
videotype=video_type,
save_as_csv=True,
destfolder=out_folder,
TFGPUinference=True)
for video in batch:
basename = os.path.basename(video)
basename, ext = os.path.splitext(basename)
rename_dlc_files(out_folder, basename)
def analyze_cropped_videos(folders_to_analyze, view_config_paths, marked_vids_parent, cropped_vid_type='.avi', gputouse=0, save_as_csv=True):
'''
:param folders_to_analyze:
:param view_config_paths:
:param cropped_vid_type:
:param gputouse:
:return: scorernames - dictionary with keys 'direct' and 'mirror' containing the scorername strings returned by
deeplabcut.analyze_videos
'''
view_list = folders_to_analyze.keys()
scorernames = {'direct': '', 'mirror': ''}
for view in view_list:
if 'direct' in view:
dlc_network = 'direct'
elif 'mirror' in view:
dlc_network = 'mirror'
else:
print(view + ' does not contain the keyword "direct" or "mirror"')
continue
config_path = view_config_paths[dlc_network]
current_view_folders = folders_to_analyze[view]
for current_folder in current_view_folders:
cropped_video_list = glob.glob(current_folder + '/*' + cropped_vid_type)
#todo: skip if analysis already done and stored in the _marked folder
scorername = deeplabcut.analyze_videos(config_path,
cropped_video_list,
videotype=cropped_vid_type,
gputouse=gputouse,
save_as_csv=save_as_csv)
scorernames[dlc_network] = scorername
new_dir = navigation_utilities.create_marked_vids_folder(current_folder, cropped_videos_parent,
marked_vids_parent)
pickle_list = glob.glob(os.path.join(current_folder, '*.pickle'))
for pickle_file in pickle_list:
# if the file already exists in the marked_vid directory, don't move it
_, pickle_name = os.path.split(pickle_file)
if not os.path.isfile(os.path.join(new_dir, pickle_name)):
shutil.copy(pickle_file, new_dir)
return scorernames
def analyze_cropped_optitrack_videos(folders_to_analyze, config_path, parent_directories, cropped_vid_type='.avi', gputouse=0, save_as_csv=True):
'''
:param folders_to_analyze:
:param view_config_paths:
:param cropped_vid_type:
:param gputouse:
:return: scorernames - dictionary with keys 'direct' and 'mirror' containing the scorername strings returned by
deeplabcut.analyze_videos
'''
if cropped_vid_type[0]=='.':
pass
else:
cropped_vid_type = '.' + cropped_vid_type
marked_vids_parent = parent_directories['marked_vids_parent']
cam_list = folders_to_analyze.keys()
for cam_name in cam_list:
current_cam_folders = folders_to_analyze[cam_name]
for current_folder in current_cam_folders:
cropped_video_list = glob.glob(current_folder + '/*' + cropped_vid_type)
#todo: skip if analysis already done and stored in the _marked folder
scorername = deeplabcut.analyze_videos(config_path,
cropped_video_list,
videotype=cropped_vid_type,
gputouse=gputouse,
save_as_csv=save_as_csv)
# deeplabcut.convert_detections2tracklets(config_path, cropped_video_list, videotype='mp4', shuffle=1, trainingsetindex=0)
# deeplabcut.stitch_tracklets(config_path, cropped_video_list, videotype='mp4', shuffle=1, trainingsetindex=0)
new_dir = navigation_utilities.create_optitrack_marked_vids_folder(current_folder, cropped_vids_parent,
marked_vids_parent)
pickle_list = glob.glob(os.path.join(current_folder, '*.pickle'))
for pickle_file in pickle_list:
# if the file already exists in the marked_vid directory, don't move it
_, pickle_name = os.path.split(pickle_file)
if not os.path.isfile(os.path.join(new_dir, pickle_name)):
shutil.copy(pickle_file, new_dir)
return scorername
deeplabcut.check_labels(path_config_file) #this creates a subdirectory with the frames + your labels
# Reviewed the labels, the seem to be ok
# Downloading the ResNets dataset:
deeplabcut.create_training_dataset(path_config_file)
# Training the dataset
deeplabcut.train_network(path_config_file)
# Evaluating the results
deeplabcut.evaluate_network(path_config_file)
# Analyzing video
videofile_path = ['dlc-blinking/an3_vid2_full/eyes_only-Guy-2019-01-25/videos/animal_3_video_2_150fps_correct.mp4',
'dlc-blinking/an3_vid2_full/eyes_only-Guy-2019-01-25/videos/march_8_animal_1_video_150fps_correct.mp4'] #Enter the list of videos to analyze.
videofile_path = ['dlc-blinking/whisk/whisk_only-Guy-2019-02-01/videos/crush_19_01_07_animal_3.mp4',
'dlc-blinking/whisk/whisk_only-Guy-2019-02-01/videos/animal_3_video_2_150fps_correct.mp4']
deeplabcut.analyze_videos(path_config_file,videofile_path,save_as_csv=True)
deeplabcut.create_labeled_video(path_config_file, ['D:\\dlc-blinking\\an3_vid2_full\\whisk_only-Guy-2019-02-01\\videos\\crush_19_01_07_animal_3.mp4'], save_frames=True)
deeplabcut.create_labeled_video(path_config_file, ['D:\\dlc-blinking\\whisk\\whisk_only-Guy-2019-02-01\\videos\\animal_3_video_2_150fps_correct.mp4'], save_frames=True)
%matplotlib notebook #for making interactive plots.
deeplabcut.plot_trajectories(path_config_file,videofile_path)
# TICTOCS:
# training - up to 72/96 hours
# analyzing - 45 minutes and 1.5 hours
# labeling - 25 minutes and 50 minutes
DLC_config = deeplabcut.auxiliaryfunctions.edit_config(posefile, edits)
print("TRAIN NETWORK", shuffle)
deeplabcut.train_network(
path_config_file,
shuffle=shuffle,
saveiters=10000,
displayiters=200,
maxiters=maxiters,
max_snapshots_to_keep=11,
)
print("EVALUATE")
deeplabcut.evaluate_network(path_config_file,
Shuffles=[shuffle],
plotting=True)
print("Analyze Video")
videofile_path = os.path.join(os.getcwd(), "openfield-Pranav-2018-10-30",
"videos", "m3v1mp4.mp4")
deeplabcut.analyze_videos(path_config_file, [videofile_path],
shuffle=shuffle)
print("Create Labeled Video and plot")
deeplabcut.create_labeled_video(path_config_file, [videofile_path],
shuffle=shuffle)
deeplabcut.plot_trajectories(path_config_file, [videofile_path],
shuffle=shuffle)
import sys
import os
os.environ["DLClight"] = "True"
vid_list = sys.argv[1:]
import deeplabcut
config_path = '/dartfs-hpc/rc/home/7/f002qw7/thesis/ir_test-markt-2020-02-28/config.yaml'
os.system('echo analyzing')
deeplabcut.analyze_videos(config_path, vid_list)
deeplabcut.create_labeled_video(config_path, vid_list, save_frames=True)
os.system('echo finished vid!')
vname='brief'
newvideo=os.path.join(cfg['project_path'],'videos',vname+'.mp4')
try: #you need ffmpeg command line interface
subprocess.call(['ffmpeg','-i',video[0],'-ss','00:00:00','-to','00:00:00.4','-c','copy',newvideo])
except:
#for windows:
from moviepy.editor import VideoFileClip,VideoClip
clip = VideoFileClip(video[0])
clip.reader.initialize()
def make_frame(t):
return clip.get_frame(1)
newclip = VideoClip(make_frame, duration=1)
newclip.write_videofile(newvideo,fps=30)
deeplabcut.analyze_videos(path_config_file,[newvideo],save_as_csv=True, destfolder=dfolder)
print("CREATE VIDEO")
deeplabcut.create_labeled_video(path_config_file,[newvideo], destfolder=dfolder)
print("Making plots")
deeplabcut.plot_trajectories(path_config_file,[newvideo], destfolder=dfolder)
print("EXTRACT OUTLIERS")
deeplabcut.extract_outlier_frames(path_config_file,[newvideo],outlieralgorithm='jump',epsilon=0,automatic=True, destfolder=dfolder)
file=os.path.join(cfg['project_path'],'labeled-data',vname,"machinelabels-iter"+ str(cfg['iteration']) + '.h5')
print("RELABELING")
