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 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 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 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(dlc_params['roi_detect'],
[str(tfile['mp4_sub'])])
tfile['h5_sub'] = next(tpath.glob(f'*{out}*.h5'), None)
return pd.read_hdf(tfile['h5_sub'])
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 create_videos(self, event):
shuffle = self.shuffle.GetValue()
trainingsetindex = self.trainingset.GetValue()
if self.filter.GetStringSelection() == "No":
filter = None
else:
filter = True
if self.video_slow.GetStringSelection() == "Yes":
self.slow = True
else:
self.slow = False
if self.filter.GetStringSelection() == "Yes":
if len(self.bodyparts) == 0:
self.bodyparts = 'all'
deeplabcut.create_labeled_video(
self.config,
self.filelist,
self.videotype.GetValue(),
shuffle=shuffle,
trainingsetindex=trainingsetindex,
save_frames=self.slow,
draw_skeleton=self.draw,
displayedbodyparts=self.bodyparts,
trailpoints=self.trail_points.GetValue(),
filtered=True)
if len(self.bodyparts) == 0:
self.bodyparts = 'all'
deeplabcut.create_labeled_video(
self.config,
self.filelist,
self.videotype.GetValue(),
shuffle=shuffle,
trainingsetindex=trainingsetindex,
save_frames=self.slow,
draw_skeleton=self.draw,
displayedbodyparts=self.bodyparts,
trailpoints=self.trail_points.GetValue(),
filtered=False)
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 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 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 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 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)
# Make super short video (so the analysis is quick!)
newvideo = deeplabcut.ShortenVideo(video[0],
start='00:00:00',
stop='00:00:00.4',
outsuffix='short',
outpath=os.path.join(
cfg['project_path'], 'videos'))
vname = Path(newvideo).stem
deeplabcut.analyze_videos(path_config_file, [newvideo],
shuffle=shuffle,
save_as_csv=True,
destfolder=dfolder)
print("CREATE VIDEO")
deeplabcut.create_labeled_video(path_config_file, [newvideo],
shuffle=shuffle,
destfolder=dfolder)
print("Making plots")
deeplabcut.plot_trajectories(path_config_file, [newvideo],
shuffle=shuffle,
destfolder=dfolder)
print("EXTRACT OUTLIERS")
deeplabcut.extract_outlier_frames(path_config_file, [newvideo],
shuffle=shuffle,
outlieralgorithm='jump',
epsilon=0,
automatic=True,
destfolder=dfolder)
file = os.path.join(cfg['project_path'], 'labeled-data', vname,
path_config_file = os.path.join(os.getcwd(), "openfield-Pranav-2018-10-30/config.yaml")
deeplabcut.load_demo_data(path_config_file)
shuffle = 13
deeplabcut.create_training_dataset(path_config_file, Shuffles=[shuffle])
cfg = deeplabcut.auxiliaryfunctions.read_config(path_config_file)
# example how to set pose config variables:
posefile, _, _ = deeplabcut.return_train_network_path(path_config_file, shuffle=shuffle)
edits = {"save_iters": 15000, "display_iters": 1000, "multi_step": [[0.005, 15001]]}
DLC_config = deeplabcut.auxiliaryfunctions.edit_config(posefile, edits)
print("TRAIN NETWORK")
deeplabcut.train_network(path_config_file, shuffle=shuffle, max_snapshots_to_keep=3)
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
) # ,videotype='.mp4')
print("Create Labeled Video")
deeplabcut.create_labeled_video(
path_config_file, [videofile_path], save_frames=False, shuffle=shuffle
) # ,videotype='.mp4')
def analyze_videos(self):
test_videos = self.test_video
deeplabcut.analyze_videos(self.full_config_path(), [test_videos])
deeplabcut.create_labeled_video(self.full_config_path(), [test_videos])
)
print("Plotting trajectories...")
deeplabcut.plot_trajectories(
config_path,
[new_video_path],
"mp4",
track_method=TESTTRACKER
)
print("Trajectory plotted.")
print("Creating labeled video...")
deeplabcut.create_labeled_video(
config_path,
[new_video_path],
"mp4",
save_frames=False,
color_by="individual",
track_method=TESTTRACKER
)
print("Labeled video created.")
print("Filtering predictions...")
deeplabcut.filterpredictions(
config_path,
[new_video_path],
"mp4",
track_method=TESTTRACKER
)
print("Predictions filtered.")
print("Extracting outlier frames...")
def create_pretrained_human_project(project,
experimenter,
videos,
working_directory=None,
copy_videos=False,
videotype='.avi',
createlabeledvideo=True,
analyzevideo=True):
"""
Creates a demo human project and analyzes a video with ResNet 101 weights pretrained on MPII Human Pose. This is from the DeeperCut paper by Insafutdinov et al. https://arxiv.org/abs/1605.03170 Please make sure to cite it too if you use this code!
Parameters
----------
project : string
String containing the name of the project.
experimenter : string
String containing the name of the experimenter.
videos : list
A list of string containing the full paths of the videos to include in the project.
working_directory : string, optional
The directory where the project will be created. The default is the ``current working directory``; if provided, it must be a string.
copy_videos : bool, optional
If this is set to True, the videos are copied to the ``videos`` directory. If it is False,symlink of the videos are copied to the project/videos directory. The default is ``False``; if provided it must be either
``True`` or ``False``.
analyzevideo " bool, optional
If true, then the video is analzyed and a labeled video is created. If false, then only the project will be created and the weights downloaded. You can then access them
Example
--------
Linux/MacOs
>>> deeplabcut.create_pretrained_human_project('human','Linus',['/data/videos/mouse1.avi'],'/analysis/project/',copy_videos=False)
Windows:
>>> deeplabcut.create_pretrained_human_project('human','Bill',[r'C:\yourusername\rig-95\Videos\reachingvideo1.avi'],r'C:\yourusername\analysis\project' copy_videos=False)
Users must format paths with either: r'C:\ OR 'C:\\ <- i.e. a double backslash \ \ )
--------
"""
cfg = deeplabcut.create_new_project(project, experimenter, videos,
working_directory, copy_videos,
videotype)
config = auxiliaryfunctions.read_config(cfg)
config['bodyparts'] = [
'ankle1', 'knee1', 'hip1', 'hip2', 'knee2', 'ankle2', 'wrist1',
'elbow1', 'shoulder1', 'shoulder2', 'elbow2', 'wrist2', 'chin',
'forehead'
]
config['skeleton'] = [['ankle1', 'knee1'], ['ankle2', 'knee2'],
['knee1', 'hip1'], ['knee2', 'hip2'],
['hip1', 'hip2'], ['shoulder1', 'shoulder2'],
['shoulder1', 'hip1'], ['shoulder2', 'hip2'],
['shoulder1', 'elbow1'], ['shoulder2', 'elbow2'],
['chin', 'forehead'], ['elbow1', 'wrist1'],
['elbow2', 'wrist2']]
config['default_net_type'] = 'resnet_101'
auxiliaryfunctions.write_config(cfg, config)
config = auxiliaryfunctions.read_config(cfg)
train_dir = Path(
os.path.join(
config['project_path'],
str(
auxiliaryfunctions.GetModelFolder(
trainFraction=config['TrainingFraction'][0],
shuffle=1,
cfg=config)), 'train'))
test_dir = Path(
os.path.join(
config['project_path'],
str(
auxiliaryfunctions.GetModelFolder(
trainFraction=config['TrainingFraction'][0],
shuffle=1,
cfg=config)), 'test'))
# Create the model directory
train_dir.mkdir(parents=True, exist_ok=True)
test_dir.mkdir(parents=True, exist_ok=True)
modelfoldername = auxiliaryfunctions.GetModelFolder(
trainFraction=config['TrainingFraction'][0], shuffle=1, cfg=config)
path_train_config = str(
os.path.join(config['project_path'], Path(modelfoldername), 'train',
'pose_cfg.yaml'))
path_test_config = str(
os.path.join(config['project_path'], Path(modelfoldername), 'test',
'pose_cfg.yaml'))
# Download the weights and put then in appropriate directory
cwd = os.getcwd()
os.chdir(train_dir)
print(
"Checking if the weights are already available, otherwise I will download them!"
)
weightfilename = auxfun_models.download_mpii_weigths(train_dir)
os.chdir(cwd)
# Create the pose_config.yaml files
parent_path = Path(os.path.dirname(deeplabcut.__file__))
defaultconfigfile = str(parent_path / 'pose_cfg.yaml')
trainingsetfolder = auxiliaryfunctions.GetTrainingSetFolder(config)
datafilename, metadatafilename = auxiliaryfunctions.GetDataandMetaDataFilenames(
trainingsetfolder,
trainFraction=config['TrainingFraction'][0],
shuffle=1,
cfg=config)
bodyparts = config['bodyparts']
net_type = 'resnet_101'
num_shuffles = 1
model_path, num_shuffles = auxfun_models.Check4weights(
net_type, parent_path, num_shuffles)
items2change = {
"dataset": 'dataset-test.mat', #datafilename,
"metadataset": metadatafilename,
"num_joints": len(bodyparts),
"all_joints": [[i] for i in range(len(bodyparts))],
"all_joints_names": [str(bpt) for bpt in bodyparts],
"init_weights":
weightfilename.split('.index')[0], #'models/mpii/snapshot-1030000',
"project_path": str(config['project_path']),
"net_type": net_type,
"dataset_type": "default"
}
trainingdata = MakeTrain_pose_yaml(items2change, path_train_config,
defaultconfigfile)
keys2save = [
"dataset", "dataset_type", "num_joints", "all_joints",
"all_joints_names", "net_type", 'init_weights', 'global_scale',
'location_refinement', 'locref_stdev'
]
MakeTest_pose_yaml(trainingdata, keys2save, path_test_config)
video_dir = os.path.join(config['project_path'], 'videos')
if analyzevideo == True:
# Analyze the videos
deeplabcut.analyze_videos(cfg, [video_dir],
videotype,
save_as_csv=True)
if createlabeledvideo == True:
deeplabcut.create_labeled_video(cfg, [video_dir],
videotype,
draw_skeleton=True)
deeplabcut.plot_trajectories(cfg, [video_dir], videotype)
return cfg, path_train_config
def write_config(configname,cfg):
with open(str(configname), 'w') as ymlfile:
yaml.dump(cfg, ymlfile,default_flow_style=False)
# Loading example data set
path_config_file = os.path.join(os.getcwd(),'openfield-Pranav-2018-10-30/config.yaml')
deeplabcut.load_demo_data(path_config_file)
cfg=read_config(path_config_file)
posefile=os.path.join(cfg['project_path'],'dlc-models/iteration-'+str(cfg['iteration'])+'/'+ cfg['Task'] + cfg['date'] + '-trainset' + str(int(cfg['TrainingFraction'][0] * 100)) + 'shuffle' + str(1),'train/pose_cfg.yaml')
DLC_config=read_config(posefile)
DLC_config['save_iters']=10
DLC_config['display_iters']=2
DLC_config['multi_step']=[[0.005,15001]]
write_config(posefile,DLC_config)
print("TRAIN NETWORK")
deeplabcut.train_network(path_config_file, shuffle=1,saveiters=15000,displayiters=100)
print("EVALUATE")
deeplabcut.evaluate_network(path_config_file,plotting=False)
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])
print("Create Labeled Video")
deeplabcut.create_labeled_video(path_config_file,[videofile_path],save_frames=True)
dlc.auxiliaryfunctions.edit_config(config_path, edits)
print('\nediting the config file... ')
for item in edits.items():
print(item)
print('edit completed!')
dlc.create_labeled_video(config=config_path,
videos=videos_path_list[listindex1:listindex2],
videotype='.mp4',
shuffle=shuffleindex,
trainingsetindex=0,
filtered=False,
save_frames=True,
Frames2plot=None,
delete=True,
displayedbodyparts='all',
codec='mp4v',
outputframerate=None,
destfolder=None,
draw_skeleton=True,
trailpoints=0,
displaycropped=False)
print("dlc_create_labeled_video.py with the call", str(sys.argv), "is done!")
print("returning snapshotindex back to 'all'...!")
edits = {'snapshotindex': 'all'}
dlc.auxiliaryfunctions.edit_config(config_path, edits)
print("snapshotindex is set back to 'all'")
def Get_Percent_Good(coords):
bbs, it, mh = coords[0], coords[1], coords[2]
current_video_path = test_video_folder_path.format(bbs=bbs, it=it, mh=mh)
#Writes a new file here for the future labeling and things to use
i_cfg_file = open(inference_cfg_path, "w")
i_cfg_file.write(inference_cfg_text.format(bbs=bbs, it=it, mh=mh))
i_cfg_file.close()
#Creates the folder and videos
if not os.path.isdir(current_video_path):
os.mkdir(current_video_path)
for v in og_video_files:
shutil.copy2(main_video_folder_path + v, current_video_path + v)
for p in og_pickle_files:
shutil.copy2(main_video_folder_path + p, current_video_path + p)
#analyze video
#No longer needed since they are the same each time
#deeplabcut.analyze_videos(config_path,[current_video_path], videotype='.mp4', save_as_csv = True)
#convert to tracklets
deeplabcut.convert_detections2tracklets(config_path, [current_video_path],
videotype='mp4',
shuffle=1,
trainingsetindex=0,
track_method='box')
video_files = os.listdir(current_video_path)
#Convert to h5s
for file in video_files:
if file.endswith("_bx.pickle"):
h5_name = file.replace("pickle", "h5")
video_name = file.replace
if h5_name in video_files:
print("h5 for {} already exists!".format(file))
else:
print("Converting {} to h5!".format(file))
deeplabcut.convert_raw_tracks_to_h5(config_path,
current_video_path + file)
#Need to do this each time to update with new videos
video_files = os.listdir(current_video_path)
#fix the messy bits in the files so all points exist
for file in video_files:
if file.endswith("_bx.h5"):
print(file)
if file.startswith("2020_6"):
x_len = 1920
y_len = 800
else:
x_len = 2368
y_len = 1152
rep_values = [x_len - x_len / 10, y_len / 2, 0]
hf = h5py.File(current_video_path + file, 'r+')
table = hf['df_with_missing/table']
n_table = np.array(table)
new_table = n_table
for i in range(n_table.shape[0]):
dlc_data = n_table[i][1]
dlc_data = np.nan_to_num(dlc_data)
for j in range(len(dlc_data)):
# j%3 gives 0 = x, 1 = y, 2 = prob
pos = j % 3
#if there is no data then replace it with default
if dlc_data[j] == 0:
new_table[i][1][j] = rep_values[pos]
if pos != 2:
print(
"No Points. Set to {} in position {}.".format(
rep_values[pos], pos))
#if x is out of range replace with default
if pos == 0 and (dlc_data[j] > x_len or dlc_data[j] < 0):
new_table[i][1][j] = rep_values[pos]
print(
"Out of X Bounds: Replaced {} with {} in position {}."
.format(dlc_data[j], rep_values[pos], pos))
#if y is out of range replace with default
if pos == 1 and (dlc_data[j] > y_len or dlc_data[j] < 0):
new_table[i][1][j] = rep_values[pos]
print(
"Out of Y Bounds: Replaced {} with {} in position {}."
.format(dlc_data[j], rep_values[pos], pos))
#This is all to allow me to just correct the first n frames and only extract those
table[...] = new_table
hf.close()
video_files = os.listdir(current_video_path)
#Now create the filtered videos and CSVs
for file in video_files:
if file.endswith(".mp4"):
print(file)
deeplabcut.filterpredictions(config_path,
[current_video_path + file],
videotype='mp4',
shuffle=1,
track_method='box')
deeplabcut.create_labeled_video(config_path,
[current_video_path + file],
videotype='.mp4',
shuffle=1,
draw_skeleton=True,
track_method='box',
save_frames=False,
filtered=True)
video_files = os.listdir(current_video_path)
#Now finally get the percent of "good" points
files = []
good_percents = []
for file_name in video_files:
if file_name.endswith(".csv"):
in_csv = open(current_video_path + file_name, "r")
#Skip the first 4
skip_lines = 0
good_points = 0
total_points = 0
for line in in_csv:
if skip_lines >= 4:
lis = line.split(",")[:-24]
#Off by 1 for the first row of frame counts
probs = np.asarray(lis[3::3]).astype(np.float)
#If there are no zeros in probs
good_points += np.sum(probs > prob_cutoff)
total_points += len(probs)
else:
skip_lines += 1
lis = line.split(",")[:-24]
files.append(file_name)
good_percents.append(round(good_points / total_points * 100, 2))
in_csv.close()
#out_csv.close()
files = np.asarray(files)
good_percents = np.asarray(good_percents)
sort_percent = np.flip(good_percents[np.argsort(good_percents)])
sorted_files = np.flip(files[np.argsort(good_percents)])
out_file = open(
current_video_path +
"PGV_{bbs}_{it}_{mh}.txt".format(bbs=bbs, it=it, mh=mh), "w")
for i in range(len(sorted_files)):
out_file.write("{} : {}% good points\n".format(sorted_files[i][:22],
sort_percent[i]))
print("{} : {}% good points".format(sorted_files[i][:22],
sort_percent[i]))
out_file.close()
score = np.sum((100 - good_percents)**2)
main_csv = open(
main_video_folder_path + "PGV_all.csv".format(bbs=bbs, it=it, mh=mh),
"a")
main_csv.write(
"{bbs}_{it}_{mh},{bbs},{it},{mh},{v0},{v1},{v2},{v3},{v4},{m},{score}\n"
.format(bbs=bbs,
it=it,
mh=mh,
v0=good_percents[0],
v1=good_percents[1],
v2=good_percents[2],
v3=good_percents[3],
v4=good_percents[4],
m=np.mean(good_percents),
score=score))
main_csv.close()
shutil.rmtree(current_video_path)
return (score)
def usingDeep(path_config, project):
exit = False
while exit == False:
video_path = path_config.split("/")
video_path = '/' + video_path[1] + '/' + video_path[
2] + '/' + video_path[3] + '/' + video_path[4] + '/videos/'
print_usage("project")
action = input()
while action not in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]:
try:
action = int(action)
if action not in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]:
print("please type number between 0 and 12")
action = input()
except ValueError:
print("Please enter number")
action = input()
print("been here")
if action == 0:
return False
elif action == 1:
print("do you want to crop the video? yes/no")
if input() == "yes" or "y":
print(
"how many videos you you want to crop? (use number: 1,2,3 etc)"
)
crops = int(input())
print("only crop all the video's and than exit")
for loop in range(0, crops):
deeplabcut.extract_frames(path_config,
'manual',
'kmeans',
crop=True)
deeplabcut.extract_frames(path_config,
'automatic',
'kmeans',
crop=True)
elif action == 2:
deeplabcut.label_frames(path_config)
elif action == 3:
deeplabcut.check_labels(path_config)
elif action == 4:
deeplabcut.create_training_dataset(path_config)
elif action == 5:
with open("training_network.py") as fp:
lines = fp.readlines()
lines[3] = lines[3].split("=")
lines[3] = lines[3][0] + "= '" + path_config + "'\n"
with open("training_network.py", "w") as fp:
for line in lines:
fp.writelines(line)
print("run: sbatch slurm.sh")
return True
elif action == 6:
try:
deeplabcut.evaluate_network(path_config,
Shuffles=[1],
trainingsetindex=0,
plotting=None,
show_errors=True,
comparisonbodyparts='all',
gputouse=None,
rescale=False)
except OSError as e:
print("file does not exist")
elif action == 7:
print("\nType video name in project/videos you want to analyze")
video_path = video_path + create_dict_list(
path_config[:-11] + "videos/", 1)[0]
with open("training_network.py") as fp:
lines = fp.readlines()
lines[3] = lines[3].split("=")
lines[3] = lines[3][0] + "= '" + path_config + "'\n"
lines[4] = lines[4].split("=")
lines[4] = lines[4][0] + "= '" + video_path + "'\n"
with open("training_network.py", "w") as fp:
for line in lines:
fp.writelines(line)
print(
"run: sbatch slurm.sh after changing the command in training_network.py"
)
return True
elif action == 8:
print(
"\nChoose the video in project/videos you want to plot trajectories from"
)
video_path = video_path + create_dict_list(
path_config[:-11] + "videos/", 1)[0]
print(video_path)
deeplabcut.plot_trajectories(path_config, [video_path],
filtered=True)
elif action == 9:
print(
"\nChoose the video in project/videos you want to make a labeled video from"
)
video_path = video_path + create_dict_list(
path_config[:-11] + "videos/", 1)[0]
deeplabcut.create_labeled_video(path_config, [video_path],
videotype='.mp4',
draw_skeleton=True)
elif action == 10:
print("\nChoose where to upload the video from")
video_path = '/data/11012579/videos/' + create_dict_list(
'/data/11012579/videos/', 0)[0]
print("\nChoose which video to upload")
video_path_list = [
video_path + "/" + create_dict_list(video_path, 1)[0]
]
while True:
print("\nDo you want to add more videos?\nType yes or no")
if input() == 'yes':
video_path_list.append(video_path + "/" +
create_dict_list(video_path, 1)[0])
else:
deeplabcut.add_new_videos(path_config,
video_path_list,
copy_videos=False)
break
elif action == 11:
print("also here")
Dlc_results2 = pd.read_hdf(
'/data/11012579/videos/vidDLC_resnet50_demo_project_grab2Feb7shuffle1_11500.h5'
)
Dlc_results2.plot()
else:
print_usage("error")
print("klaar")
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)
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")
DF=pd.read_hdf(file,'df_with_missing')
DLCscorer=np.unique(DF.columns.get_level_values(0))[0]
DF.columns.set_levels([scorer.replace(DLCscorer,scorer)],level=0,inplace=True)
img_array = []
for filename in files:
img = cv2.imread(filename)
height, width, layers = img.shape
size = (width, height)
img_array.append(img)
videoBaseName = os.path.basename(os.path.normpath(dataDir))
if '.' in videoBaseName:
videoBaseName = videoBaseName[:-2]
videoName = dataDir + videoBaseName + '.avi'
out = cv2.VideoWriter(videoName, cv2.VideoWriter_fourcc(*'DIVX'), 25, size)
for i in range(len(img_array)):
out.write(img_array[i])
out.release()
videoPath = videoName
imageDir = dataDir
deeplabcut.analyze_time_lapse_frames(config,
imageDir,
save_as_csv=True,
rgb=False)
deeplabcut.create_labeled_video(config, [videoPath], filtered=False)
deeplabcut.analyze_videos(
path_config_file,
[newvideo],
save_as_csv=True,
destfolder=dfolder,
dynamic=(True, 0.1, 5),
)
print("analyze again...")
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,
save_frames=True)
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,
)
"mp4",
track_method=TESTTRACKER,
transformer_checkpoint=transformer_checkpoint,
)
print("Plotting trajectories...")
deeplabcut.plot_trajectories(
config_path, [new_video_path], "mp4", track_method=TESTTRACKER
)
print("Trajectory plotted.")
print("Creating labeled video...")
deeplabcut.create_labeled_video(
config_path,
[new_video_path],
"mp4",
save_frames=False,
color_by="individual",
track_method="transformer",
)
print("Labeled video created.")
print("Filtering predictions...")
deeplabcut.filterpredictions(
config_path, [new_video_path], "mp4", track_method=TESTTRACKER
)
print("Predictions filtered.")
print("Extracting outlier frames...")
deeplabcut.extract_outlier_frames(
config_path, [new_video_path], "mp4", automatic=True, track_method=TESTTRACKER
)
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!')
newvideo_path = os.path.join(path_prj, 'videostoanalyze', animal)
newvideos = [os.path.join(newvideo_path, 'CPB15_120418.mp4')]
# animal = 'Az'
# # Az/
# newvideo_path = os.path.join(path_prj, 'videostoanalyze', animal)
# newvideos = [os.path.join(newvideo_path, 'Az_Neural-190128_Azula-190128-141757_Cam1.avi'), \
# os.path.join(newvideo_path, 'Az_Neural-190313_Azula-190313-124618_Cam1.avi'), \
# os.path.join(newvideo_path, 'Az_Neural-190410_Azula-190410-120937_Cam1.avi')]
# # Az/turningbehavior
# newvideo_path = os.path.join(path_prj, 'videostoanalyze', animal,'turningbehavior')
# newvideos = [os.path.join(newvideo_path, 'Az_Neural-190128_Azula-190128-141757_Cam2.avi'), \
# os.path.join(newvideo_path, 'Az_Neural-190228_Azula-190228-121940_Cam2.avi'), \
# os.path.join(newvideo_path, 'Az_Neural-190228_Azula-190228-123038_Cam2.avi'), \
# os.path.join(newvideo_path, 'Az_Neural-190410_Azula-190410-120937_Cam2.avi'), \
# os.path.join(newvideo_path, 'Az_Neural-190410_Azula-190410-122407_Cam2.avi')]
if tag_analyze:
# analyze new video
deeplabcut.analyze_videos(path_config_file,
newvideos,
save_as_csv=True,
videotype='.mp4')
if tag_createlabel:
# create labeled video in .mp4
deeplabcut.create_labeled_video(path_config_file, newvideos)
# plot trajectories
#deeplabcut.plot_trajectories(path_config_file, newvideos)
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
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 17 14:19:41 2019
@author: gtsror
"""
import matplotlib
import deeplabcut
import tensorflow as tf
import os
from pathlib import Path
path_config_file = os.path.join(os.getcwd(),
'Reaching-Mackenzie-2018-08-30/config.yaml')
deeplabcut.load_demo_data(path_config_file)
deeplabcut.check_labels(path_config_file)
deeplabcut.create_training_dataset(path_config_file)
deeplabcut.train_network(path_config_file, shuffle=1)
deeplabcut.evaluate_network(path_config_file, plotting=True)
# creating the video path
videofile_path = '/Reaching-Mackenzie-2018-08-30/videos/MovieS2_Perturbation_noLaser_compressed.avi'
print("Start Analyzing the video!")
deeplabcut.analyze_videos(path_config_file, [videofile_path])
deeplabcut.create_labeled_video(path_config_file, [videofile_path])
