From 071f9e1d214eadc705167671673f85647a4b5cb6 Mon Sep 17 00:00:00 2001 From: Jan Grewe Date: Thu, 21 Jan 2021 08:36:35 +0100 Subject: [PATCH] some files --- boldness_darkside.py | 120 +++++++++++++++++++++++++++++++++++++++ dark_light_preference.py | 29 ++++++++++ feeder_positions.py | 64 +++++++++++++++++++++ speed.py | 28 +++++++++ 4 files changed, 241 insertions(+) create mode 100644 boldness_darkside.py create mode 100644 dark_light_preference.py create mode 100644 feeder_positions.py create mode 100644 speed.py diff --git a/boldness_darkside.py b/boldness_darkside.py new file mode 100644 index 0000000..2853aa1 --- /dev/null +++ b/boldness_darkside.py @@ -0,0 +1,120 @@ +import numpy as np +import matplotlib.pyplot as plt +import image_marker as im +import tracking_result as tr +import os +import glob +import argparse +from IPython import embed + +#1. Tankkoordinaten +def tankcoordinates(video, dontask=False): + redo = True + if os.path.exists('tankcoordinates.py'): + from tankcoordinates import bottom_left, bottom_right, top_left, top_right + print("Found tank coordinates top left: %s, top right: %s" % (top_left, top_right)) + if dontask: + return bottom_left, top_left, top_right, bottom_right + answer = input('Redo markers? y/n') + if answer == 'y' or answer == 'Y': + redo = True + else: + redo = False + if redo: + tank_task = im.MarkerTask("tank limits", ["bottom left corner", "top left corner", "top right corner", "bottom right corner"], "Mark tank corners") + image_marker = im.ImageMarker([tank_task]) + marker_positions = image_marker.mark_movie(video, 100) + bottom_right = marker_positions[0]['bottom right corner'] + bottom_left = marker_positions[0]['bottom left corner'] + top_right = marker_positions[0]['top right corner'] + top_left = marker_positions[0]['top left corner'] + with open('tankcoordinates.py', 'w') as f: + f.write('bottom_left = %s\n' % str(marker_positions[0]['bottom left corner'])) + f.write('top_left = %s\n' % str(marker_positions[0]['top left corner'])) + f.write('top_right = %s\n' % str(marker_positions[0]['top right corner'])) + f.write('bottom_right = %s\n' % str(marker_positions[0]['bottom right corner'])) + + return bottom_left, top_left, top_right, bottom_right +#2. Feederkoordinaten + +#3. dark_light Koordinaten +def dark_light_coordinates(video, dontask=False): + redo = True + if os.path.exists('dark_light_coordinates.py'): + from dark_light_coordinates import left, right, dark_center + print("Found dark_light_coordinates left: %s, right: %s, dark_center: %s" % (left, right, dark_center)) + if dontask: + return left, right, dark_center + answer = input('Redo markers? y/n') + if answer == 'y' or answer == 'Y': + redo = True + else: + redo = False + if redo: + dark_light_task = im.MarkerTask('Dark side', ['left', 'right', 'dark_center'], 'Mark light dark separator line') + image_marker = im.ImageMarker([dark_light_task]) + marker_positions = image_marker.mark_movie(video, 100) + + right = tr.coordinate_transformation(marker_positions[0]['right']) + left = tr.coordinate_transformation(marker_positions[0]['left']) + dark_center = tr.coordinate_transformation(marker_positions[0]['dark_center']) + + with open('dark_light_coordinates.py', 'w') as f: + f.write('left = %s\n' % str(left)) + f.write('right = %s\n' % str(right)) + f.write('dark_center = %s\n' % str(dark_center)) + + return left, right, dark_center + +#4. Laden der Trackingresults +def load_tracking_results(dlc_results_file): + trs = tr.TrackingResult(dlc_results_file) + t, x, y, l, name = trs.position_values(bodypart="snout", framerate=30) + return t, x, y, l + +#5. Wie lange hält sich der Fisch im Hellen/Dunklen auf? + # Anzahl Frames in der Fisch in definiertem, dunklen Bereich ist, bzw. in der der Fisch nicht im Hellen ist +def aufenthaltsort(left, center, fish_y): + top_is_dark=left[1]>=center[1] + #bei wie vielen Frames ist der Fisch im Hellen? + if top_is_dark: + hell_count = len(fish_y[fish_y >= left[1]]) + else: + hell_count = len(fish_y[fish_y < left[1]]) + dark_count=len(fish_y) - hell_count + total_count = len(fish_y) + return hell_count, dark_count, total_count + + +def analysiere_video(v, dlc, left, center): + t, fish_x, fish_y, likelihood = load_tracking_results(dlc) + hc, dc, tc = aufenthaltsort(left, center, fish_y) + print('Der Fisch hat sich %.2f %% im Dunklen aufgehalten.'%(dc/tc*100)) + return (dc/tc*100) + + +def main(): + parser = argparse.ArgumentParser(description="") + parser.add_argument("day", type=str, help="The day you want to work on") + parser.add_argument("-f", "--folder", type=str, default="/data/boldness/labeled_videos", help="The base folder in which the labeled videos are stored. Default is /data/boldness/labeled_videos") + parser.add_argument("-a", "--animal", type=str, default="*", help="The animal id, default is * for all animals") + parser.add_argument("-e", "--extension", type=str, default=".mp4", help="The video file extension, default is .mp4") + parser.add_argument("-na", "--noask", action="store_true", help="do not ask for coordinates") + args = parser.parse_args() + + videos = sorted(glob.glob(os.path.join(args.folder, args.day, '*%s*%s' % (args.animal, args.extension)))) + dlc_files = sorted(glob.glob(os.path.join(args.folder, args.day, '*%s*%s' % (args.animal, '.h5')))) + results = {} + if len(videos) > 0: + left, right, center = dark_light_coordinates(videos[0], args.noask) + # bl, tl, tr, br = tankcoordinates(v, args.noask) + for video, dlc_file in zip(videos, dlc_files): + animal = video.split(os.sep)[-1].split('_')[1] + p_dark = analysiere_video(video, dlc_file, left, center) + results[animal] = p_dark + np.save('results_%s.npy' % args.day, results) + print(results) + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/dark_light_preference.py b/dark_light_preference.py new file mode 100644 index 0000000..2d171bc --- /dev/null +++ b/dark_light_preference.py @@ -0,0 +1,29 @@ +import numpy as np +import os +import glob +import matplotlib.pyplot as pyplot +from IPython import embed + + +if __name__ == "__main__": + result_files = sorted(glob.glob("./results_day*.npy")) + results = {} + + for r in result_files: + day = r.split(os.sep)[-1].split('_')[-1].split('.')[0] + if "day" in results.keys(): + results["day"].append(day) + else: + results["day"] = [day] + data = np.load(r, allow_pickle=True) + d = data.item() + for k in d.keys(): + if k in results.keys(): + results[k].append(d[k]) + else: + results[k] =[d[k]] + + + #res= dict((k, results[k]) for k in ['lepto03DLC' , 'lepto48DLC'] if k in results) + #print(res) + print(results) \ No newline at end of file diff --git a/feeder_positions.py b/feeder_positions.py new file mode 100644 index 0000000..ae0e8bf --- /dev/null +++ b/feeder_positions.py @@ -0,0 +1,64 @@ +import image_marker as im +import matplotlib.pyplot as plt +import numpy as np +import tracking_result as tr +from IPython import embed +import argparse +import glob +import sys +import dark_light_coordinates as dl + +x_limits = np.array([0, 124]) +y_limits = np.array([0, 81]) +light_area_y = [45.5, 81] + +def get_risk(position, light_area_y, light_risk_scale=3, x_limits=np.array([0, 124]), y_limits = np.array([0, 81])): + """Calculates the risk associated with a certain position in the arena + + Args: + position (iterable): two-element vector of position i.e. (x,y) + light_area_y (iterable): two element vactor with the start and stop y-coordinates of light area + light_risk_scale (int, optional): if position is on th birght side, risk is scaled by this number. Defaults to 2. + x_limits : extent of the tank on x axis in cm + y_limits : extent of the tank on y axis in cm + + Returns: + float: the risk for this position + """ + min_wall_dist_x = min(np.abs(position[0] - x_limits)) + min_wall_dist_y = min(np.abs(position[1] - y_limits)) + + risk_x = 1/(max(x_limits)/2) * min_wall_dist_x + risk_y = 1/(max(y_limits)/2) * min_wall_dist_y + #risk_y = 1/(np.abs(np.diff(light_area_y))/2) * min_wall_dist_y + total_risk = min(risk_x,risk_y) #+ 0.25 * (risk_x + risk_y) + + is_position_on_the_bright_side = position[1] >= light_area_y[0] and position[1] < light_area_y[1] + if is_position_on_the_bright_side: + total_risk = total_risk + 1 + return total_risk + +x_positions = np.arange(0,125, 5) +y_positions = np.arange(0, 81, 5) + +risk_matrix = np.zeros((len(x_positions), len(y_positions))) +print(risk_matrix.shape) +for i, x in enumerate(x_positions): + for j, y in enumerate(y_positions): + risk_matrix[i, j] = get_risk([x, y], light_area_y) + +plt.imshow(risk_matrix) +plt.show() +""" +if __name__ == '__main__': + vid = '/mnt/movies/merle_verena/boldness/labeled_videos/day_5/2020.12.07_lepto48.m4v' + feeder_task = im.MarkerTask("Feeder positions", list(map(str, range(1, 9))), "Mark feeder positions") + tasks = [feeder_task] + image_marker = im.ImageMarker(tasks) + # vid1 = "2020.12.11_lepto48DLC_resnet50_boldnessDec11shuffle1_200000_labeled.mp4" + print(sys.argv[0]) + print (sys.argv[1]) + vid1 = sys.argv[1] + marker_positions = im.mark_movie(vid1, 10) + print(marker_positions) +""" diff --git a/speed.py b/speed.py new file mode 100644 index 0000000..3cce575 --- /dev/null +++ b/speed.py @@ -0,0 +1,28 @@ +import sys +import tracking_result as tr +import numpy as np +import matplotlib.pyplot as plt +from IPython import embed +#tracking_tools]$ python3 speed.py /mnt/movies/merle_verena/boldness/labeled_videos/day_1/2020.12.01_lepto03DLC_resnet50_boldnessDec11shuffle1_200000.h5 + +if __name__ == '__main__' : + dlc_results = sys.argv[1] + + trs = tr.TrackingResult(dlc_results) + t, x, y, l, name = trs.position_values(bodypart="snout", framerate=30) + t = t[l > 0.975] + x = x[l > 0.975] + y = y[l > 0.975] + + # Dann Differenzen berechnen + dx= np.diff(x) + dy= np.diff(y) + dt= np.diff(t) + + + s = np.sqrt(dx**2 + dy**2) + v = s/dt + embed () + + plt.scatter(x[:-1],y[:-1],c=v) + plt.show()