Source code for start_GUI

__author__ = 'David Tadres'
__project__ = 'PiVR'
__version__ = '1.4.13'
__date__ = '25th of September, 2020'

#####################################################
# This seems to be necessary in order to run on MacOS
import matplotlib
matplotlib.use('TkAgg')
#####################################################

# general imports
import json
import os
import time
import tkinter as tk
from tkinter import font as tkfont
from tkinter import filedialog, simpledialog
from glob import glob
import numpy as np
import pandas as pd
from PIL import Image, ImageTk
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
from matplotlib.patches import Circle
import calendar
import imageio
import subprocess

# local modules
import control_file
import distance_configuration_module
import VR_drawing_board
import analysis_scripts
import output_channels
import visualize_tracked_experiment
import initialize_image_data
import image_data_handling
# testing purpose
import record_videos_and_image_sequences
import multi_animal_tracking

# SOME CONSTANTS:

# depending on the sampling frequency (set when starting the program
# in the terminal when starting the pigpio daemon)
# you need to comment/uncomment the correct variable
MAX_PWM_FREQ = 40000 # sampling freq = 1us
# MAX_PWM_FREQ = 20000 # sampling freq = 2us
# MAX_PWM_FREQ = 10000 # sampling freq = 4us
# MAX_PWM_FREQ = 8000 # sampling freq = 5us
# MAX_PWM_FREQ = 5000 # sampling freq = 8us
# MAX_PWM_FREQ = 4000 # sampling freq = 10us

# The numbers between 0 and the number defined here are used to
# define the dutycyle of the GPIO. The maximum value for the
# PWM_RANGE is 40000:
# http://abyz.me.uk/rpi/pigpio/python.html#set_PWM_range
PWM_RANGE = 100

# Here is a switch for simulating the Raspberry Pi experience on
# another computer
virtual_raspberry = False

# this try-except statement checks if the processor is a ARM processor
# (used by the Raspberry Pi) or not.
# Since this command only works in Linux it is caught using
# try-except otherwise it's throw an error in a Windows system.
try:
    if os.uname()[4][:3] == 'arm':
        RASPBERRY = True
        LINUX = True
    else:
        RASPBERRY = False
        LINUX = True

    DIRECTORY_INDICATOR = '/'
except AttributeError:
    RASPBERRY = False
    LINUX = False
    DIRECTORY_INDICATOR = '\\'

# Keep a reference to the path of the PiVR software.
SOFTWARE_PATH = os.path.abspath(os.getcwd())

if RASPBERRY:
    import picamera
    import pigpio

# The snippet below will try to read a file called
# 'saved_variables.json' in the same folder as this GUI is. If it
# finds it, it will try to read all the settings the user had when
# the program was closed
previous_variables = None
try:
    if LINUX:
        with open(('/'.join(os.path.realpath(__file__).split('/')[:-1])
                   + '/saved_variables.json'), 'r') as file:
            previous_variables = json.load(file)
    else:
        with open(('\\'.join(os.path.realpath(__file__).split('\\')[:-1])
                   + '\\saved_variables.json'), 'r') as file:
            previous_variables = json.load(file)
except FileNotFoundError:
    pass

# In addition, the software looks for a second json file:
# "list_of_available_organisms.json". This file contains parameters
# used by PiVR to adapt the tracking algorithm to specific animals.
try:

    if LINUX:
        with open(('/'.join(os.path.realpath(__file__).split('/')[:-1])
                   + '/list_of_available_organisms.json'),
                  'r') as file:
            organisms_and_heuristics = json.load(file)
    else:
        with open(('\\'.join(os.path.realpath(__file__).split('\\')[:-1])
                   + '/list_of_available_organisms.json'),
                  'r') as file:
            organisms_and_heuristics = json.load(file)

except FileNotFoundError:
    # without this file we can't really do anything - so quit the
    # program and ask the user to fix the problem
    tk.messagebox.showerror('File Missing',
            'Cannot find list_of_available_organisms.json in the '
            'main program folder.'
            '\nPlease restore the file or get a new copy of the program')
    import sys

    sys.exit()

class Camera():
    def __init__(self):
        """
        This class initializes the Raspberry Pi camera.

        This is done once while the software PiVR class is preparing
        the GUI if run on a Raspberry Pi
        """

        if RASPBERRY:

            # Here we initialize the camera
            self.cam = picamera.PiCamera()
            # turn off the small signal LED on the PiCamera as it
            # might be seen by the animal
            self.cam.led = False
            # At least for the RPi it seems the white balance needs to be set manually
            self.cam.awb_mode = 'tungsten'
            # Exposure mode, explanation here:
            # http://picamera.readthedocs.io/en/release-1.10/api_camera.html
            if previous_variables is not None:
                self.cam.shutter_speed = \
                    previous_variables['exposure time']
                # if exposure time is anything but 0 it has been set
                # while autoexposure was turned off, i.e. because the
                # user wanted to slightly overexpose the image. In
                # that case turn autoexposure off from the start
                if self.cam.shutter_speed != 0:
                    self.cam.exposure_mode = 'off'
                else:
                    # if the exposure time was 0 it means that the
                    # autoexposure mode was on when saving the
                    # variables. Reflect that by turning
                    # autoexposure on
                    self.cam.exposure_mode= 'auto'

            print('initalized')
        else:
            self.cam = None


[docs]class PiVR(tk.Tk): """ This class initializes the GUI the user will see. There are several different frames (e.g. "Tracking" vs "Virtual Arena") that all are created differently. To do this, the "PiVR" class instantiates (=calls) a number of other classes. To help with this the following three "helper" classes are important: #) "CommonVariables" contains variables that are true between frames, #) "SubFrames" helps with the creation of the different frames and finally #) "CommonFunction" which contains functions that are called in different frames. The actual frames (e.g. "TrackingFrame") are then created by "constructor" classes which call different components of the three classes described above. The "helper" classes are necessary as they can save variables and functions between different frames (similar to global variables). For example, if the user would select at particular folder to save all the experimental data, the "CommonVariables" class saves this folder when the user is then switching from e.g. the "Tracking" frame to the "Virtual Arena" frame. """ def __init__(self, *args, **kwargs): """ """ tk.Tk.__init__(self, *args, **kwargs) self.title_font = tkfont.Font(family='Helvetica', size=18) if LINUX: try: self.wm_iconbitmap(bitmap = '@pics/VRLarvaBanana32px.xbm') except: # it's a tkinter.TclError when opening on the Pi # with the shortcut pass else: self.wm_iconbitmap('pics\\VRLarvaBanana32px.ico') self.wm_title('PiVR') # the container is where we'll stack a bunch of frames on top # of each other, then the one we want visible will be raised # above the others container = tk.Frame(self) container.grid(row=0, column=0) container.grid_rowconfigure(0, weight=1) container.grid_columnconfigure(0, weight=1) # Initialize the camera instance - this is the only time this # happens! # If error, e.g. camera not connected/not turned on the # script fails here. So if we want to give a more meaningful # error message, this would be the place to raise tkinter # exception and let the user know what to do! camera_class_pointer = Camera() # Call the common classes first - every class that wants to # use any of those variables will get to work with this # variable which has the whole class of variables used by the # GUI. # After initalization, these can be called from inside other # classes. self.all_common_variables = \ CommonVariables(camera_class=camera_class_pointer) self.all_common_functions = \ CommonFunctions(camera_class=camera_class_pointer, controller=self) self.sub_frames = \ SubFrames(camera_class=camera_class_pointer, controller=self) # figure out where the script itself is. if LINUX: # todo - test with a mac! self.path_of_program = \ (os.path.realpath(__file__)[0:-len( os.path.realpath(__file__).split('/')[-1])]) #print(self.path_of_program) else: # Assume it's Windows self.path_of_program = \ (os.path.realpath(__file__)[0:-len( os.path.realpath(__file__).split('\\')[-1])]) print(self.path_of_program) #print(pathlib.Path.cwd()) # Todo - for readability can # try to change to a pathlib.Path - but need to change a # lot of strings that use self.path_of_program # Now create an empty dictionary. This dictionary will be # used to address the newly created tkinter frames self.frames = {} # This loop takes the list of the "constructor" classes if RASPBERRY or virtual_raspberry: for F in (TrackingFrame, VirtualRealityFrame, DynamicVirtualRealityFrame, VideoFrame, FullFrameImagesRecording, #FixMetadata, SimulateOnlineExperiment,): # previously included: , TryFastCam, FastDownscaleSave, # AnalyzeVideoExperiment # This will save the name of the class (e.g. # TrackingFrame) so that it can be used as a # dictionary key later on page_name = F.__name__ # Now construct the different frames using the # constructor classes. All frames are constructed in # the "container" tk.Frame(). frame = F(parent=container, controller=self, camera_class=camera_class_pointer) # Here the "frames" dictionary is filled with the # different frame instances self.frames[page_name] = frame # put all of the pages in the same location; # the one on the top of the stacking order # will be the one that is visible. frame.grid(row=0, column=0, sticky="nsew") # In case the software is started not on the PiVR (and the # virtual_raspberry boolean is turned to False) a slightly # different frame dictionary is created. elif not virtual_raspberry: for F in (TrackedAnalysisFrame, ImageDataHandling, #FixMetadata, DisplayTrackedImage, MultiAnimalTracking, SimulateOnlineExperiment, ): # This will save the name of the class (e.g. # TrackingFrame) so that it can be used as a # dictionary key later on page_name = F.__name__ # Now construct the different frames using the # constructor classes. All frames are constructed in # the "container" tk.Frame(). frame = F(parent=container, controller=self, camera_class=camera_class_pointer) # Here the "frames" dictionary is filled with the # different frame instances self.frames[page_name] = frame # put all of the pages in the same location; # the one on the top of the stacking order # will be the one that is visible. frame.grid(row=0, column=0, sticky="nsew") # After constructing all the individual frames, an immutable # menubar on top of the window is created self.menubar = tk.Menu(self) # The creation of the menubar goes from left to right # We start with the "File" menu that enables the user to do # globally valid actions, such as closing the window or # updating the software! menu_file = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label="File", menu=menu_file) # To this Menu-object, a number of different options # attached to functions are created: menu_file.add_command( label="Save settings", command=lambda: self.all_common_functions.quit_sequence( save=True, exit=False)) menu_file.add_command( label="Save and exit", command=lambda: self.all_common_functions.quit_sequence( save=True, exit=True)) menu_file.add_command( label='Discard changes and exit', command=lambda: self.all_common_functions.quit_sequence( save=False, exit=True)) menu_file.add_command( label='About/Version', command=self.all_common_functions.software_info) menu_file.add_command( label='Update software', command=self.all_common_functions.update_software) # In the "Recording" menu, the user can choose between the # different recording options! menu_recording = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label="Recording", menu=menu_recording) menu_recording.add_command( label="Tracking", command=lambda: self.show_frame('TrackingFrame')) menu_recording.add_command( label="VR Arena", command=lambda: self.show_frame('VirtualRealityFrame')) menu_recording.add_command( label="Dynamic VR Arena", command=lambda: self.show_frame( 'DynamicVirtualRealityFrame')) menu_recording.add_command( label='Full Frame Recording', command=lambda: self.show_frame('FullFrameImagesRecording')) menu_recording.add_command( label="Video", command=lambda: self.show_frame('VideoFrame')) # In the "Analysis" menu, the user can choose different # tools option menu_tools = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label="Tools", menu=menu_tools) menu_tools.add_command( label='Analysis', command=lambda: self.show_frame('TrackedAnalysisFrame')) menu_tools.add_command( label='Image data handling', command=lambda: self.show_frame('ImageDataHandling') ) #menu_tools.add_command( # label='Fix Metadata', # command=lambda: self.show_frame('FixMetadata')) menu_tools.add_command( label='Display tracked experiment', command=lambda: self.show_frame('DisplayTrackedImage')) menu_tools.add_command( label='Multi-Animal Tracking', command=lambda: self.show_frame('MultiAnimalTracking')) menu_tools.add_command( label='Draw VR arena', command=self.all_common_functions.draw_VR_arena) # Here goes the "Debug" menu - currently the only option is # to simulate an online experiment menu_simulate = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label='Debug', menu=menu_simulate) menu_simulate.add_command( label='Simulate Online Tracking', command=lambda : self.show_frame('SimulateOnlineExperiment')) #menu.add_command(label='Analyze Full Frame Image Experiment', # command=lambda: self.show_frame('AnalyzeFullFrameImageExperiment')) #menu.add_command(label='Analyze Video Experiment', # command=lambda: self.show_frame('AnalyzeVideoExperiment')) # Todo - decide if delete or keep. Includes the classes and python files! #menu = tk.Menu(self.menubar, tearoff=0) #self.menubar.add_cascade(label='Development', menu=menu) #menu.add_command(label='fast vid', command=lambda: self.show_frame('TryFastCam')) #menu.add_command(label='fast downscale', command=lambda: self.show_frame('FastDownscaleSave')) # Finally, the "Options' Menu is defined. Quite a few # essential options are in here such as menu_options = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label='Options', menu=menu_options) # Add a menu to select organism using a dropdown menu which # allows for maximum flexibility as the end user can and # should change the list of organisms! organism_menu = tk.Menu(self, tearoff=0) menu_options.add_cascade(label='Select Organism', menu=organism_menu) # As the content of the menu option are dependent on what was # read in "available_organisms.json", use a loop to populate it for organism_names in organisms_and_heuristics: organism_menu.add_radiobutton( label=organism_names, value=organism_names, variable=self.all_common_variables.model_organism_variable) # add radiobutton to turn debug mode on or off debug_menu = tk.Menu(self, tearoff=0) menu_options.add_cascade( label='Turn Debug Mode...', menu = debug_menu) debug_options = ['OFF', 'ON'] for debug_option_names in debug_options: debug_menu.add_radiobutton( label=debug_option_names, value=debug_option_names, variable=self.all_common_variables.debug_mode_var) # The following menu items call functions found in the # all_common_functions class menu_options.add_command( label='Define Pixel/mm', command=self.all_common_functions.distance_configuration_func) menu_options.add_command( label='Optimize Image', command=self.all_common_functions.camera_controls_func) menu_options.add_command( label='Select Output Channels', command=self.all_common_functions.select_output_channels) menu_options.add_command( label='High Power LEDs', command=self.all_common_functions.high_power_LED) menu_options.add_command( label='Animal Detection Method', command=self.all_common_functions.animal_detection_method_func) menu_options.add_command( label='VR Stimulation Point', command=self.all_common_functions.vr_body_part_stim_func) menu_options.add_command( label='Animal Color', command=self.all_common_functions.select_signal) # And finally, this menu allows the user to design their own # virtual arena using the drawing board. #menu_VR_options = tk.Menu(self.menubar, tearoff=0) #self.menubar.add_cascade(label='VR', menu=menu_VR_options) #menu_VR_options.add_command( # label='Draw VR arena', # command=self.all_common_functions.draw_VR_arena) top = self.winfo_toplevel() top.config(menu=self.menubar) # Here, a number of the just created menu options are # disabled depending on the platform the PiVR software is # being used. if RASPBERRY or virtual_raspberry: menu_tools.entryconfig( "Analysis", state="disabled") menu_tools.entryconfig( "Display tracked experiment", state="disabled") #menu_tools.entryconfig( # "Post-Hoc Single Animal Analysis", state="disabled") menu_tools.entryconfig( "Multi-Animal Tracking", state="disabled") menu_tools.entryconfig( "Draw VR arena", state="disabled") menu_tools.entryconfig( "Image data handling", state="disabled") menu_simulate.entryconfig( "Simulate Online Tracking", state="disabled") menu_options.entryconfig( "Turn Debug Mode...", state="disabled") elif not virtual_raspberry: #menu_file.entryconfig( # "Update software", state="disabled") menu_recording.entryconfig( "Tracking", state="disabled") menu_recording.entryconfig( "VR Arena", state="disabled") menu_recording.entryconfig( "Dynamic VR Arena", state="disabled") menu_recording.entryconfig( "Full Frame Recording", state="disabled") menu_recording.entryconfig( "Video", state="disabled") menu_options.entryconfig( "Select Organism", state="disabled") menu_options.entryconfig( "Define Pixel/mm", state="disabled") menu_options.entryconfig( "Optimize Image", state="disabled") menu_options.entryconfig( "Select Output Channels", state="disabled") menu_options.entryconfig( "High Power LEDs", state="disabled") menu_options.entryconfig( "Animal Color", state="disabled") # Whenever the software starts, display the last shown frame if previous_variables is not None and 'Window' in previous_variables: self.show_window = previous_variables['Window'] else: if RASPBERRY or virtual_raspberry: self.show_window ='TrackingFrame' else: self.show_window = 'TrackedAnalysisFrame' try: self.show_frame(self.show_window) except KeyError: # # this happens when the user opens the software for the # first time on a PC (non-virtual RPi) if RASPBERRY or virtual_raspberry: self.show_window = 'TrackingFrame' else: self.show_window ='TrackedAnalysisFrame' self.show_frame(self.show_window) # Here, the term protocol refers to the interaction between # the application and the window manager. The most commonly # used protocol is called WM_DELETE_WINDOW, and is used to # define what happens when the user explicitly closes a # window using the window manager. # (http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm#protocols) def on_closing(): if tk.messagebox.askokcancel("Quit without " "\n saving", "Do you want to quit " "\nwithout saving your " "settings?"): self.destroy() # root.destroy() self.protocol("WM_DELETE_WINDOW", on_closing)
[docs] def show_frame(self, page_name): """ This function is called when the user presses on a different frame. It takes the selected frame and raises it to the top. In addition, it saves the current page name which is needed to pass around as a reference to the currently active frame when calling functions that are generally called, such as starting an experiment! """ frame = self.frames[page_name] frame.tkraise() # also save which window we currently have up - needed for referencing self.current_window = page_name print(self.current_window) # finally, for user friendliness - if the user has been # presenting a virtual reality it is shown in the preview # window. # If user now goes to, e.g. 'Tracking' tab, this is not # intuitive as this would not be presented. # Therefore check here if the current "page_name" is # "VirtualRealityFrame" - if yes, check if an arena has been # chosen and present it in the preview window. # If the current page_name is NOT "VirtualRealityFrame", # remove any preview if page_name == "VirtualRealityFrame": # check if arena has been selected if self.all_common_variables.overlay is not None: self.all_common_functions.preview_overlay_func() else: # # Remove any overlay on the preview window! if self.all_common_variables.overlay_image is not None: try: self.all_common_variables.cam.remove_overlay( self.all_common_variables.overlay) except Exception as ex: # This happens when selecting a VR arena, # then selecting e.g. Video and then selecting # tracking or some other window that is not # VirtualRealityFrame. #print('Tried removing overlay after removing it ' # 'already:') #print(ex) pass
[docs] def call_start_experiment_function(self, page_name): """ This function will be called by the button that says 'start experiment'. It will look in the currently active frame for a function called 'start_experiment_function'. """ self.frames[page_name].start_experiment_function()
[docs] def access_subframes(self, page_name): """ This function just return the instance of the currently active (=in foreground) window """ return (self.frames[page_name])
class CommonVariables(): """ Here are all the variables stored that are being used in the GUI. This class is called by the controller (SmallVR) and referenced. All subsequent calls to any of these variables goes through the controller. I hope this makes the code easier to understand on a high level and also possible to add new windows without fully understanding all the other windows. """ def __init__(self, camera_class): self.camera_class = camera_class self.cam = self.camera_class.cam # previously was in 'if not RASPBERRY' - might lead to a bug out here self.image_path = tk.StringVar() self.image_path.set('No path selected yet') # todo check in previous variables? Maybe? if not RASPBERRY: self.cam = None if previous_variables is not None \ and 'Animal Signal' in previous_variables: self.signal=previous_variables['Animal Signal'] else: self.signal = 'dark' # need to define early (before setting output variables) if the setup used is using high-powered LEDs or strips self.high_power_LEDs_bool = tk.IntVar() if previous_variables is not None: try: self.high_power_LEDs_bool.set(previous_variables['High Power LEDs']) except KeyError: self.high_power_LEDs_bool.set(0) else: self.high_power_LEDs_bool.set(0) # if RASPBERRY or virtual_raspberry: # I like to give this output a very different name than all the other outputs as this one is only one of two # GPIO pins on the Raspberry Pi that is capable of true hardware PWM: 13 and 18 (the latter not tested by me) self.backlight_intensity_variable = tk.IntVar() if previous_variables != None and 'Background dutycycle' in previous_variables: self.backlight_intensity_value = previous_variables['Background dutycycle'] else: self.backlight_intensity_value = 0 self.backlight_intensity_variable.set(self.backlight_intensity_value) # Another backlight channel. This can be needed if illumination is done via IR on the backlight #1 but one also # needs a constant color, e.g. white or blue LEDs, to be on the whole experiment. self.backlight_two_intensity_variable = tk.IntVar() if previous_variables != None and 'Background 2 dutycycle' in previous_variables: self.backlight_two_intensity_value = previous_variables['Background 2 dutycycle'] else: self.backlight_two_intensity_value = 0 self.backlight_two_intensity_variable.set(self.backlight_two_intensity_value) # Goal here is to give the user relativly free reign over how to use the GPIOs. In total we have four channels # (including the background channel above). It is, however, possible to use the four channels independently # if no PWM is needed for the background illumination. These four channels are defined below. self.channel_one_variable = tk.IntVar() if previous_variables != None: try: self.channel_one_dutycycle = previous_variables['Channel 1 dutycycle'] except: self.channel_one_dutycycle = 0 else: self.channel_one_dutycycle = 0 # Channel 2 self.channel_two_variable = tk.IntVar() if previous_variables != None: try: self.channel_two_dutycycle = previous_variables['Channel 2 dutycycle'] except: self.channel_two_dutycycle = 0 else: self.channel_two_dutycycle = 0 self.channel_three_variable = tk.IntVar() if previous_variables != None: try: self.channel_three_dutycycle = previous_variables['Channel 3 dutycycle'] except: self.channel_three_dutycycle = 0 else: self.channel_three_dutycycle = 0 self.channel_four_variable = tk.IntVar() if previous_variables != None: try: self.channel_four_dutycycle = previous_variables['Channel 4 dutycycle'] except: self.channel_four_dutycycle = 0 else: self.channel_four_dutycycle = 0 # Try to assign the channel variables (including frequencies) from the previous variables json files if previous_variables != None: try: self.background = previous_variables['Background'] self.background_two = previous_variables['Background 2'] self.channel_one = previous_variables['Channel 1'] self.channel_two = previous_variables['Channel 2'] self.channel_three = previous_variables['Channel 3'] self.channel_four = previous_variables['Channel 4'] except: self.background = [[18, 40000]] self.background_two = [] self.channel_one = [[17, MAX_PWM_FREQ], [27, MAX_PWM_FREQ], [13, MAX_PWM_FREQ]] self.channel_two = [] self.channel_three = [] self.channel_four = [] else: self.background = [[18, 40000]] self.background_two = [] self.channel_one = [[17, MAX_PWM_FREQ], [27, MAX_PWM_FREQ], [13, MAX_PWM_FREQ]] self.channel_two = [] self.channel_three = [] self.channel_four = [] if RASPBERRY: # accesses the local Pi's GPIO and binds it to the variable pwm_object. In order to access the GPIOs we # can just call the variable self.pwm_object = pigpio.pi() # if not hardware PWM the range of values will be 0-40000 (standard would be 0-255) self.pwm_range = PWM_RANGE # for each of the channels, look which gpios are assigned and set the frequency at this point for i in range(len(self.background)): if self.background[i][1] > MAX_PWM_FREQ: self.pwm_object.hardware_PWM(self.background[i][0], self.background[i][1], self.backlight_intensity_value) else: # this should almost never be used - can't really think of a good use of this! self.pwm_object.set_PWM_frequency(self.background[i][0], self.background[i][1]) self.pwm_object.set_PWM_range(self.background[i][0], self.pwm_range) self.pwm_object.set_PWM_dutycycle(self.background[i][0], int(round(self.backlight_intensity_value*(self.pwm_range/1000000)))) # for backlight_two: for i in range(len(self.background_two)): if self.background_two[i][1] > MAX_PWM_FREQ: self.pwm_object.hardware_PWM(self.background_two[i][0], self.background_two[i][1], self.backlight_intensity_value) else: # this should almost never be used - can't really think of a good use of this! self.pwm_object.set_PWM_frequency(self.background_two[i][0], self.background_two[i][1]) self.pwm_object.set_PWM_range(self.background_two[i][0], self.pwm_range) self.pwm_object.set_PWM_dutycycle(self.background_two[i][0], int(round(self.backlight_two_intensity_value*(self.pwm_range/1000000)))) for i in range(len(self.channel_one)): if self.channel_one[i][1] > MAX_PWM_FREQ: self.pwm_object.hardware_PWM(self.channel_one[i][0], self.channel_one[i][1], self.channel_one_dutycycle) else: # this should almost never be used - can't really think of a good use of this! self.pwm_object.set_PWM_frequency(self.channel_one[i][0], self.channel_one[i][1]) self.pwm_object.set_PWM_range(self.channel_one[i][0], self.pwm_range) # if high power LED bool is True invert the scale - zero will then be 40000 which is off and # vice versa if self.high_power_LEDs_bool.get(): self.pwm_object.set_PWM_dutycycle(self.channel_one[i][0], int(self.pwm_range - self.channel_one_dutycycle)) else: self.pwm_object.set_PWM_dutycycle(self.channel_one[i][0], self.channel_one_dutycycle) for i in range(len(self.channel_two)): if self.channel_two[i][1] > MAX_PWM_FREQ: self.pwm_object.hardware_PWM(self.channel_two[i][0], self.channel_two[i][1], self.channel_two_dutycycle) else: # this should almost never be used - can't really think of a good use of this! self.pwm_object.set_PWM_frequency(self.channel_two[i][0], self.channel_two[i][1]) self.pwm_object.set_PWM_range(self.channel_two[i][0], self.pwm_range) if self.high_power_LEDs_bool.get(): # if high power LED bool is True invert the scale - zero will then be 40000 which is off and # vice versa self.pwm_object.set_PWM_dutycycle(self.channel_two[i][0], int(self.pwm_range - self.channel_two_dutycycle)) else: self.pwm_object.set_PWM_dutycycle(self.channel_two[i][0], self.channel_two_dutycycle) for i in range(len(self.channel_three)): if self.channel_three[i][1] > MAX_PWM_FREQ: self.pwm_object.hardware_PWM(self.channel_three[i][0], self.channel_three[i][1], self.channel_three_dutycycle) else: # this should almost never be used - can't really think of a good use of this! self.pwm_object.set_PWM_frequency(self.channel_three[i][0], self.channel_three[i][1]) self.pwm_object.set_PWM_range(self.channel_three[i][0], self.pwm_range) if self.high_power_LEDs_bool.get(): # if high power LED bool is True invert the scale - zero will then be 40000 which is off and # vice versa self.pwm_object.set_PWM_dutycycle(self.channel_three[i][0], int(self.pwm_range - self.channel_three_dutycycle)) else: self.pwm_object.set_PWM_dutycycle(self.channel_three[i][0], self.channel_three_dutycycle) for i in range(len(self.channel_four)): if self.channel_four[i][1] > MAX_PWM_FREQ: self.pwm_object.hardware_PWM(self.channel_four[i][0], self.channel_four[i][1], self.channel_four_dutycycle) else: # this should almost never be used - can't really think of a good use of this! self.pwm_object.set_PWM_frequency(self.channel_four[i][0], self.channel_four[i][1]) self.pwm_object.set_PWM_range(self.channel_four[i][0], self.pwm_range) if self.high_power_LEDs_bool.get(): # if high power LED bool is True invert the scale - zero will then be 40000 which is off and # vice versa self.pwm_object.set_PWM_dutycycle(self.channel_four[i][0], int(self.pwm_range - self.channel_four_dutycycle)) else: self.pwm_object.set_PWM_dutycycle(self.channel_four[i][0], self.channel_four_dutycycle) #print(self.pwm_object.get_PWM_frequency(STIM_GPIO_1)) # In the next line the variable that will be bound to the menu where the user can choose the resolution # is created. self.resolution_variable = tk.StringVar() self.available_resolution = ('640x480', '1024x784', '1296x972', '1920x1080', '2592x1944') # Test if the file that saved the previous settings exists if previous_variables is not None: try: # check if the user used the 640x480 resolution before if previous_variables['Resolution'] == '640x480': # if yes, set the variable to that resolution - this will make sure that the menu option self.resolution_variable.set(self.available_resolution[0]) self.resolution = '640x480' # todo - delete if below in final version if RASPBERRY: # Here the resolution of the camera is changed self.cam.resolution = (640, 480) # check if the user used the 1024x784 resolution before elif previous_variables['Resolution'] == '1024x784': self.resolution_variable.set(self.available_resolution[1]) # todo - understand why we have resolution, resolution_variable and cam.resolution on the Pi self.resolution = '1024x784' # todo - delete if below in final version if RASPBERRY: self.cam.resolution = (1024, 784) elif previous_variables['Resolution'] == '1296x972': self.resolution_variable.set(self.available_resolution[2]) self.resolution = '1296x972' # todo - delete if below in final version if RASPBERRY: self.cam.resolution = (1296, 972) elif previous_variables['Resolution'] == '1920x1080': self.resolution_variable.set(self.available_resolution[3]) self.resolution = '1920x1080' # todo - delete if below in final version if RASPBERRY: self.cam.resolution = (1920, 1080) elif previous_variables['resolution'] == '2592x1944': self.resolution_variable.set(self.available_resolution[4]) self.resolution = '2592x1944' # todo - delete if below in final version if RASPBERRY: self.cam.resolution = (2592, 1944) except: # todo - no blank exceptions # if for some reason the above failed, just set the resolution to 640x480 self.resolution_variable.set(self.available_resolution[0]) self.resolution = '640x480' # todo - delete if below in final version if RASPBERRY: self.cam.resolution = (640, 480) else: self.resolution_variable.set(self.available_resolution[0]) self.resolution = '640x480' # todo - delete if below in final version if RASPBERRY: self.cam.resolution = (640, 480) # todo - delete if below in final version # todo change camelBack names to under_score_variable_names_and_be_more_explicit if RASPBERRY or virtual_raspberry: self.preview_window_size_variable = tk.StringVar() self.preview_window_size_value = 180 #self.camera_brightness_variable = tk.IntVar() #self.camera_brightness_value = 50 #self.camera_contrast_variable = tk.IntVar() #self.camera_contrast_value = 50 #self.camera_exposure_variable = tk.IntVar() #self.camera_exposure_value = 0 # organisms are defined in the 'list_of_available_organisms.json' file in the main folder of this software # An example entry of one organism: # "3rd instar Dmel" : { # "filled_area_min_mm" : 8, # "filled_area_max_mm" : 24, # "eccentricity_min" : 0.5, # "eccentricity_max" : 1.0, # "major_over_minor_axis_min": 1.25, # "major_over_minor_axis_max": 7, # "max_skeleton_length_mm": 4 # The string before the { is the name of the organism. After the { are several non-optional heuristic parameters # filled_area_min and max, eccentricity_min and max and major_over_minor_axis_min and max are necessary to # define the animal before the experiment starts # max_skeleton_length defines the size of the pre-allocated numpy array that will be used to save the images # the max_speed_animal_mm_per_s will be used to define the size of the search box self.model_organism_variable = tk.StringVar() self.model_organism_value = 'Not in list' # self.available_model_organisms = ('Not in list', 'Drosophila larva', 'D rerio 5dpf', 'Planaria') # add options to the optionmenu here # read dynamically which model organisms are saved in the json file self.available_model_organisms = [] # list comprehension (compact for loop) to add all the available animals [self.available_model_organisms.append(i) for i in organisms_and_heuristics] if previous_variables is not None and 'Organism' in previous_variables: for i in range(len(self.available_model_organisms)): if previous_variables['Organism'] == self.available_model_organisms[i]: self.model_organism_variable.set(self.available_model_organisms[i]) else: # default is 'not in list' self.model_organism_variable.set(self.available_model_organisms[0]) # Here the menu, that lets the user choose what to display during the experiment, is constructed self.experiment_observation_mode = tk.StringVar() # If more modes shall be added in the future, add them to this tuple. self.available_modes = ('only animal', 'overview', 'none', 'debug') if previous_variables != None: try: for experiment_observation_mode_loop in range(len(self.available_modes)): if previous_variables['Observation mode'] == self.available_modes[experiment_observation_mode_loop]: self.experiment_observation_mode.set(self.available_modes[experiment_observation_mode_loop]) self.experiment_observation_mode_output = self.available_modes[experiment_observation_mode_loop] except: self.experiment_observation_mode.set(self.available_modes[0]) self.experiment_observation_mode_output = self.available_modes[0] else: self.experiment_observation_mode.set(self.available_modes[0]) self.experiment_observation_mode_output = self.available_modes[0] # Changed to a menu button for the magnification of the observation during the experiment #self.observation_resize_variable = tk.IntVar() #self.observation_resize_options = (1, 2, 3, 4) #if previous_variables != None: # try: # for i in range(len(self.observation_resize_options)): # if previous_variables['Observation Resize'] == self.observation_resize_options[i]: # self.observation_resize_variable.set(self.observation_resize_options[i]) # else: # # if not in list, set default to '1' # self.observation_resize_variable.set(self.observation_resize_options[0]) # except: # # if for some reason not in previous_variables, fall back to default '1' # self.observation_resize_variable.set(self.observation_resize_options[0]) #else: # # default is '1' # self.observation_resize_variable.set(self.observation_resize_options[0]) self.display_pixel_per_mm_variable = tk.DoubleVar() self.pixel_per_mm_var = tk.DoubleVar() if previous_variables != None: try: self.pixel_per_mm_var.set(float(round(previous_variables['distance factor'],2))) self.known_distance = previous_variables['known distance'] self.display_pixel_per_mm_variable.set(self.pixel_per_mm_var.get()) except KeyError: self.pixel_per_mm_var.set(0) self.known_distance = 1 #self.debug_mode_var = False self.debug_mode_resize = 2 else: self.pixel_per_mm_var.set(0) self.known_distance = 'none' # todo - check, i dont think this is actually used anywhere right now # All the variable we'll need for the preview frame constructions # to assign the class afterwards #self.debug_mode = None #if previous_variables != None: # try: # self.debug_mode_var = previous_variables['debug mode'] # self.debug_mode_resize = previous_variables['debug mode resize'] # self.preview_resize = previous_variables['preview resize'] # except: # self.debug_mode_var = False # self.debug_mode_resize = 2 # self.preview_resize = 2 #else: # self.debug_mode_var = False # self.debug_mode_resize = 2 # self.preview_resize = 2 # print('set debug mode to ' + repr(self.debug_mode_var)) self.debug_mode_var = tk.StringVar() # todo - save in json and read again, for now just self.debug_mode_var.set('OFF') # get vr_arena variable in the correct resolution resolution_height = int(self.resolution.split("x")[0]) resolution_width = int(self.resolution.split("x")[1]) self.vr_arena = np.zeros((resolution_width, resolution_height)) self.overlay_bool = False self.overlay = None self.overlay_image = None self.placed_animal = None self.animal_annotation = None self.vr_arena_name = None self.path = None self.framerate_read_from_experiment_settings = None self.pixel_per_mm_read_from_experiment_settings = None self.organism_read_from_experiment_settings = None self.genotype_read_from_experiment_settings = None self.resolution_read_from_experiment_settings = None self.recording_time_read_from_experiment_settings = None self.entered_text = None self.convert_image_output_variable = tk.StringVar() self.convert_image_output_options = ('.npy', '.avi') self.convert_image_output_variable.set(self.convert_image_output_options[0]) self.playback_speed_options = ('0.1X', '0.5X', '1X', '2X', '5X', 'Fastest') self.playback_speed_var = tk.StringVar() self.playback_speed_var.set(self.playback_speed_options[2]) self.time_dependent_stimulation_file = None # This is only used for the tools part. Whenever the user selects a folder it will be global self.data_path = None self.experimental_metadata = None self.vr_arena_multidimensional = False self.multiple_folder_analysis_var = tk.IntVar() self.animal_detection_method_var = tk.StringVar() # todo - implement previous variables if previous_variables is not None and 'Animal Detection Mode' in previous_variables: self.animal_detection_method_var.set(previous_variables['Animal Detection Mode']) else: self.animal_detection_method_var.set('Mode 1') # make this a bit nicer #self.child_window_optimize_image = None self.auto_exposure_button = None self.child_high_power_LED = None # textvariable for the entry for path self.path_entry_variable = tk.StringVar() if previous_variables != None: try: self.path_entry_variable.set(previous_variables['Path']) except KeyError: self.path_entry_variable.set('/home/pi/Desktop/') else: self.path_entry_variable.set('/home/pi/Desktop/') # textvariable for entry of framerate self.framerate_entry_variable = tk.StringVar() if previous_variables != None: try: self.framerate_entry_variable.set(previous_variables['Recording framerate']) except KeyError: # be sure that is correct - e.g. if user fiddles manually in settings file she might set it to zero self.framerate_entry_variable.set('30') else: self.framerate_entry_variable.set('30') # textvariable for genotype self.genotype_entry_variable = tk.StringVar() if previous_variables != None: #try: if 'Exp. group' in previous_variables: self.genotype_entry_variable.set(previous_variables['Exp. group']) elif 'genotype' in previous_variables: self.genotype_entry_variable.set(previous_variables['genotype']) #except: # self.genotype_entry_variable.set('myExpGroup') else: self.genotype_entry_variable.set('myExpGroup') # textvariable for recordingtime self.recording_time_variable = tk.StringVar() if previous_variables != None: try: self.recording_time_variable.set(previous_variables['Recording length']) except: self.recording_time_variable.set('20') else: self.recording_time_variable.set('20') # variable to keep name of time dependent stimulus file self.time_dependent_stim_file_name = tk.StringVar() # better not the save and re-load when # variable to display timedep file user has selected self.chosen_timedep_file_display_var = tk.StringVar() self.chosen_timedep_file_display_var.set(None) # for image sequence recording give option to record different formats self.image_sequence_format_var = tk.StringVar() self.image_sequence_format_var.set('jpg') # todo, make saveable in saved_variables.json self.image_sequence_format_options = ('jpg', 'png', 'rgb', 'yuv', 'rgba') self.vr_update_rate = 1 # This variable is necessary to ensure that each selected arena (if high power LED setup) only gets inverted once! self.invert_arena_bool = True # Used to track user provided intensity self.vr_intensity_adjustment_variable = tk.StringVar() # ALWAYS set to 100% when program starts!!! self.vr_intensity_adjustment_variable.set('100') # Cam preview on or off self.preview_bool = False # body part defining vr stimulation self.vr_stim_loc_var = tk.StringVar() # set to head as standard if previous_variables is not None \ and 'VR Body Part Stimulation' in previous_variables: self.vr_stim_loc_var.set( previous_variables['VR Body Part Stimulation']) else: self.vr_stim_loc_var.set('Head') class SubFrames(): """ This class is used to construct all the different frames (windows that are displayed in the GUI). To keep the code short different parts of the windows are re-used. Using the boolean switches defined in the __init__ different parts of the frame can be called which then constructs a given frame. """ def __init__(self, camera_class, controller, cam_frame=False, subframe_preexperiment=False, misc_frame=False, observation_mode=False, distance_configuration=False, model_organism=False, update_metadata=False, exp_ctr_frame=False,start_text='Not defined', experiment_name='Not defined', frame=None, VR_arena=False, quit_frame=False, display_experiment_settings=False, fix_metadata=False, convert_images_frame=False, time_dependent_stim_Frame=False, dynamic_VR_arena=False): self.controller = controller self.common_variables = CommonVariables(camera_class) self.camera_class = camera_class self.cam = self.camera_class.cam self.sub_subframe_cam = None if cam_frame: #self.camera_frame_func(subframe_preexperiment=subframe_preexperiment) self.camera_frame_func(frame=frame) if misc_frame: self.misc_frame_func(subframe_preexperiment=subframe_preexperiment, observation_mode=observation_mode, distance_configuration=distance_configuration, model_organism=model_organism, update_metadata=update_metadata) self.experiment_control_frame_bool = exp_ctr_frame if self.experiment_control_frame_bool: self.experiment_control_frame( frame, VR_arena=VR_arena, start_text=start_text, experiment_name=experiment_name, dynamic_VR_arena = dynamic_VR_arena ) if quit_frame: self.quit_frame_func(frame) if display_experiment_settings: self.display_experiment_settings_frame_func( subframe_preexperiment, fix_metadata=fix_metadata ) if convert_images_frame: self.convert_images_frame_func(subframe_preexperiment) if time_dependent_stim_Frame: self.time_dependent_stimulus_frame(subframe_preexperiment) def experiment_control_frame(self, frame, VR_arena=False, start_text='Not defined', experiment_name='Not defined', dynamic_VR_arena=False): self.subframe_expcontrol = tk.LabelFrame(frame, text=experiment_name, font='Helvetica 18 bold') self.subframe_expcontrol.grid(row=1, column=1) self.sub_subframe_tracking = tk.LabelFrame(self.subframe_expcontrol, text='') self.sub_subframe_tracking.grid(row=7, column=0, columnspan=2) self.sub_subframe_exp_setting = tk.LabelFrame(self.subframe_expcontrol, text='') self.sub_subframe_exp_setting.grid(row=6, column=0,columnspan=2) # fix dimesions of the frame - otherwise have ugly re-sizing when long or short names if RASPBERRY: self.sub_subframe_exp_setting.configure(height=70, width=400) else: self.sub_subframe_exp_setting.configure(height=70, width=300) self.sub_subframe_exp_setting.grid_propagate(0) self.genotypelabel = tk.Label(self.subframe_expcontrol, text='Exp. Group:') self.genotypelabel.grid(row=2, column=0) self.genotype_entry = tk.Entry(self.subframe_expcontrol, width=30, textvariable=self.controller.all_common_variables.genotype_entry_variable) self.genotype_entry.grid(row=2, column=1) if VR_arena: if dynamic_VR_arena: self.select_vr_arena_button = tk.Button( self.subframe_expcontrol, text='Select VR arena', command=lambda: self.controller.all_common_functions.select_vr_arena_func(dynamic_VR=True) ) else: self.select_vr_arena_button = tk.Button( self.subframe_expcontrol, text='Select VR arena', command=lambda: self.controller.all_common_functions.select_vr_arena_func(dynamic_VR=False) ) self.select_vr_arena_button.grid(row=3, column=0) if not dynamic_VR_arena: self.downscale_arena_label = tk.Label( self.subframe_expcontrol, text = 'Adjust Power[%]') self.downscale_arena_label.grid(row=4, column=0) self.downscale_arena_entry = tk.Entry( self.subframe_expcontrol, width=5, textvariable=self.controller.all_common_variables.vr_intensity_adjustment_variable) self.downscale_arena_entry.grid(row=5, column=0) # call the plotting library and plot the empty arena into a figure self.fig = Figure(figsize=(2, 1)) self.ax_vr_arena = self.fig.add_subplot(111) if not dynamic_VR_arena: self.image_of_arena = self.ax_vr_arena.imshow( self.controller.all_common_variables.vr_arena, vmin=0, vmax=PWM_RANGE ) else: self.image_of_arena = self.ax_vr_arena.imshow( self.controller.all_common_variables.vr_arena, vmin=0, vmax=255 ) # move the axis to the left (-0.3 points for now) # todo make nicer pos1 = self.ax_vr_arena.get_position() # get the original position pos2 = [pos1.x0 - 0.2, pos1.y0, pos1.width / 1.0, pos1.height / 1.0] self.ax_vr_arena.set_position(pos2) # set a new position # Now adding the colorbar # todo make nicer # [xpos, ypos, probably limitx and limit y) cbaxes = self.fig.add_axes([0.6, 0.1, 0.03, 0.8]) self.fig.colorbar(self.image_of_arena, cax=cbaxes) #self.fig.colorbar(self.image_of_arena) # turn off the labels and axis to save space self.ax_vr_arena.axes.get_xaxis().set_ticks([]) self.ax_vr_arena.axes.get_yaxis().set_ticks([]) # bind the plot to the GUI self.canvas = FigureCanvasTkAgg(self.fig, master=self.subframe_expcontrol) self.canvas.draw() self.canvas.get_tk_widget().grid(row=3, column=1, columnspan=1, rowspan=3) # plt.tight_layout() if RASPBERRY or virtual_raspberry: #self.pathlabel = tk.Label(self.subframe_expcontrol, text='Save in Folder: ~Desktop/',justify='right') #self.pathlabel.grid(row=0, column=0) path_label = tk.Label(self.subframe_expcontrol, text='Save in:') path_label.grid(row=0, column=0, columnspan=1) # instead of an entry use button: path_to_save_experiment = tk.Button(self.subframe_expcontrol, text='Press to select folder', command = self.controller.all_common_functions.select_folder_to_save_exp_func, textvariable= self.controller.all_common_variables.path_entry_variable, width = 30) path_to_save_experiment.grid(row=0, column=1, columnspan=1) #self.path_entry = tk.Entry(self.subframe_expcontrol, # width=30, # textvariable = self.controller.all_common_variables.path_entry_variable) #self.path_entry.grid(row=0, column=1) #if previous_variables != None: # try: # self.path.insert(tk.END, previous_variables['path']) # except: # self.path.insert(tk.END, '/home/pi/Desktop/output/') #else: # self.path.insert(tk.END, '/home/pi/Desktop/output/') # # todo - to save space save /home/pi/ as a variable, print desktop as a label so that user only enters # # the folder on the desktop - should make it much more tidy and ideally no need for the / anymore! else: # in case not on Raspberry self.pathlabel = tk.Label(self.subframe_expcontrol, textvariable=self.controller.all_common_variables.image_path) self.pathlabel.grid(row=0, column=0) pathbutton = tk.Button(self.subframe_expcontrol, text='Press to select data to analyze', command=self.controller.all_common_functions.select_images) pathbutton.grid(row=1, column=0) if not RASPBERRY and not virtual_raspberry: self.display_frameratelabel = tk.Label(self.subframe_expcontrol, text='display framerate') self.display_frameratelabel.grid(row=2, column=1) self.display_framerate = tk.Text(self.subframe_expcontrol, height=1, width=5) self.display_framerate.grid(row=3, column=1) if previous_variables is not None: try: self.display_framerate.insert(tk.END, previous_variables['display framerate']) except: self.display_framerate.insert(tk.END, '2') else: self.display_framerate.insert(tk.END, '2') if RASPBERRY or virtual_raspberry: self.recordingtime_label = tk.Label(self.sub_subframe_tracking, text='Recording Time[s]') self.recordingtime_label.grid(row=0, column=0) self.recordingtime_entry = tk.Entry(self.sub_subframe_tracking, width=5, textvariable=self.controller.all_common_variables.recording_time_variable) self.recordingtime_entry.grid(row=1, column=0) # Currently this seems to be the best way - this function # should be defined in each class as it can be widely # different between classes (both in which module/function to # call as well as arguments passed). # The current solution is to outsource this to the # controller which then calls the function (which must # always have the same name: "start_experiment_function") and # it should be obvious and easy to understand which function # with which arguments is called in each window. self.start_tracking_button = tk.Button( self.sub_subframe_tracking, text=start_text, command=lambda: self.controller.call_start_experiment_function( self.controller.current_window)) self.start_tracking_button.grid(row=2, column=0) if experiment_name == 'Image Sequence': image_format_frame = tk.Frame( self.sub_subframe_tracking, borderwidth=2, relief='groove') image_format_frame.grid(row=0, column=1, rowspan=3) image_format_label = tk.Label( image_format_frame, text='Image Format') image_format_label.grid(row=0, column=0) image_format_option = tk.OptionMenu( image_format_frame, self.controller.all_common_variables.image_sequence_format_var, *self.controller.all_common_variables.image_sequence_format_options) image_format_option.grid(row=1, column=0) # print pixel per mm next to start experiment button self.pixel_per_mm_label_left = tk.Label( self.sub_subframe_exp_setting, text='Pixel/mm: ') self.pixel_per_mm_label_left.grid(row=0, column=0, sticky='W') self.pixel_per_mm_label_right = tk.Label( self.sub_subframe_exp_setting, textvariable=self.controller.all_common_variables.pixel_per_mm_var) self.pixel_per_mm_label_right.grid(row=0, column=1, sticky='W') ''' self.debug_mode_label_left = tk.Label(self.sub_subframe_exp_setting, text='Debug Mode: ') self.debug_mode_label_left.grid(row=2, column=0, sticky='W') if experiment_name == 'Online Tracking' \ or experiment_name == 'Closed Loop stimulation': self.debug_mode_label_right = tk.Label( self.sub_subframe_exp_setting, textvariable=self.controller.all_common_variables.debug_mode_var) else: self.debug_mode_label_right = tk.Label(self.sub_subframe_exp_setting, text='NA') self.debug_mode_label_right.grid(row=2, column=1, sticky='W') ''' # Show the body part that has been defined as the defining # x/y position for the presentation of the virtual arena self.vr_stim_part_label_left = tk.Label( self.sub_subframe_exp_setting, text='VR stim at:') self.vr_stim_part_label_left.grid(row=2, column=0, sticky='W') if experiment_name == 'Closed Loop stimulation'\ or experiment_name == 'Dynamic VR': self.vr_stim_part_label_right = tk.Label( self.sub_subframe_exp_setting, textvariable=self.controller.all_common_variables.vr_stim_loc_var ) else: self.vr_stim_part_label_right = tk.Label( self.sub_subframe_exp_setting, text='N/A') self.vr_stim_part_label_right.grid(row=2, column=1, sticky='W') show_framerate_label_left = tk.Label(self.sub_subframe_exp_setting, text='Framerate:') show_framerate_label_left.grid(row=1, column=0, sticky='W') show_framerate_label_right = tk.Label( self.sub_subframe_exp_setting, textvariable=self.controller.all_common_variables.framerate_entry_variable) show_framerate_label_right.grid(row=1, column=1, sticky='W') self.animal_detection_method_label_left = tk.Label( self.sub_subframe_exp_setting, text='Animal Detection:') self.animal_detection_method_label_left.grid(row=0, column=2, sticky='W') if experiment_name == 'Online Tracking' \ or experiment_name == 'Closed Loop stimulation' \ or experiment_name == 'Dynamic VR': self.animal_detection_method_label_right = tk.Label( self.sub_subframe_exp_setting, textvariable=self.controller.all_common_variables.animal_detection_method_var) else: self.animal_detection_method_label_right = tk.Label( self.sub_subframe_exp_setting, text='N/A') self.animal_detection_method_label_right.grid( row=0, column=3, sticky='W') show_resolution_label_left = tk.Label( self.sub_subframe_exp_setting, text='Cam Resolution:') show_resolution_label_left.grid(row=1, column=2, sticky='W') show_resolution_label_right = tk.Label( self.sub_subframe_exp_setting, textvariable=self.controller.all_common_variables.resolution_variable) show_resolution_label_right.grid(row=1, column=3, sticky='W') # print organism next to start experiment button self.organism_label_left = tk.Label( self.sub_subframe_exp_setting, text='Animal: ') self.organism_label_left.grid(row=2,column=2, sticky='W') self.organims_label_right = tk.Label( self.sub_subframe_exp_setting, textvariable = self.controller.all_common_variables.model_organism_variable) self.organims_label_right.grid(row=2, column=3, sticky='W') def quit_frame_func(self, frame): """ This function handles the options in "File" of the menubar. """ self.subframe_quit = tk.LabelFrame(frame, text='') self.subframe_quit.grid(row=8, column=0, sticky='W') self.apply_button = tk.Button( self.subframe_quit, text='Save changes', fg='blue', command=lambda: self.controller.all_common_functions.quit_sequence( save=True, exit=False)) self.apply_button.grid(row=0, column=0) self.exit_button = tk.Button( self.subframe_quit, text='Save and Exit', fg='green', command=lambda: self.controller.all_common_functions.quit_sequence( save=True, exit=True)) self.exit_button.grid(row=0, column=1) self.quit = tk.Button( self.subframe_quit, text='Discard and Exit', fg='red', command=lambda: self.controller.all_common_functions.quit_sequence( save=False, exit=True)) self.quit.grid(row=0, column=2) def misc_frame_func(self, subframe_preexperiment=False, observation_mode=False, distance_configuration=False, model_organism=False, update_metadata=False): ''' TODO: I don't think this is necessary - test if everything works if deleted! This function takes the left subframe below the camera control and defines several potential subframes :param subframe_preexperiment: :param observation_mode: If set to True, will construct another subframe called sub_subframe_observation_mode which will host a menu where the user can choose how to display what the algorithm is collecting while the experiment is running. There will also be an option of how large the observation shall be displayed with 1 being the original. The larger, the more CPU power is needed for displaying and the less resources are available for the actual recording/tracking :param distance_configuration: If set to True, will construct another subframe called sub_subframe_config_dist which has a text field that will either display 'None' if the pixel per mm ratio is unknown or the measured pixel per mm ratio. Below that field a button is constructed that will call the function *distance_configuration_func* from the *CommonFunctions* class through the controller. :param model_organism: If set to True, will construct a subframe called sub_subframe_model_organism which has an option menu with which the user will be able to select the model organism she's working with. :return: ''' self.sub_subframe_misc = tk.LabelFrame(subframe_preexperiment, text='Other options') self.sub_subframe_misc.grid(row=2, column=0) #if distance_configuration: # # Then the buttons are constructed # self.sub_subframe_config_dist = tk.LabelFrame(self.sub_subframe_misc, text='Pixel per mm') # self.sub_subframe_config_dist.grid(row=0, column=0) # # self.distance_label = tk.Label(self.sub_subframe_config_dist, # textvariable=self.controller.all_common_variables.display_pixel_per_mm_variable) # self.distance_label.grid(row=0, column=1) # self.controller.all_common_variables.display_pixel_per_mm_variable.set( # repr(self.controller.all_common_variables.pixel_per_mm_var.get())) # # self.distance_button = tk.Button(self.sub_subframe_config_dist, text='configure dist', # command=self.controller.all_common_functions.distance_configuration_func) # self.distance_button.grid(row=1, column=1) #if model_organism: # self.sub_subframe_model_organism = tk.LabelFrame(self.sub_subframe_misc, text='Choose the organism') # self.sub_subframe_model_organism.grid(row=0, column=1) # # self.model_organism_menu = tk.OptionMenu(self.sub_subframe_model_organism, # self.controller.all_common_variables.model_organism_variable, # *self.controller.all_common_variables.available_model_organisms) # self.model_organism_menu.grid(row=0, column=0) #if observation_mode: # self.sub_subframe_observation_mode = tk.LabelFrame(self.sub_subframe_misc, text='Preview mode') # self.sub_subframe_observation_mode.grid(row=0, column=2) # # self.previewmode_menu = tk.OptionMenu(self.sub_subframe_observation_mode, # self.controller.all_common_variables.experiment_observation_mode, # *self.common_variables.available_modes) # self.previewmode_menu.grid(row=0, column=0, columnspan=2) # # self.preview_resize_label = tk.Label(self.sub_subframe_observation_mode, text='Magnification') # self.preview_resize_label.grid(row=1, column=0) # # self.preview_size_menu = tk.OptionMenu(self.sub_subframe_observation_mode, # self.controller.all_common_variables.observation_resize_variable, # *self.common_variables.observation_resize_options) # self.preview_size_menu.grid(row=1, column=1) if update_metadata: self.sub_subframe_update_metadata = tk.LabelFrame(self.sub_subframe_misc, text='Update Metadata') self.sub_subframe_update_metadata.grid(row=0, column=3) self.update_metadata_button = tk.Button(self.sub_subframe_update_metadata, text='Press to save metadata', command=self.controller.all_common_functions.overwrite_metadata) self.update_metadata_button.grid(row=0, column=0) self.adjust_arena_to_animal = None def display_experiment_settings_frame_func(self, subframe_preexperiment, fix_metadata=False): self.display_experiment_settings_frame = tk.LabelFrame(subframe_preexperiment, text='Experiment Settings') self.display_experiment_settings_frame.grid(row=1, column=0) self.pathbutton = tk.Button(self.display_experiment_settings_frame, text='Select data to analyze', command=lambda: self.controller.all_common_functions.select_images( display_settings=True)) self.pathbutton.grid(row=0, column=0, columnspan=2) self.pathchosen = tk.Label(self.display_experiment_settings_frame, text='no data chosen yet') self.pathchosen.grid(row=1, column=0, columnspan=2) self.experiment_date_n_time_frame = tk.LabelFrame(self.display_experiment_settings_frame, text='Experiment Date/Time') self.experiment_date_n_time_frame.grid(row=2, column=0, sticky='nsew') self.experiment_date_n_time_label = tk.Label(self.experiment_date_n_time_frame, text='') self.experiment_date_n_time_label.grid(row=0, column=0) if fix_metadata: self.experiment_date_n_time_update_button = \ tk.Button(self.experiment_date_n_time_frame, text='Change', command=lambda: self.controller.all_common_functions.metadata_fix_date_time()) self.experiment_date_n_time_update_button.grid(row=1, column=0) self.genotype_frame = tk.LabelFrame(self.display_experiment_settings_frame, text='Exp. group') #self.genotype_frame = tk.LabelFrame(self.display_experiment_settings_frame, text='Genotype') self.genotype_frame.grid(row=3, column=0, sticky='nsew') self.genotype_label = tk.Label(self.genotype_frame, text='') self.genotype_label.grid(row=0, column=0) self.species_frame = tk.LabelFrame(self.display_experiment_settings_frame, text='Species') self.species_frame.grid(row=4, column=0, sticky='nsew') self.species_label = tk.Label(self.species_frame, text='') self.species_label.grid(row=0, column=0) if fix_metadata: self.update_metadata_organism_button = tk.Button(self.species_frame, text='Change', command=lambda: self.controller.all_common_functions.metadata_fix_organism()) self.update_metadata_organism_button.grid(row=1, column=0) self.resolution_frame = tk.LabelFrame(self.display_experiment_settings_frame, text='Resolution') self.resolution_frame.grid(row=5, column=0, sticky='nsew') self.resolution_label = tk.Label(self.resolution_frame, text='') self.resolution_label.grid(row=0, column=0) self.recording_time_frame = tk.LabelFrame(self.display_experiment_settings_frame, text='Recorded Time') self.recording_time_frame.grid(row=2, column=1, sticky='nsew') self.recording_time_label = tk.Label(self.recording_time_frame, text='') self.recording_time_label.grid(row=0, column=0) self.framerate_label_frame = tk.LabelFrame(self.display_experiment_settings_frame, text='Framerate') self.framerate_label_frame.grid(row=3, column=1, sticky='nsew') self.framerate_label = tk.Label(self.framerate_label_frame, text='') self.framerate_label.grid(row=0, column=0) self.timestamps_frame = tk.LabelFrame(self.display_experiment_settings_frame, text='Timestamps') self.timestamps_frame.grid(row=4, column=1, sticky='nsew') self.timestamps_label = tk.Label(self.timestamps_frame, text='') self.timestamps_label.grid(row=0, column=0) self.pixel_per_mm_frame = tk.LabelFrame(self.display_experiment_settings_frame, text='Pixel per mm') self.pixel_per_mm_frame.grid(row=5, column=1, sticky='nsew') self.pixel_per_mm_label = tk.Label(self.pixel_per_mm_frame, text='') self.pixel_per_mm_label.grid(row=0, column=0) if fix_metadata: self.update_metadata_pixel_per_mm_button = tk.Button(self.pixel_per_mm_frame, text='Change', command=self.controller.all_common_functions.distance_configuration_func) self.update_metadata_pixel_per_mm_button.grid(row=1, column=0) def convert_images_frame_func(self, subframe_preexperiment): """ This function is used to construct the frame "Simulate online tracking". There is a commented part that would allow the user to select particular sets of images to use for tracking. Ideally image selection should now be done in 'Tools->Image data handling'. Afterwards, the 'Simulate online tracking' can be used. """ self.convert_images_frame = tk.LabelFrame(subframe_preexperiment, text='') self.convert_images_frame.grid(row=2, column=0) ''' # I think for most people this is confusing, take out for now # Define how to look for images self.common_string_frame = tk.LabelFrame( self.convert_images_frame, text='Define names of exp. images') self.common_string_frame.grid(row=0, column=0, columnspan=3) self.common_str_label = tk.Label( self.common_string_frame, text='common image string ' '\n(image*.jpg, *.png...)') self.common_str_label.grid(row=1, column=0) self.common_str = tk.Entry(self.common_string_frame, width=8) self.common_str.grid(row=2, column=0) # Better to have the user explicitly call for an update - as the folders with images is likely to be really full # the updating might take a noticable amount of time (I tested 4500images, took several seconds) self.common_str_update_button = tk.Button(self.common_string_frame, text='update # of images', command=self.controller.all_common_functions.common_str_update_func) self.common_str_update_button.grid(row=1, column=1) self.common_str_frame = tk.LabelFrame(self.common_string_frame, text='Number of Images') self.common_str_frame.grid(row=2, column=1) self.common_str_counted = tk.Label(self.common_str_frame, text='') self.common_str_counted.grid(row=5, column=0) ''' ############# # DONT DELETE YET # button that lets user convert the jpgs in a given folder to a npy array explicitly #self.convert_single_images_frame = tk.LabelFrame(self.convert_images_frame, text='Conversion') #self.convert_single_images_frame.grid(row=0, column=1) # #self.convert_single_images_choose_output_label = tk.Label(self.convert_single_images_frame, # text='Target Format') #self.convert_single_images_choose_output_label.grid(row=0, column=0) # #self.convert_single_images_choose_output_option = tk.OptionMenu(self.convert_single_images_frame, # self.controller.all_common_variables.convert_image_output_variable, # *self.controller.all_common_variables.convert_image_output_options) #self.convert_single_images_choose_output_option.grid(row=1, column=0) # #self.convert_single_images_button = tk.Button(self.convert_single_images_frame, text='Convert single images', # command=self.controller.all_common_functions.convert_single_images_func) #self.convert_single_images_button.grid(row=3, column=0) self.playback_speed_label = tk.Label( self.convert_images_frame, text='Playback speed') self.playback_speed_label.grid(row=1, column=0) self.playback_speed_optionmenu = tk.OptionMenu( self.convert_images_frame, self.controller.all_common_variables.playback_speed_var, *self.controller.all_common_variables.playback_speed_options ) self.playback_speed_optionmenu.grid(row=2, column=0) self.animal_detection_method_simulation_label_top = tk.Label( self.convert_images_frame, text='Animal Detection') self.animal_detection_method_simulation_label_top.grid(row=1, column=1) self.animal_detection_method_stimulation_label_bottom = \ tk.Label(self.convert_images_frame, textvariable=self.controller.all_common_variables.animal_detection_method_var) self.animal_detection_method_stimulation_label_bottom.grid(row=2, column=1) ''' self.debug_model_label_top = tk.Label(self.convert_images_frame, text='Debug Mode:') self.debug_model_label_top.grid(row=1, column=2) self.debug_model_label_bottom = tk.Label( self.convert_images_frame, textvariable=self.controller.all_common_variables.debug_mode_var) self.debug_model_label_bottom.grid(row=2, column=2) ''' self.track_button = tk.Button( subframe_preexperiment, text='Track single animal', command=lambda: self.controller.call_start_experiment_function(self.controller.current_window)) self.track_button.grid(row=3, column=0, columnspan=2) def time_dependent_stimulus_frame(self, frame): self.subframe_timedep = tk.LabelFrame(self.subframe_expcontrol, text='Time dependent Stimulation') self.subframe_timedep.grid(row=3, column=0, columnspan=2) self.select_timedep_stim = tk.Button(self.subframe_timedep, text='Select Time Dependent Stim File', command=self.controller.all_common_functions.select_time_dependent_stim_func) self.select_timedep_stim.grid(row=0, column=0) #self.chosen_timedep_file = tk.Label(self.subframe_timedep, text='None selected') self.chosen_timedep_file_label = tk.Label(self.subframe_timedep, textvariable=self.controller.all_common_variables.chosen_timedep_file_display_var) self.chosen_timedep_file_label.grid(row=1, column=0) # def batch_analysis(self, subframe_preexperiment): # """ # Create the frame with the batch tools option # :param subframe_preexperiment: # :return: # """ # self.multilplecheck = tk.Checkbutton(self, text='Batch Analysis', # variable = self.controller.all_common_variables.multiple_folder_analysis_var, # onvalue=True, offvalue=False) # self.controller.all_common_variables.multiple_folder_analysis_var.set(False) # todo - make saveable using previous variables # self.multiplecheck.grid() def camera_frame_func(self, frame): if RASPBERRY or virtual_raspberry: self.sub_subframe_cam = tk.LabelFrame(frame, text='Camera Control', font='Helvetica 18 bold') self.sub_subframe_cam.grid(row=0, column=1, sticky='W') # the camera ON button self.cam_on_button = tk.Button(self.sub_subframe_cam, text='Cam On', fg='green', command=self.controller.all_common_functions.cam_on_func) self.cam_on_button.grid(row=0, column=1) # the camera OFF button self.cam_off_button = tk.Button(self.sub_subframe_cam, text='Cam Off', fg='red', command=self.controller.all_common_functions.cam_off_func) self.cam_off_button.grid(row=0, column=2) # the preview size scale self.preview_size_scale = tk.Scale(self.sub_subframe_cam, from_=180, to=1000, resolution=20, label='Preview Window Size', variable=self.controller.all_common_variables.preview_window_size_variable, orient='horizontal', len=180) self.preview_size_scale.grid(row=0, column=0, columnspan=1, rowspan=2) self.preview_size_scale.set(180) class CommonFunctions(): def __init__(self, camera_class, controller, private=False): self.controller = controller self.camera_class = camera_class self.cam = self.camera_class.cam def update_framerate_func(self, new_framerate): if RASPBERRY: # The camera can only support a given framerate at a given resolution. See full docs here: # https://picamera.readthedocs.io/en/release-1.13/fov.html # I'm pretty sure that the Camera (F) from Waveshare is v1 module as 5MP are indicated (which is pretty much # 2592x1944 if self.controller.all_common_variables.resolution == '640x480': if new_framerate <= 90 and new_framerate > 0: self.cam.framerate = new_framerate else: tk.messagebox.showerror("Error", "'With resolution of 640x480 the \nframerate must be between 1 and 90") print('With resolution of 640x480 the framerate must be between 1 and 90') elif self.controller.all_common_variables.resolution == '1024x784': if new_framerate <= 42 and new_framerate > 0: self.cam.framerate = new_framerate else: tk.messagebox.showerror("Error", "'With resolution of 1024x784 the \nframerate must be between 1 and 42") print('With resolution of 1024x784 the framerate must be between 1 and 42') elif self.controller.all_common_variables.resolution == '1296x972': if new_framerate <= 42 and new_framerate > 0: self.cam.framerate = new_framerate else: tk.messagebox.showerror("Error", "'With resolution of 1296x972 the \nframerate must be between 1 and 42") print('With resolution of 1296x972 the framerate must be between 1 and 42') elif self.controller.all_common_variables.resolution == '1920x1080': if new_framerate <= 30 and new_framerate > 0: self.cam.framerate = new_framerate else: tk.messagebox.showerror("Error", "'With resolution of 1920x1080 the \nframerate must be between 1 and 15") print('With resolution of 1920x1080 the framerate must be between 1 and 30') elif self.controller.all_common_variables.resolution == '2592x1944': if new_framerate <= 15 and new_framerate > 0: self.cam.framerate = new_framerate else: tk.messagebox.showerror("Error", "'With resolution of 2592x1944 the \nframerate must be between 1 and 15") print('With resolution of 2592x1944 the framerate must be between 1 and 15') else: tk.messagebox.showwarning("Information", "With resolution of 640x480 \nthe framerate must be between 1 and 90") print('you have pressed the update framerate button') def menu_callback_shared(self, cam, backlight, analog_output_one): # , backlight, analog_output_one):#, backlight,analog_output_one): self.controller.after(700, lambda: self.menu_callback_shared(cam, backlight, analog_output_one)) if cam: if RASPBERRY: # if self.cam.framerate != int(self.controller.sub_frames.recording_framerate.get("1.0", 'end-1c')): # if int(self.controller.sub_frames.recording_framerate.get("1.0", 'end-1c')) > 90 or int( # self.controller.sub_frames.recording_framerate.get("1.0", 'end-1c')) < 1: # print('please enter a framerate between 1 and 90') # else: # self.cam.framerate = int(self.controller.sub_frames.recording_framerate.get("1.0", 'end-1c')) # print('set Framerate to: +' + repr(self.cam.framerate)) if self.controller.all_common_variables.resolution != self.controller.all_common_variables.resolution_variable.get(): if self.controller.all_common_variables.resolution_variable.get() == '640x480': self.controller.all_common_variables.resolution = '640x480' self.cam.resolution = (640, 480) self.controller.all_common_variables.pixel_per_mm_var.set(0) print('Changed resolution to 640x480') if self.controller.all_common_variables.resolution_variable.get() == '1024x784': self.controller.all_common_variables.resolution = '1024x784' self.cam.resolution = (1024, 784) self.controller.all_common_variables.pixel_per_mm_var.set(0) print('Changed resolution to 1024x784') if self.controller.all_common_variables.resolution_variable.get() == '1296x972': self.controller.all_common_variables.resolution = '1296x972' self.cam.resolution = (1296, 972) self.controller.all_common_variables.pixel_per_mm_var.set(0) print('Changed resolution to 1296x730') if self.controller.all_common_variables.resolution_variable.get() == '1920x1080': self.controller.all_common_variables.resolution = '1920x1080' self.cam.resolution = (1920, 1080) self.controller.all_common_variables.pixel_per_mm_var.set(0) print('Changed resolution to 1920x1080') if self.controller.all_common_variables.resolution_variable.get() == '2592x1944': self.controller.all_common_variables.resolution = '2592x1944' self.cam.resolution = (2592, 1944) self.controller.all_common_variables.pixel_per_mm_var.set(0) print('Changed resolution to 2592x1944') # In case the arena has been defined, redraw # the overlay by calling the function if self.controller.all_common_variables.overlay is not None: self.controller.all_common_functions.preview_overlay_func() # Check whether the user has used the scale to change preview window size by comparing the variable that # the preview window size is currently set to, to the value that the variable that is bound to the scale if self.controller.all_common_variables.preview_window_size_value != \ self.controller.all_common_variables.preview_window_size_variable.get(): # If the current preview window size value is different to the variable that is bound to the scale first # change the preview window size value to the value defined by the variable self.controller.all_common_variables.preview_window_size_value = \ self.controller.all_common_variables.preview_window_size_variable.get() # To be a bit more concise, define the size variable size = self.controller.all_common_variables.preview_window_size_value # then change the preview window size to the requested size self.cam.preview_window = (0, 0, int(size), int(size) ) # After changing the preview window size, the script checks if a VR overlay is present. If yes # it's size needs to be adjusted as well! if self.controller.all_common_variables.overlay is not None: self.controller.all_common_variables.overlay.window = \ (0, 0, int(size), int(size) ) if backlight: if RASPBERRY: # Check whether the user has used the scale to change backlight intensity by comparing the variable that # the background intensity is currently set to, to the value that the variable that is bound to the scale if self.controller.all_common_variables.backlight_intensity_value != \ self.controller.all_common_variables.backlight_intensity_variable.get(): # If the current backlight intensity value is different to the variable that is bound to the scale self.controller.all_common_variables.backlight_intensity_value = \ self.controller.all_common_variables.backlight_intensity_variable.get() # set the PWM dutycycle to value chosen by user. # Manual: Starts hardware PWM on a GPIO at the specified frequency and dutycycle. # http://abyz.me.uk/rpi/pigpio/python.html#hardware_PWM #self.controller.all_common_variables.pwm_object.hardware_PWM(BACKGROUND_GPIO, 3000000, # self.controller.all_common_variables.backlight_intensity_value) for i in range(len(self.controller.all_common_variables.background)): if self.controller.all_common_variables.background[i][1] > MAX_PWM_FREQ: self.controller.all_common_variables.pwm_object.hardware_PWM( self.controller.all_common_variables.background[i][0], self.controller.all_common_variables.background[i][1], self.controller.all_common_variables.backlight_intensity_value) else: self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( self.controller.all_common_variables.background[i][0], int(round(self.controller.all_common_variables.backlight_intensity_value* (self.controller.all_common_variables.pwm_range/1000000)))) # Check whether the user has used the scale to change backlight intensity by comparing the variable that # the background intensity is currently set to, to the value that the variable that is bound to the scale if self.controller.all_common_variables.backlight_two_intensity_value != \ self.controller.all_common_variables.backlight_two_intensity_variable.get(): # If the current backlight intensity value is different to the variable that is bound to the scale self.controller.all_common_variables.backlight_two_intensity_value = \ self.controller.all_common_variables.backlight_two_intensity_variable.get() # set the PWM dutycycle to value chosen by user. # Manual: Starts hardware PWM on a GPIO at the specified frequency and dutycycle. # http://abyz.me.uk/rpi/pigpio/python.html#hardware_PWM for i in range(len(self.controller.all_common_variables.background_two)): if self.controller.all_common_variables.background_two[i][1] > MAX_PWM_FREQ: self.controller.all_common_variables.pwm_object.hardware_PWM( self.controller.all_common_variables.background_two[i][0], self.controller.all_common_variables.background_two[i][1], self.controller.all_common_variables.backlight_two_intensity_value) else: self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( self.controller.all_common_variables.background_two[i][0], int(round(self.controller.all_common_variables.backlight_two_intensity_value* (self.controller.all_common_variables.pwm_range/1000000)))) print('backlight intensity value updated to: ' + repr(self.controller.all_common_variables.backlight_two_intensity_value)) if analog_output_one: if RASPBERRY: # Check whether the user has used the scale to change analog output intensity by comparing the variable that # the analog output intensity is currently set to, to the value that the variable that is bound to the scale if self.controller.all_common_variables.channel_one_dutycycle != \ self.controller.all_common_variables.channel_one_variable.get(): # If the current analog output intensity value is different to the variable that is bound to the scale self.controller.all_common_variables.channel_one_dutycycle = \ self.controller.all_common_variables.channel_one_variable.get() for i in range(len(self.controller.all_common_variables.channel_one)): if self.controller.all_common_variables.channel_one[i][1] > MAX_PWM_FREQ: self.controller.all_common_variables.pwm_object.hardware_PWM( gpio=self.controller.all_common_variables.channel_one[i][0], PWMfreq=self.controller.all_common_variables.channel_one[i][1], PWMduty=int(self.controller.all_common_variables.channel_one_dutycycle* (1000000/self.controller.all_common_variables.pwm_range))) # NOTE: Not sure if this is the best way as it might mask problems for users! else: if self.controller.all_common_variables.high_power_LEDs_bool.get(): self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=self.controller.all_common_variables.channel_one[i][0], dutycycle=int(self.controller.all_common_variables.pwm_range - self.controller.all_common_variables.channel_one_dutycycle)) else: self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=self.controller.all_common_variables.channel_one[i][0], dutycycle=self.controller.all_common_variables.channel_one_dutycycle) if self.controller.all_common_variables.channel_two_dutycycle != \ self.controller.all_common_variables.channel_two_variable.get(): # If the current analog output intensity value is different to the variable that is bound to the scale self.controller.all_common_variables.channel_two_dutycycle = \ self.controller.all_common_variables.channel_two_variable.get() for i in range(len(self.controller.all_common_variables.channel_two)): if self.controller.all_common_variables.channel_two[i][1] > MAX_PWM_FREQ: self.controller.all_common_variables.pwm_object.hardware_PWM( gpio=self.controller.all_common_variables.channel_two[i][0], PWMfreq=self.controller.all_common_variables.channel_two[i][1], PWMduty=int(self.controller.all_common_variables.channel_two_dutycycle* (1000000/self.controller.all_common_variables.pwm_range))) # NOTE: Not sure if this is the best way as it might mask problems for users! else: if self.controller.all_common_variables.high_power_LEDs_bool.get(): self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=self.controller.all_common_variables.channel_two[i][0], dutycycle=int(self.controller.all_common_variables.pwm_range - self.controller.all_common_variables.channel_two_dutycycle)) else: self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=self.controller.all_common_variables.channel_two[i][0], dutycycle=self.controller.all_common_variables.channel_two_dutycycle) if self.controller.all_common_variables.channel_three_dutycycle != \ self.controller.all_common_variables.channel_three_variable.get(): # If the current analog output intensity value is different to the variable that is bound to the scale self.controller.all_common_variables.channel_three_dutycycle = \ self.controller.all_common_variables.channel_three_variable.get() for i in range(len(self.controller.all_common_variables.channel_three)): if self.controller.all_common_variables.channel_three[i][1] > MAX_PWM_FREQ: self.controller.all_common_variables.pwm_object.hardware_PWM( gpio=self.controller.all_common_variables.channel_three[i][0], PWMfreq=self.controller.all_common_variables.channel_three[i][1], PWMduty=int(self.controller.all_common_variables.channel_three_dutycycle* (1000000/self.controller.all_common_variables.pwm_range))) # NOTE: Not sure if this is the best way as it might mask problems for users! else: if self.controller.all_common_variables.high_power_LEDs_bool.get(): self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=self.controller.all_common_variables.channel_three[i][0], dutycycle=int(self.controller.all_common_variables.pwm_range - self.controller.all_common_variables.channel_three_dutycycle)) else: self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=self.controller.all_common_variables.channel_three[i][0], dutycycle=self.controller.all_common_variables.channel_three_dutycycle) if self.controller.all_common_variables.channel_four_dutycycle != \ self.controller.all_common_variables.channel_four_variable.get(): # If the current analog output intensity value is different to the variable that is bound to the scale self.controller.all_common_variables.channel_four_dutycycle = \ self.controller.all_common_variables.channel_four_variable.get() for i in range(len(self.controller.all_common_variables.channel_four)): if self.controller.all_common_variables.channel_four[i][1] > MAX_PWM_FREQ: self.controller.all_common_variables.pwm_object.hardware_PWM( gpio=self.controller.all_common_variables.channel_four[i][0], PWMfreq=self.controller.all_common_variables.channel_four[i][1], PWMduty=int(self.controller.all_common_variables.channel_four_dutycycle* (1000000/self.controller.all_common_variables.pwm_range))) # NOTE: Not sure if this is the best way as it might mask problems for users! else: if self.controller.all_common_variables.high_power_LEDs_bool.get(): self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=self.controller.all_common_variables.channel_four[i][0], dutycycle=int(self.controller.all_common_variables.pwm_range - self.controller.all_common_variables.channel_four_dutycycle)) else: self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=self.controller.all_common_variables.channel_four[i][0], dutycycle=self.controller.all_common_variables.channel_four_dutycycle) # if self.controller.sub_frames.distance_label.cget('text') != \ # repr(self.controller.all_common_variables.pixel_per_mm)[0:10]: # print('changing to ' + repr(self.controller.all_common_variables.pixel_per_mm)[0:10]) # self.controller.sub_frames.distance_label.configure( # text=repr(self.controller.all_common_variables.pixel_per_mm)[0:10]) # print(self.controller.sub_frames.distance_label.cget('text')) if self.controller.all_common_variables.experiment_observation_mode_output != \ self.controller.all_common_variables.experiment_observation_mode.get(): # todo - make into loop - less readability but easier to implement different versions # todo - somethings wrong with this - it doesn't seem to react to user input # for experiment_observation_mode_loop in range(len(self.controller.all_common_variables.available_modes)): # todo - doesn't change...why? if self.controller.all_common_variables.experiment_observation_mode.get() == 'only animal': self.controller.all_common_variables.experiment_observation_mode_output = 'only animal' print('only animal chosen') if self.controller.all_common_variables.experiment_observation_mode.get() == 'overview': self.controller.all_common_variables.experiment_observation_mode_output = 'overview' print('overview chosen') if self.controller.all_common_variables.experiment_observation_mode.get() == 'none': self.controller.all_common_variables.experiment_observation_mode_output = 'none' print('no preview will be displayed') if self.controller.all_common_variables.experiment_observation_mode.get() == 'debug': self.controller.all_common_variables.experiment_observation_mode_output = 'debug' print('debug mode selected') if self.controller.all_common_variables.model_organism_value != \ self.controller.all_common_variables.model_organism_variable.get(): self.controller.all_common_variables.model_organism_value = \ self.controller.all_common_variables.model_organism_variable.get() print('Model organism: ' + repr(self.controller.all_common_variables.model_organism_value) + ' selected!') def cam_on_func(self): print('cam on') # todo - delete if in final version if RASPBERRY: self.controller.all_common_variables.preview_bool = True size = int(self.controller.all_common_variables.preview_window_size_value) self.cam.resolution = self.controller.all_common_variables.resolution self.cam.preview_window = (0, 0, size, size) self.cam.zoom = (0, 0, 1, 1) self.cam.start_preview() self.cam.preview.fullscreen = False # if overlay was previously defined, re-create it if self.controller.all_common_variables.overlay is not None: self.controller.all_common_functions.preview_overlay_func() #self.controller.all_common_variables.overlay.layer = 3 # wait a second so the camera adjusts before the user has # the chance to change anything # TODO check if necessary! time.sleep(1) def cam_off_func(self): print("cam off") # todo - delete in final version if RASPBERRY: self.controller.all_common_variables.preview_bool = False self.cam.stop_preview() # if overlay is active remove it. if self.controller.all_common_variables.overlay is not None: try: self.controller.all_common_variables.cam.remove_overlay( self.controller.all_common_variables.overlay) except Exception as ex: # This happens when the user presses the "cam # off" button more than once... pass def distance_configuration_func(self): if RASPBERRY: if self.controller.all_common_variables.resolution == '640x480': resolution = [640, 480] if self.controller.all_common_variables.resolution == '1024x784': resolution = [1024, 784] if self.controller.all_common_variables.resolution == '1296x972': resolution = [1296, 972] if self.controller.all_common_variables.resolution == '1920x1080': resolution = [1920, 1080] if self.controller.all_common_variables.resolution == '2592x1944': resolution = [2592, 1944] distance_factor = \ distance_configuration_module.DistanceConfigurationLive(cam=self.cam, resolution=resolution, known_distance=self.controller.all_common_variables.known_distance) else: distance_factor = distance_configuration_module.DistanceConfigurationStatic( known_distance=self.controller.all_common_variables.known_distance) # This variable is the number that is used internally self.controller.all_common_variables.pixel_per_mm_var.set(round(distance_factor.distance_factor,3)) # Check what exactly this variable is doing and write in comments self.controller.all_common_variables.known_distance = distance_factor.known_distance self.controller.all_common_variables.display_pixel_per_mm_variable.set( repr(distance_factor.distance_factor)[0:10]) print('There are ' + repr(self.controller.all_common_variables.pixel_per_mm_var.get()) + ' pixel per mm ') try: # todo - probably don't need that! rounded_value = str(round(self.controller.all_common_variables.pixel_per_mm_var.get(),1)) self.controller.access_subframes( self.controller.current_window).sub_frames.pixel_per_mm_label.configure( text='Pixel/mm: ' + rounded_value) # todo - check if this is the best way to update the pixel_per_mm in the fix_metadata without breaking # Todo - online pixel_per_mm except: pass def select_folder_to_save_exp_func(self): self.controller.all_common_variables.path_entry_variable.set( filedialog.askdirectory(initialdir=self.controller.all_common_variables.path_entry_variable.get())) def select_images(self, display_settings=False): self.controller.all_common_variables.data_path = filedialog.askdirectory() self.controller.all_common_variables.image_path.set(self.controller.all_common_variables.data_path) os.chdir(self.controller.all_common_variables.data_path) if display_settings: self.controller.all_common_variables.path = self.controller.all_common_variables.data_path path_to_show = '...' + self.controller.all_common_variables.data_path[-30:] self.controller.access_subframes( self.controller.current_window).sub_frames.pathchosen.configure(text=path_to_show) try: with open((self.controller.all_common_variables.data_path + '/experiment_settings.json'), 'r') as file: self.controller.all_common_variables.experimental_metadata = json.load(file) # Comment on why I use try..except instead of if..else. It seems that in Python it is prefered to use # the try..except style if one does not expect too many excepts to come true. try: self.controller.access_subframes( self.controller.current_window).sub_frames.experiment_date_n_time_label.configure( text=self.controller.all_common_variables.experimental_metadata['Experiment Date and Time']) except KeyError: self.controller.access_subframes( self.controller.current_window).sub_frames.experiment_date_n_time_label.configure( text='No Data') try: self.controller.access_subframes( self.controller.current_window).sub_frames.framerate_label.configure( text=repr(self.controller.all_common_variables.experimental_metadata['Framerate']) + 'fps') self.controller.all_common_variables.framerate_read_from_experiment_settings = \ self.controller.all_common_variables.experimental_metadata['Framerate'] except KeyError: self.controller.access_subframes( self.controller.current_window).sub_frames.framerate_labelconfigure(text='No Data') self.controller.all_common_variables.framerate_read_from_experiment_settings = None try: self.controller.access_subframes( self.controller.current_window).sub_frames.recording_time_label.configure( text=repr( self.controller.all_common_variables.experimental_metadata['Recording time']) + 's') except KeyError: self.controller.access_subframes( self.controller.current_window).sub_frames.recording_time_label.configure(tex='No Data') try: self.controller.access_subframes( self.controller.current_window).sub_frames.resolution_label.configure( text=self.controller.all_common_variables.experimental_metadata['Resolution']) self.controller.all_common_variables.resolution_read_from_experiment_settings = \ self.controller.all_common_variables.experimental_metadata['Resolution'] except KeyError: self.controller.access_subframes( self.controller.current_window).sub_frames.resolution_label.configure(text='No Data') self.controller.all_common_variables.resolution_read_from_experiment_settings = None try: self.controller.access_subframes( self.controller.current_window).sub_frames.species_label.configure( text=self.controller.all_common_variables.experimental_metadata['Model Organism']) self.controller.all_common_variables.organism_read_from_experiment_settings = \ self.controller.all_common_variables.experimental_metadata['Model Organism'] except KeyError: self.controller.access_subframes( self.controller.current_window).sub_frames.species_label.configure(text='No Data') self.controller.all_common_variables.organism_read_from_experiment_settings = None # changed name of 'genotype' to 'exp. group' to be more generic. Reflect that change here and # make sure not to break backwards compatibility if 'Exp. group' in self.controller.all_common_variables.experimental_metadata: self.controller.access_subframes( self.controller.current_window).sub_frames.genotype_label.configure( text=self.controller.all_common_variables.experimental_metadata['Exp. group']) self.controller.all_common_variables.genotype_read_from_experiment_settings = \ self.controller.all_common_variables.experimental_metadata['Exp. group'] elif 'Genotype' in self.controller.all_common_variables.experimental_metadata: self.controller.access_subframes( self.controller.current_window).sub_frames.genotype_label.configure( text=self.controller.all_common_variables.experimental_metadata['Genotype']) self.controller.all_common_variables.genotype_read_from_experiment_settings = \ self.controller.all_common_variables.experimental_metadata['Genotype'] #try: # self.controller.access_subframes( # self.controller.current_window).sub_frames.genotype_label.configure( # text=self.controller.all_common_variables.experimental_metadata['Genotype']) # self.controller.all_common_variables.genotype_read_from_experiment_settings = \ # self.controller.all_common_variables.experimental_metadata['Genotype'] #except KeyError: # self.controller.access_subframes( # self.controller.current_window).sub_frames.genotype_label.configure(text='No Data') # self.controller.all_common_variables.genotype_read_from_experiment_settings = None try: self.controller.access_subframes( self.controller.current_window).sub_frames.pixel_per_mm_label.configure( text=round(self.controller.all_common_variables.experimental_metadata['Pixel per mm'],2)) self.controller.all_common_variables.pixel_per_mm_read_from_experiment_settings = \ round(self.controller.all_common_variables.experimental_metadata['Pixel per mm'],2) except KeyError: self.controller.access_subframes( self.controller.current_window).sub_frames.pixel_per_mm_label.configure(text='No Data') self.controller.all_common_variables.pixel_per_mm_read_from_experiment_settings = None except IOError: self.controller.access_subframes( self.controller.current_window).sub_frames.experiment_date_n_time_label.configure(text='No Data') self.controller.access_subframes( self.controller.current_window).sub_frames.framerate_label.configure(text='No Data') self.controller.access_subframes( self.controller.current_window).sub_frames.recording_time_label.configure(text='No Data') self.controller.access_subframes( self.controller.current_window).sub_frames.resolution_label.configure(text='No Data') self.controller.access_subframes( self.controller.current_window).sub_frames.species_label.configure(text='No Data') self.controller.access_subframes( self.controller.current_window).sub_frames.genotype_label.configure(text='No Data') self.controller.access_subframes( self.controller.current_window).sub_frames.pixel_per_mm_label.configure(text='No Data') try: self.timestamps = np.load('timestamps.npy') self.controller.access_subframes( self.controller.current_window).sub_frames.timestamps_label.configure(text='Found') except IOError: self.controller.access_subframes( self.controller.current_window).sub_frames.timestamps_label.configure(text='No Data') def common_str_update_func(self): self.controller.all_common_variables.entered_text = self.controller.access_subframes( self.controller.current_window).sub_frames.common_str.get() files_and_folders_common = [p.replace('\\', '') for p in glob('*' + self.controller.all_common_variables.entered_text + '*')] self.controller.access_subframes(self.controller.current_window).sub_frames.common_str_counted.configure( text=len(files_and_folders_common)) ''' # DONT DELETE YET # function is called when user wants to explicitly convert jpgs to a npy array def convert_single_images_func(self): if self.controller.all_common_variables.path is None: tk.messagebox.showerror("Error", "You have to select a\n" "path in order to convert images") elif self.controller.all_common_variables.entered_text is None: user_said_its_ok = tk.messagebox.askokcancel("Warning", "Do you only have images in the folder?\n" "If yes, press 'OK', otherwise 'Cancel'\n" "and enter a string for the extension of\n" "of the images!") if self.controller.all_common_variables.path is not None and \ (self.controller.all_common_variables.entered_text is not None or user_said_its_ok): # Figure out how many files must be read files_to_read = [p.replace('\\', '') for p in glob('*' + self.controller.access_subframes( self.controller.current_window).sub_frames.common_str.get("1.0", 'end-1c') + '*')] sorted_filed_to_read = natsorted(files_to_read) temp = imread(files_to_read[0]) height, width = temp.shape[0], temp.shape[1] """ # Todo!! Write a correction algorithm for missing frames (especially if very fast recording!) if self.timestamps is not None: # first calculate the time it took to take each frame # Note: The timestamps are not the true time the picture was taken - after the picture is taken the # time is written down before the next frame is taken. So the timestamps are not 'true' but give us a good # hint when the frame was captured timestamps_subtracted = self.timestamps[1:,0] - np.roll(self.timestamps[:,0],1)[1:] if timestamps_subtracted.any() < (1/self.framerate)*2: """ if self.controller.all_common_variables.convert_image_output_variable.get() == '.npy': """ saving as mmep as the advantage that one can build arrays that are larger than the avaiable memory The drawback is that how it's currently implemented it will take much more SD space than a normal numpy array """ array = np.zeros((height, width, len(files_to_read)), dtype=temp.dtype) # with open("All_images.npy", 'w') as image_file: # mmapData = np.memmap("all_images.npy", mode='w+', shape=(height, width, len(files_to_read)), # dtype=temp.dtype) for i in range(len(sorted_filed_to_read)): # print(i) temp = imread(sorted_filed_to_read[i]) try: array[:, :, i] = temp[:, :, 0] # mmapData[:, :, i] = temp[:, :, 0] except IndexError: # in case the image is only grayscale array[:, :, i] = temp np.save('all_images.npy', array) elif self.controller.all_common_variables.convert_image_output_variable.get() == '.avi': """ not trivial - still needs to be implemented!! fig = Figure() ax = fig.add_subplot(111) ax.set_aspect('equal') ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) image = ax.imshow(temp, cmap='gray', interpolation='nearest') #im.set_clim([0, 1]) #fig.set_size_inches([5, 5]) #tight_layout() def update_img(i): tmp = np.random(300, 300) image.set_data(tmp) #temp = imread(sorted_filed_to_read[i]) #image.set_data(temp) return image # legend(loc=0) ani = animation.FuncAnimation(fig, update_img, 300, interval=30) writer = animation.writers['ffmpeg'](fps=30) ani.save('demo.mp4', writer=writer, dpi=100) return ani """ print('Still needs to be implemented!') ''' def quit_sequence(self, save=True, exit=True): if RASPBERRY or virtual_raspberry: if save: variables = {'Path': self.controller.all_common_variables.path_entry_variable.get(), 'Recording framerate': int(self.controller.all_common_variables.framerate_entry_variable.get()), 'Resolution': self.controller.all_common_variables.resolution, 'Recording length': int(self.controller.all_common_variables.recording_time_variable.get()), 'Background dutycycle': self.controller.all_common_variables.backlight_intensity_value, 'Background 2 dutycycle' : self.controller.all_common_variables.backlight_two_intensity_value, 'Exp. group' : self.controller.all_common_variables.genotype_entry_variable.get(), 'Observation mode': self.controller.all_common_variables.experiment_observation_mode_output, 'Window': self.controller.current_window, 'Organism': self.controller.all_common_variables.model_organism_value, 'Background': self.controller.all_common_variables.background, 'Background 2' : self.controller.all_common_variables.background_two, 'Channel 1': self.controller.all_common_variables.channel_one, 'Channel 2': self.controller.all_common_variables.channel_two, 'Channel 3': self.controller.all_common_variables.channel_three, 'Channel 4': self.controller.all_common_variables.channel_four, 'Channel 1 dutycycle': self.controller.all_common_variables.channel_one_dutycycle, 'Channel 2 dutycycle': self.controller.all_common_variables.channel_two_dutycycle, 'Channel 3 dutycycle': self.controller.all_common_variables.channel_three_dutycycle, 'Channel 4 dutycycle': self.controller.all_common_variables.channel_four_dutycycle, 'High Power LEDs': self.controller.all_common_variables.high_power_LEDs_bool.get(), 'Animal Detection Mode': self.controller.all_common_variables.animal_detection_method_var.get(), 'VR Body Part Stimulation': self.controller.all_common_variables.vr_stim_loc_var.get(), 'Animal Signal': self.controller.all_common_variables.signal } try: if self.cam.exposure_mode == 'off': variables['exposure time'] = self.cam.exposure_speed else: # if autoexposure is on set the shutter speed to zero which allows it to float variables['exposure time'] = 0 except AttributeError: # if not on Raspberry an Attribute Error indicates that the cam object which in that case is # a string does not have exposure speed as a attribute pass if self.controller.all_common_variables.pixel_per_mm_var.get() != 0: variables['distance factor'] = self.controller.all_common_variables.pixel_per_mm_var.get() variables['known distance'] = self.controller.all_common_variables.known_distance try: variables['bbox size'] = int(self.boxsize.get("1.0", 'end-1c')) except: pass with open((self.controller.path_of_program + '/saved_variables.json'), 'w') as file: json.dump(variables, file, sort_keys=True, indent=4) if not RASPBERRY and not virtual_raspberry: if save: # thoughts - it's best to just save environments as json files - + is that different user can use # the same setup and not having to always set up the software again. # currently one can only save from the main window (tracking) as this is the one that has all the variables # change this and make it more specific for each window #variables = {'recording framerate': int( # self.controller.access_subframes(self.controller.current_window).sub_frames.recording_framerate.get( # "1.0", 'end-1c')), # # 'display framerate': int(self.controller.sub_frames.display_framerate.get("1.0", 'end-1c')), # 'observation mode': self.controller.all_common_variables.experiment_observation_mode_output, # 'Window': self.controller.current_window #} variables = {'Window': self.controller.current_window} #if self.controller.all_common_variables.pixel_per_mm_var is not None: # variables['distance factor'] = self.controller.all_common_variables.pixel_per_mm_var.get() # variables['known distance'] = self.controller.all_common_variables.known_distance #print('saved the following variable: ' + variables['Window']) with open((self.controller.path_of_program + '/saved_variables.json'), 'w') as file: json.dump(variables, file, sort_keys=True, indent=4) # with open(('/'.join(os.path.realpath(__file__).split('/')[:-1]) + '/saved_variables.json'), # 'w') as file: # json.dump(variables, file, sort_keys=True, indent=4) if exit: # quit causes mainloop to stop, but keeps interpreter intact. app.quit() def update_software(self): """ This function calls the shell script "update_PiVR" located in the folder "Installation_update". This shell script will: 1) sudo apt-get update the Raspberry Pi 2) cd into the PiVR directory and git pull the newest version of the software from gitlab """ if RASPBERRY: if tk.messagebox.askokcancel('Update?', 'This will stop the PiVR software to update! You ' 'will have to restart the software after the ' 'update.\nDo you want to continue?'): result = subprocess.run( ['/bin/bash', '-c', '/'.join(os.path.realpath(__file__).split('/')[:-1]) + '/Installation_update/update_PiVR.sh']) if result.returncode == 0: tk.messagebox.showinfo( 'Success!', 'Was able to connect to gitlab to download ' 'newest version!\n' 'Please restart software for update to take effect!') elif result.returncode == 1: tk.messagebox.showinfo( 'Failed!', 'Unable to connect to https://gitlab.com' '\nPlease make sure you are connected to the ' 'Internet!') else: print(result.returncode) else: if tk.messagebox.askokcancel( 'Update?', 'This will stop the PiVR software to update! You ' 'will have to restart the software after the ' 'update.\nDo you want to continue?'): # Safe the current path temporarilly current_path = os.path.abspath(os.getcwd()) # cd to the software path os.chdir(SOFTWARE_PATH) process = subprocess.Popen(["git", "pull"], stdout=subprocess.PIPE) output = process.communicate() print(output[0]) tk.messagebox.showinfo('Update Information', output[0]) tk.messagebox.showinfo( 'Reminder', 'If successfully downloaded newest version, please ' 'remember to restart the software for updates to ' 'take effect!') # cd back to the previously used path. os.chdir(current_path) def software_info(self): """ Show version (and in future the license) of the software """ child_window_info = tk.Toplevel() child_window_info.wm_title('About') child_window_info.geometry("%dx%d%+d%+d" % (300, 450, 0, 0)) child_window_info.attributes("-topmost", True) # force on top # disable main window child_window_info.grab_set() logo = Image.open( self.controller.path_of_program + '/pics/PiVRLogo.ico')#.resize((100, 100)) logo_as_photo = ImageTk.PhotoImage(logo) display_logo = tk.Label(child_window_info, image=logo_as_photo) display_logo.image = logo_as_photo display_logo.grid(row=1, column=0, columnspan=2) title = tk.Label(child_window_info, text=__project__) title.config(font=("Arial", 50, "bold")) title.grid(row=0, column=0, columnspan=2) some_description = tk.Label(child_window_info, text='The software powering your home built RPi tracker') some_description.config(font=('Arial', 10,'italic')) some_description.grid(row=2, column=0, columnspan=2) author_label = tk.Label(child_window_info, text='Written by:') author_label.grid(row=3, column=0) author_read = tk.Label(child_window_info, text=__author__) author_read.grid(row=3,column=1) version_label = tk.Label(child_window_info, text='Version:') version_label.grid(row=4, column=0) version_read = tk.Label(child_window_info, text=__version__) version_read.grid(row=4, column=1) version_date = tk.Label(child_window_info, text='Release Date:') version_date.grid(row=5, column =0) version_data_read = tk.Label(child_window_info, text=__date__) version_data_read.grid(row=5, column=1) license_label = tk.Label(child_window_info, text='License') license_label.grid(row=6, column = 0) license_BSD = tk.Label(child_window_info, text='BSD-3-Clause') license_BSD.grid(row=6, column=1) """ def autoexp_callback_old(self): ''' The callback menu for the autoexposure button. When the user clicks on the autoexposure button this function will change both what is displayed in the GUI as well as changing the exposure_mode of the camera. NOTE: This has been retired 10th of October 2018 as the button moved from a the main frame to a popup window :return: ''' if self.controller.access_subframes( self.controller.current_window).sub_frames.auto_exposure_button['text'] == 'autoexp. on': self.controller.access_subframes( self.controller.current_window).sub_frames.auto_exposure_button['text'] = 'autoexp. off' # todo - delete if line below in final version if RASPBERRY: self.cam.exposure_mode = 'off' print(self.cam.exposure_speed) print('autoexposure: off') else: self.controller.access_subframes( self.controller.current_window).sub_frames.auto_exposure_button['text'] = 'autoexp. on' # todo - delete if line below in final version if RASPBERRY: self.cam.exposure_mode = 'auto' print(self.cam.exposure_speed) print('autoexposure: auto') """ def autoexp_callback(self): ''' The callback menu for the autoexposure button. When the user clicks on the autoexposure button this function will change both what is displayed in the GUI as well as changing the exposure_mode of the camera. :return: ''' if self.controller.all_common_variables.auto_exposure_button['text'] == 'autoexp. on': self.controller.all_common_variables.auto_exposure_button['text'] = 'autoexp. off' # todo - delete if line below in final version if RASPBERRY: self.cam.exposure_mode = 'off' self.cam.shutter_speed = self.cam.exposure_speed print(self.cam.exposure_speed) print(self.cam.shutter_speed) else: self.controller.all_common_variables.auto_exposure_button['text'] = 'autoexp. on' # todo - delete if line below in final version if RASPBERRY: self.cam.exposure_mode = 'auto' self.cam.shutter_speed = 0 print(self.cam.exposure_speed) print(self.cam.shutter_speed) def select_signal(self): ''' This function gets called when the user presses the 'Animal Color' option in the menubar. It will display an example of both dark and white signal and lets the user choose which of two options are correct for her. :return: ''' distance_configuration_module.AnimalColorSelection(path=self.controller.path_of_program, linux=LINUX, controller=self.controller) print(self.controller.all_common_variables.signal) def select_output_channels(self): ''' This function will let the user select which output channel (GPIO#x) corresponds to STIM_1 etc :return: ''' output_channels.DefineOutputChannels(path=self.controller.path_of_program, controller=self.controller) def draw_VR_arena(self): if self.controller.all_common_variables.resolution == '640x480': resolution = [640, 480] elif self.controller.all_common_variables.resolution == '1024x784': resolution = [1024, 784] elif self.controller.all_common_variables.resolution == '1296x972': resolution = [1296, 972] elif self.controller.all_common_variables.resolution == '1920x1080': resolution = [1920, 1080] self.VR_arena = VR_drawing_board.VRArena( resolution=resolution, path_of_program=self.controller.path_of_program ) def select_time_dependent_stim_func(self): """ This function gets called when the user clicks on the 'Select Time Dependent Stim File' button a recording setting. The user has to choose an csv file. I don't think there will be enough space to actually display it so the only way to display it will be in a special menu where one can create the stimulation file. Todo Actually - it might be better to show the stimulus and the time...to be discussed! """ try: self.controller.all_common_variables.time_dependent_stim_file_name = filedialog.askopenfilename( initialdir=self.controller.path_of_program + '/time_dependent_stim', title="Select file", filetypes=(("csv files", "*.csv"), ("all files", "*.*"))) # read the file self.controller.all_common_variables.time_dependent_stimulation_file = \ pd.read_csv(self.controller.all_common_variables.time_dependent_stim_file_name , delimiter=',') # np.genfromtxt(name_of_file, delimiter=',') #print(self.controller.all_common_variables.time_dependent_stimulation_file) # update the button label if LINUX: self.controller.all_common_variables.chosen_timedep_file_display_var.set( self.controller.all_common_variables.time_dependent_stim_file_name .split('\\')[-1]) else: self.controller.all_common_variables.chosen_timedep_file_display_var.set( self.controller.all_common_variables.time_dependent_stim_file_name .split('/')[-1]) #self.controller.access_subframes( # self.controller.current_window).sub_frames.chosen_timedep_file.configure( # text=name_of_file.split('/')[-1] #) # todo if want to display the stimulation file, put the code here except OSError: # if nothing has been selected self.controller.all_common_variables.time_dependent_stimulation_file = None self.controller.all_common_variables.chosen_timedep_file_display_var.set(None) #self.controller.access_subframes( # self.controller.current_window).sub_frames.chosen_timedep_file.configure('None selected') pass def select_vr_arena_func(self, dynamic_VR=False): """ This function gets called when the user clicks on the 'Select VR Arena' button in the VR experiment tab. The user has to choose a arena and it will be displayed as an extra window. Different arenas can be chosen: #) A static arena that will just be displayed "as is". Such an arena is identified using its name: "XX.csv" #) A static arena that will be displayed relative to starting position of the animal without taking the movement of the animal into account. Such an arena is identified using its name: "XX[320,240].csv". 320 and 240 stand for the x and y coordinates. For example, if the animal is at exactly 320,240 at the start of the experiment the arena will not be translated. If the animal is at 300, 240, the virtual arena will be translated by 20 pixels. #) A static arena that is both translated and rotated relative to the starting position of the animal. Such an arena is defined using its name: "XX.[320,240,1.5].csv". The first two number again define the translation while the third number, 1.5 in this case, defines the angle the arena is oriented relative to the movement of the animal. #) A dynamic arena. This arena can **not** be rotated nor translated. Dynamic arenas are defined as 3 dimensional numpy arrays with the third dimension encoding time. The dynamic arena is also defined by its name: "XXHz[Y].np" with Y being a floating point number between 0 and pi. This function handles these different types of arenas by saving the path to the chosen arena which will then be iven to the tracking class if the user starts an experiment. The function also handles the presention: if a static arena is chosen, the arena is presented in the small preview plot in the PiVR software. If no rotation nor translation is desired, an overlay is put over the preview window to help the user place the animal at the correct place. Obviously, this doesn't make sense if the arena is anyway translated/rotated afterwards, so no overlay is presented. """ # As soon as user clicks, reset everything. This enables the # user to "unselect" any arena and have a "clean slate". self.controller.all_common_variables.vr_arena_name = None if dynamic_VR: self.controller.all_common_variables.vr_arena_name = \ filedialog.askopenfilename( initialdir=self.controller.path_of_program + '/VR_arenas', title="Select file", filetypes=(("dynamic", "*.npy"), )) else: self.controller.all_common_variables.vr_arena_name = \ filedialog.askopenfilename( initialdir=self.controller.path_of_program + '/VR_arenas', title="Select file", filetypes=(("csv files", "*.csv"), )) # always remove the animal that was placed before try: self.controller.all_common_variables.animal_annotation.remove() except (AttributeError, ValueError): pass # check if overlay image has been defined. If yes, it means # that the user has selected a VR arena since starting up the # software. # If yes, remove the previous overlay if self.controller.all_common_variables.overlay_image is not \ None: try: self.controller.all_common_variables.cam.remove_overlay( self.controller.all_common_variables.overlay) except Exception as ex: print('Tried removing overlay. This happened:') print(ex) # then set the overlay_image... self.controller.all_common_variables.overlay_image = None # ... and the overlay variable back to None self.controller.all_common_variables.overlay = None # Now check what the user has provided...start with checking # if its a static arena if 'csv' in self.controller.all_common_variables.vr_arena_name: #print('csv in name') self.controller.all_common_variables.vr_arena_multidimensional = \ False # collect the string after animal_pos. If no animal_pos # is defined this will just take the whole string. animal_defined = \ self.controller.all_common_variables.vr_arena_name.split( 'animal_pos')[-1] # load the arena into memory self.controller.all_common_variables.vr_arena = \ np.genfromtxt( self.controller.all_common_variables.vr_arena_name, delimiter=',') # Now check if the animal is placed..for this it's # necessary to do some string acrobatics try: # This will check if there's a "," and a "[" in the # string. As there's indexing here, this will fail ( # IndexError) if none of the two characters are # present and this will lead to no animal placed! self.controller.all_common_variables.placed_animal = \ [int(animal_defined.split(',')[0].split('[')[1])] # Now check after how many "," a "]" is present. If # after only one, no orientation has been defined. if ']' in animal_defined.split(',')[1]: print('no orientation') self.controller.all_common_variables.placed_animal.append( int(animal_defined.split(',')[1].split(']')[0])) # Else the desired orientation theta has been defined. elif ']' in animal_defined.split(',')[2]: self.controller.all_common_variables.placed_animal.append( int(animal_defined.split(',')[1])) self.controller.all_common_variables.placed_animal.append( float(animal_defined.split(',')[2].split(']')[0])) print('animal with orientation') except IndexError: # When analyzing the string and finding that no # animal position has been defined, the code # continues here. #print('no animal placed') self.controller.all_common_variables.placed_animal = None # only display overlay if **no** animal is placed # Create an empty array which will be used to create # the RGBA image RGB_arena = \ np.zeros(( self.controller.all_common_variables.vr_arena.shape[0], self.controller.all_common_variables.vr_arena.shape[1], 4), dtype=np.uint8) # The image only takes values between 0...255 (uint8) normalized_values = \ self.controller.all_common_variables.vr_arena \ * (255 / PWM_RANGE) # Now fill the empty array with the normalized values RGB_arena[:, :, 0] = np.around(a=(normalized_values)) RGB_arena[:, :, 3] = np.around(a=(normalized_values)) # And convert the array to an image object self.controller.all_common_variables.overlay_image = \ Image.fromarray(RGB_arena, 'RGBA') # call the function that puts the overlay over the # preview self.preview_overlay_func() print(self.controller.all_common_variables.placed_animal) # Here the plotting in the small figure in the center of # the PiVR software is done. First, the arena is set self.controller.access_subframes( self.controller.current_window).sub_frames.image_of_arena.set_data( self.controller.all_common_variables.vr_arena) if self.controller.all_common_variables.placed_animal is \ not None: # if only animal is placed, no orientation information # is given - therefore a circle is drawn at the given # position - the animal annotation is a common # variable which enables us to always delete it when # loading a new arena if len(self.controller.all_common_variables.placed_animal) == 2: circle = Circle(( self.controller.all_common_variables.placed_animal[0], self.controller.all_common_variables.placed_animal[1]), 10) self.controller.all_common_variables.animal_annotation = \ self.controller.access_subframes( self.controller.current_window).sub_frames.ax_vr_arena.add_artist(circle) else: # if theta is given (here it doesn't check for # values between -pi and +pi) first the x and y # position of the thin end of the arrow needs to # be calculated (the inverse of arctan2 with # length = 10) x_before = \ self.controller.all_common_variables.placed_animal[0] \ + 10 \ * np.cos(self.controller.all_common_variables.placed_animal[2]) y_before = \ self.controller.all_common_variables.placed_animal[1] \ + 10 \ * np.sin(self.controller.all_common_variables.placed_animal[2]) # This is where the arrow is plotted self.controller.all_common_variables.animal_annotation = \ self.controller.access_subframes( self.controller.current_window).sub_frames.ax_vr_arena.arrow( x_before, # x y_before, # y self.controller.all_common_variables.placed_animal[0] - x_before, # dx self.controller.all_common_variables.placed_animal[1] - y_before, # dy head_width=50, head_length=-25, fc='r', ec='r' ) # and finally the plot is updated self.controller.access_subframes( self.controller.current_window).sub_frames.ax_vr_arena.figure.canvas.draw() # TODO: Shouldn't be necessary in here, right? if self.controller.all_common_variables.high_power_LEDs_bool: self.controller.all_common_variables.invert_arena_bool = True elif 'npy' in self.controller.all_common_variables.vr_arena_name: # This is checking whether the user selected a dynamic # virtual reality arnea # read the file: temp = np.load(self.controller.all_common_variables.vr_arena_name) if temp.shape[0] == 480 and temp.shape[1] == 640: try: self.controller.all_common_variables.vr_update_rate = \ int(self.controller.all_common_variables.vr_arena_name.split('Hz[')[-1].split('].npy')[0]) except ValueError: tk.messagebox.showerror( 'Please define update rate', 'The time-dependent file you have selected does ' 'not specify the update rate.' 'The update rate is defined in the name as' ' the follwing string: ' '\nHz[xxxx].npy ' '\nAn example file name would be: "test_Hz[15].npy"') self.controller.all_common_variables.vr_arena = temp self.controller.all_common_variables.vr_arena_multidimensional = True # TODO: Shouldn't be necessary in here, right? if self.controller.all_common_variables.high_power_LEDs_bool: self.controller.all_common_variables.invert_arena_bool = True # Create an empty array which will be used to create # the RGBA image used to display the overlay over the # preview window RGB_arena = \ np.zeros((self.controller.all_common_variables.vr_arena.shape[0], self.controller.all_common_variables.vr_arena.shape[1], 4), dtype=np.uint8) values = self.controller.all_common_variables.vr_arena[:,:,0] # Now fill the empty array with the values RGB_arena[:, :, 0] = np.around(a=(values)) RGB_arena[:, :, 3] = np.around(a=(values)) # And convert the array to an image object self.controller.all_common_variables.overlay_image = \ Image.fromarray(RGB_arena, 'RGBA') # call the function that puts the overlay over the # preview self.preview_overlay_func() # Here the plotting in the small figure in the center of # the PiVR software is done. First, the arena is set self.controller.access_subframes( self.controller.current_window).sub_frames.image_of_arena.set_data( self.controller.all_common_variables.vr_arena[:,:,0]) # and finally the plot is updated self.controller.access_subframes( self.controller.current_window).sub_frames.ax_vr_arena.figure.canvas.draw() else: tk.messagebox.showerror( 'Wrong spatial dimensions', 'For a virtual arena that changes over time please' 'only use numpy arrays with the size of ' '480x640xtime.' '\nThe arena you selected has the following ' 'dimensions: ' + repr(temp.shape[0]) + 'x' + repr(temp.shape[1])) else: # If nothing has been selected, clean up the plot. The # overlay, filename variables etc. have already been # reset to zero. self.controller.access_subframes( self.controller.current_window).sub_frames.image_of_arena.set_data( np.zeros((480,640))) # This will break if arenas other than 640x480 are being used! self.controller.access_subframes( self.controller.current_window).sub_frames.ax_vr_arena.figure.canvas.draw() # TODO: Shouldn't be necessary in here, right? if self.controller.all_common_variables.high_power_LEDs_bool: self.controller.all_common_variables.invert_arena_bool = False def preview_overlay_func(self): """ This function is called whenever the virtual arena is supposed to be put on top of the overlay. It adds the overlay_image in all_common_variables to cam. It then adjusts the size of the overlay to the size of the preview window. """ if RASPBERRY \ and self.controller.all_common_variables.resolution == '640x480': if self.controller.all_common_variables.preview_bool: self.controller.all_common_variables.overlay = \ self.cam.add_overlay( source=self.controller.all_common_variables.overlay_image.tobytes(), layer=3, alpha=150) size = int(self.controller.all_common_variables.preview_window_size_value) self.controller.all_common_variables.overlay.fullscreen = False self.controller.all_common_variables.overlay.window = \ (0, 0, size, size) else: # If user selects an arena while the preview window # is turned off, change the overlay variable from # None to True so that when the preview window is # turned on the overlay is presented! self.controller.all_common_variables.overlay = True elif RASPBERRY and \ self.controller.all_common_variables.resolution != '640x480': tk.messagebox.showerror( 'Wrong spatial dimension', 'For a virtual arena experiment the resolution must ' 'be set to' '\n640x480' '\n' '\nIt is currently set to: ' '\n' + self.controller.all_common_variables.resolution) def overwrite_metadata(self): """ This function is called when the user wants to update the metadata that is saved in each experimental folder in the file experiment_settings.json :return: """ datetime = time.strftime("%d.%m.%Y_%H-%M-%S") try: # open the file with the history of the changed metadata with open((self.controller.all_common_variables.data_path + '/old_experiment_settings.json'), 'r') as file: all_old_experiment_settings = json.load(file) # also open the file that holds the metadata until now with open((self.controller.all_common_variables.data_path + '/experiment_settings.json'), 'r') as file: old_experiment_settings = json.load(file) # extract the metadata of the metadata up to now metadata_before_change = {} try: metadata_before_change['Experiment Date and Time'] = old_experiment_settings['Experiment Date and Time'] except KeyError: pass try: metadata_before_change['Framerate'] = old_experiment_settings['Framerate'] except KeyError: pass try: metadata_before_change['Pixel per mm'] = old_experiment_settings['Pixel per mm'] except KeyError: pass # to keep backwards compatibility after changing the 'genotype' to exp. control if 'Exp. group' in metadata_before_change: metadata_before_change['Exp. group'] = old_experiment_settings['Exp. group'] elif 'Genotype' in metadata_before_change: metadata_before_change['Genotype'] = old_experiment_settings['Genotype'] #try: # metadata_before_change['Genotype'] = old_experiment_settings['Genotype'] #except KeyError: # pass try: metadata_before_change['Resolution'] = old_experiment_settings['Resolution'] except KeyError: pass try: metadata_before_change['Recording time'] = old_experiment_settings['Recording time'] except KeyError: pass #try: # metadata_before_change['Bounding box size'] = # old_experiment_settings['Bounding box size'] #except KeyError: # pass try: metadata_before_change['Search box size'] = \ old_experiment_settings['Search box size'] except KeyError: pass try: metadata_before_change['Preview'] = old_experiment_settings['Preview'] except KeyError: pass try: metadata_before_change['Preview size'] = old_experiment_settings['Preview size'] except KeyError: pass try: metadata_before_change['Model Organism'] = old_experiment_settings['Model Organism'] except KeyError: pass # update the json file with all the old metadata all_old_experiment_settings.update(metadata_before_change) # and save it with open((self.controller.all_common_variables.data_path + '/old_experiment_settings.json'), 'w') as file: json.dump(all_old_experiment_settings, file, indent=4) except FileNotFoundError: print(self.controller.all_common_variables.data_path) with open((self.controller.all_common_variables.data_path + '/experiment_settings.json'), 'r') as file: old_experiment_settings = json.load(file) metadata_before_change = {} try: metadata_before_change['Experiment Date and Time'] = old_experiment_settings['Experiment Date and Time'] except KeyError: pass try: metadata_before_change['Framerate'] = old_experiment_settings['Framerate'] except KeyError: pass try: metadata_before_change['Pixel per mm'] = old_experiment_settings['Pixel per mm'] except KeyError: pass # to keep backwards compatibility after changing the 'genotype' to exp. control if 'Exp. group' in metadata_before_change: metadata_before_change['Exp. group'] = old_experiment_settings['Exp. group'] elif 'Genotype' in metadata_before_change: metadata_before_change['Genotype'] = old_experiment_settings['Genotype'] #try: # metadata_before_change['Genotype'] = old_experiment_settings['Genotype'] #except KeyError: # pass try: metadata_before_change['Resolution'] = old_experiment_settings['Resolution'] except KeyError: pass try: metadata_before_change['Recording time'] = old_experiment_settings['Recording time'] except KeyError: pass #try: # metadata_before_change['Bounding box size'] = # old_experiment_settings['Bounding box size'] #except KeyError: # pass try: metadata_before_change['Search box size'] = \ old_experiment_settings['Search box size'] except KeyError: pass try: metadata_before_change['Preview'] = old_experiment_settings['Preview'] except KeyError: pass try: metadata_before_change['Preview size'] = old_experiment_settings['Preview size'] except KeyError: pass try: metadata_before_change['Model Organism'] = old_experiment_settings['Model Organism'] except KeyError: pass with open((self.controller.all_common_variables.data_path + '/old_experiment_settings.json'), 'w') as file: json.dump(metadata_before_change, file, indent=4) # open the original file with all the experimental settings with open((self.controller.all_common_variables.data_path + '/experiment_settings.json'), 'r') as file: experiment_settings = json.load(file) # update the old values with the new values experiment_settings['Pixel per mm'] = self.controller.all_common_variables.pixel_per_mm_var.get() experiment_settings['Model Organism'] = self.controller.all_common_variables.experimental_metadata[ 'Model Organism'] experiment_settings['Experiment Date and Time'] = \ self.controller.all_common_variables.experimental_metadata['Experiment Date and Time'] # overwrite the original file with the experimental settings with open((self.controller.all_common_variables.data_path + '/experiment_settings.json'), 'w') as file: json.dump(experiment_settings, file, indent=4) def metadata_fix_date_time(self): # create a new window and name it self.child = tk.Toplevel() self.child.wm_title('Fix Date and Time') self.child.attributes("-topmost", True) # force on top # disable main window self.child.grab_set() # create a frame in the window self.child_frame = tk.Frame(self.child) self.day_label = tk.Label(self.child_frame, text='Day') self.day_label.grid(row=0, column=0) self.day_entry = tk.Entry(self.child_frame, width=5) self.day_entry.grid(row=1, column=0) # enter the original day self.day_entry.insert(tk.END, self.controller.all_common_variables.experimental_metadata['Experiment Date and Time']. split('.')[0]) self.month_label = tk.Label(self.child_frame, text='Month') self.month_label.grid(row=0, column=1) self.month_entry = tk.Entry(self.child_frame, width=5) self.month_entry.grid(row=1, column=1) # enter the original month self.month_entry.insert(tk.END, self.controller.all_common_variables.experimental_metadata['Experiment Date and Time']. split('.')[1]) self.year_label = tk.Label(self.child_frame, text='Year') self.year_label.grid(row=0, column=2) self.year_entry = tk.Entry(self.child_frame, width=5) self.year_entry.grid(row=1, column=2) # enter the original year self.year_entry.insert(tk.END, self.controller.all_common_variables.experimental_metadata['Experiment Date and Time']. split('.')[2].split('_')[0]) self.hour_label = tk.Label(self.child_frame, text='Hour') self.hour_label.grid(row=0, column=3) self.hour_entry = tk.Entry(self.child_frame, width=5) self.hour_entry.grid(row=1, column=3) # enter the original hour self.hour_entry.insert(tk.END, self.controller.all_common_variables.experimental_metadata['Experiment Date and Time']. split('-')[0].split('_')[1]) self.minutes_label = tk.Label(self.child_frame, text='Minutes') self.minutes_label.grid(row=0, column=4) self.minutes_entry = tk.Entry(self.child_frame, width=5) self.minutes_entry.grid(row=1, column=4) # enter the original hour self.minutes_entry.insert(tk.END, self.controller.all_common_variables.experimental_metadata[ 'Experiment Date and Time']. split('-')[1]) self.seconds_label = tk.Label(self.child_frame, text='Seconds') self.seconds_label.grid(row=0, column=5) self.seconds_entry = tk.Entry(self.child_frame, width=5) self.seconds_entry.grid(row=1, column=5) # enter the original hour self.seconds_entry.insert(tk.END, self.controller.all_common_variables.experimental_metadata[ 'Experiment Date and Time']. split('-')[2]) self.accept_changes = tk.Button(self.child_frame, text='Accept Changes', command=self.metadata_accept_datetime_changes) self.accept_changes.grid(row=2, column=0, columnspan=3) self.discard_changes = tk.Button(self.child_frame, text='Discard Changes', command=self.metadata_discard_changes) self.discard_changes.grid(row=2, column=3, columnspan=3) self.child_frame.pack() def metadata_accept_datetime_changes(self): ''' Function is called to update the date and time metadata. It first checks for valid input and prompts the user to fix the input if it fails this test :return: ''' try: if type(int(self.day_entry.get())) and type(int(self.month_entry.get())) and type( int(self.year_entry.get())) \ and type(int(self.hour_entry.get())) and type(int(self.minutes_entry.get())) and \ type(int(self.seconds_entry.get())) is int: # first check if the input is all integer and no text if 0 < int(self.day_entry.get()) <= 31 and \ 0 < int(self.month_entry.get()) <= 12 and \ 1900 < int(self.year_entry.get()) < 2050 and \ 0 <= int(self.hour_entry.get()) < 24 and \ 0 <= int(self.minutes_entry.get()) < 60 and \ 0 <= int(self.seconds_entry.get()) < 60: # then check if the input is generally valid if 0 < int(self.day_entry.get()) <= \ calendar.monthrange(int(self.year_entry.get()), int(self.month_entry.get()))[1]: # then check if the month has as many days as is being claimed' # if all good, assign the new time/date to the main variable. Note - small caveat, this will # remove trailing zeros (e.g. 01 for January will become just 1) self.controller.all_common_variables.experimental_metadata['Experiment Date and Time'] = \ str(int(self.day_entry.get())) + '.' + str(int(self.month_entry.get())) + '.' + \ str(int(self.year_entry.get())) + '_' + str(int(self.hour_entry.get())) + '-' + \ str(int(self.minutes_entry.get())) + '-' + str(int(self.seconds_entry.get())) # set main window active again self.child.grab_release() # close the child window self.child.after(0, self.child.destroy()) # update the date and time in the main window self.controller.access_subframes( self.controller.current_window).sub_frames.experiment_date_n_time_label.configure( text=self.controller.all_common_variables.experimental_metadata['Experiment Date and Time']) else: # the user entered an invalid day relative to the month and year chosen tk.messagebox.showerror('Invalid Entry', 'Please enter a valid date') else: # the user entered an invalid anything - could be day, month, year, hour, minute or second (or all) tk.messagebox.showerror('Invalid Entry', 'Please enter valid numbers') else: # unsure how this could happen, but let's keep it to not have silent errors tk.messagebox.showerror('Invalid Entry', 'Please enter valid numbers in the format\n 01 01 2018 12 12 12\n' 'Also, let me know how you got this error!') except ValueError: # this error happens when the user enters a string tk.messagebox.showerror('Invalid Entry', 'Please enter valid numbers in the format\n 01 01 2018 12 12 12') def metadata_discard_changes(self): # set main window active again self.child.grab_release() # close the child window self.child.after(0, self.child.destroy()) def metadata_accept_organism_changes(self): self.controller.all_common_variables.experimental_metadata['Model Organism'] = self.organism_entry.get() # set main window active again self.child.grab_release() # close the child window self.child.after(0, self.child.destroy()) # update the model organism in the main window self.controller.access_subframes( self.controller.current_window).sub_frames.species_label.configure( text=self.controller.all_common_variables.experimental_metadata['Model Organism']) def metadata_fix_organism(self): # create a new window and name it self.child = tk.Toplevel() self.child.wm_title('Fix Organism') self.child.attributes("-topmost", True) # force on top # disable main window self.child.grab_set() # create a frame in the window self.child_frame = tk.Frame(self.child) self.organism_label = tk.Label(self.child_frame, text='Enter name of Organims') self.organism_label.grid(row=0, column=0) self.organism_entry = tk.Entry(self.child_frame, width=20) self.organism_entry.grid(row=1, column=0, columnspan=2) self.organism_entry.insert(tk.END, self.controller.all_common_variables.experimental_metadata['Model Organism']) self.accept_changes = tk.Button(self.child_frame, text='Accept Changes', command=self.metadata_accept_organism_changes) self.accept_changes.grid(row=2, column=0) self.discard_changes = tk.Button(self.child_frame, text='Discard Changes', command=self.metadata_discard_changes) self.discard_changes.grid(row=2, column=1) self.child_frame.pack() def high_power_LED(self): ''' If the software is run on a configuration using the miniBuck the PWM signal needs to be inverted as the current controller is on if no control voltage is provided. The standard configuration with the transistor is inverse, as the transistor only conducts current if the gate is opened using the control voltage :return: ''' # create new window and name it self.controller.all_common_variables.child_high_power_LED = tk.Toplevel() self.controller.all_common_variables.child_high_power_LED.wm_title('High Power LED selection') self.controller.all_common_variables.child_high_power_LED.attributes("-topmost", True) # force on top # disable main window self.controller.all_common_variables.child_high_power_LED.grab_set() # create a temporary variable that can be saved or thrown away depending on what the user does temp_high_power_LED_bool = tk.IntVar() temp_high_power_LED_bool.set(self.controller.all_common_variables.high_power_LEDs_bool.get()) # todo once name is finalized > change name here! explanation = tk.Label(self.controller.all_common_variables.child_high_power_LED, justify=tk.LEFT, text='PiVR comes in two different versions:\n' '1) the standard version with LED strips\n' '2) the high LED power version with high power LEDs\n' 'Please select which version you have:') explanation.grid(row=0, column=0, columnspan=2, sticky='W') standard_radiobutton = tk.Radiobutton(self.controller.all_common_variables.child_high_power_LED, justify=tk.LEFT, text="Standard LED configuration (Strips)", padx=20, variable=temp_high_power_LED_bool, value=0) standard_radiobutton.grid(row=1, column=0,columnspan=2, sticky='W') high_power_radiobutton = tk.Radiobutton(self.controller.all_common_variables.child_high_power_LED, justify=tk.LEFT, text="High Powered LED configuration (Stars)", padx=20, variable=temp_high_power_LED_bool, value=1) high_power_radiobutton.grid(row=2, column=0,columnspan=2, sticky='W') quit_window_save = tk.Button(self.controller.all_common_variables.child_high_power_LED, text='Exit and save changes', command=lambda : self.exit_toplevel(popup_name='High Powered LED', save=True, savevalue=temp_high_power_LED_bool)) quit_window_save.grid(row=3, column=0, sticky='W') quit_window_discard = tk.Button(self.controller.all_common_variables.child_high_power_LED, text='Exit and discard changes', command=lambda : self.exit_toplevel(popup_name='High Powered LED', save=False)) quit_window_discard.grid(row=3, column=1, sticky='W') def exit_toplevel(self, popup_name,save=False,savevalue=None): ''' Function is called when user presses the quit button on one of the toplevel (popup) windows :return: ''' if popup_name=='High Powered LED': if save: # only save if user presses the correct button self.controller.all_common_variables.high_power_LEDs_bool.set(savevalue.get()) # let the user know that the program needs to be restarted tk.messagebox.showinfo('Notification', 'For the changes to take effect\n' 'please save and exit and restart\n' 'the program') # set main window active again self.controller.all_common_variables.child_high_power_LED.grab_release() # close the child window self.controller.all_common_variables.child_high_power_LED.after(0, self.controller.all_common_variables.child_high_power_LED.destroy()) def animal_detection_method_func(self): """ User can choose between three animal detection/background reconstruction modes: Mode 1 is the standard mode. It waits until something moves and reconstructs the the background from that image. Most of the time the background image of this mode will have a little bit of the animal left. But it seems to be robust. Mode 2, or pre-define background, is the mode where the user takes a picture of the arena without the animal and then adds the animal. The first image is the background for the whole experiment. This can be the optimal mode if the experiment has no lid that has to be opened to put the animal, such as a zebrafish experiment. Mode 3, or background reconstruction by stitching, attempts to give a close to perfect background reconstruction without user intervention. It waits for the animal to move, does local thresholding to identify the animal, then the algorithm waits until the animal is gone from the original position and then takes a picture of only the rectangle that was occupied by the animal before and 'stiches' it into the first image. This works well with slow moving animal such as Drosophila larvae on a evenly illuminated background without any high-contrast image features """ # create a new window and name it self.child = tk.Toplevel() self.child.wm_title('Select Detection Method') self.child.attributes("-topmost", True) # force on top # disable main window self.child.grab_set() # create a frame in the window self.child_frame = tk.Frame(self.child) explanation_animal_detection_method = tk.Label( self.child, justify=tk.LEFT, wraplength=500, text='Before the animal can be tracked it needs to be ' 'identified. ' 'In the current implementation three options are ' 'available. ') #'Please refer to the publication/webpage for more details.') explanation_animal_detection_method.grid(row=0, column=0,sticky='W') standard_method_button = tk.Radiobutton( self.child, justify=tk.LEFT, wraplength=500, text='Standard - Mode 1\n' 'This method will work for a wide array of animals and ' 'experimental setups.\n' 'It detects the animal as soon as it moves. It then proceeds ' 'with a lazy background reconstruction that will usually not ' 'completely get rid of the animal in the background image\n', variable=self.controller.all_common_variables.animal_detection_method_var, value='Mode 1') standard_method_button.grid(row=1, column=0,sticky='W') pre_define_background_button = tk.Radiobutton( self.child, justify=tk.LEFT, wraplength=500, text='Pre-Define background - Mode 2\n' 'This method works well if the user is able to insert the animal ' 'into the Field of View of the camera without changing ' 'anything else in the image.\n' 'The user takes a background image without the animal. ' 'Then the animal (and only the animal) is introduced.\n' 'This works well if no lid is used on the arena.\n', variable=self.controller.all_common_variables.animal_detection_method_var, value='Mode 2') pre_define_background_button.grid(row=2, column=0,sticky='W') background_reconstruction_by_stitching = tk.Radiobutton( self.child, justify=tk.LEFT, wraplength=500, text='Reconstruct background by stitching - Mode 3\n' 'Similar to Standard. It only works if the animal clearly ' 'contrasts with the background.\n' 'This method detects the animal as soon as it moves. It then ' 'identies the animal using the parameters defined in' '"list_of_available_organisms.json" file. ' "It then waits for the animal to leave it's original position " "and then reconstructs the whole background image automatically\n" 'This method is recommended for slow animals/animals that do ' 'not reach the edge of the arena during detection.\n', variable=self.controller.all_common_variables.animal_detection_method_var, value='Mode 3') background_reconstruction_by_stitching.grid(row=3, column=0, sticky='W') def camera_controls_func(self): """ Popup that user can call to define optimal image quality. Contains Cam ON/Cam OFF button, Scales for the different GPIO channels, button for autoexposure, and scales for brightness and contrast :return: """ # create a new window and name it child_window_optimize_image = tk.Toplevel() child_window_optimize_image.wm_title('Set up optimal image') child_window_optimize_image.attributes("-topmost", True) # force on top # disable main window child_window_optimize_image.grab_set() # create a Labeled Frame in the window for all the camera controls child_frame_cam = tk.LabelFrame(child_window_optimize_image, text='Camera Control') child_frame_cam.grid(row=0, column=0) # create a second Labeled Frame in the window for all the LED controls child_frame_led = tk.LabelFrame(child_window_optimize_image, text='LED Control') child_frame_led.grid(row=1, column=0) #if RASPBERRY or virtual_raspberry: self.cam_on_button = tk.Button(child_frame_cam, text='Cam On', fg='green', command=self.controller.all_common_functions.cam_on_func) self.cam_on_button.grid(row=0, column=0) self.cam_off_button = tk.Button(child_frame_cam, text='Cam Off', fg='red', command=self.controller.all_common_functions.cam_off_func) self.cam_off_button.grid(row=0, column=1) self.controller.all_common_variables.auto_exposure_button = tk.Button(child_frame_cam, text='autoexp. on', command=self.controller.all_common_functions.autoexp_callback) self.controller.all_common_variables.auto_exposure_button.grid(row=1, column=0) # turn autoexposure off only if it was turned off before. In fresh out-of-the box software will # be turned on if RASPBERRY: if previous_variables is not None and self.cam.shutter_speed != 0 : self.controller.all_common_variables.auto_exposure_button['text'] = 'autoexp. off' # to keep things tidy, class the resolution widgets together in one frame: the resolution_frame resolution_frame = tk.Frame(child_frame_cam) resolution_frame.grid(row=2, column=3, rowspan=2) resolution_label = tk.Label(resolution_frame, text='Camera Resolution') resolution_label.grid(row=0, column=0) self.cam_resolution_menu = tk.OptionMenu(resolution_frame, self.controller.all_common_variables.resolution_variable, *self.controller.all_common_variables.available_resolution) self.cam_resolution_menu.grid(row=1, column=0) self.preview_size_scale = tk.Scale(child_frame_cam, from_=180, to=1000, resolution=20, label='Video preview window size', variable=self.controller.all_common_variables.preview_window_size_variable, orient='horizontal', len=180) self.preview_size_scale.grid(row=2, column=0, columnspan=2, rowspan=2) # to keep things tidy, class the framerate widgets together into one frame: the recording_framerate_frame recording_framerate_frame = tk.Frame(child_frame_cam) recording_framerate_frame.grid(row=0, column=3, rowspan=2) # the recording framerate entry and update button - keep in here as this will change the image self.recording_frameratelabel = tk.Label(recording_framerate_frame, text='Recording framerate') self.recording_frameratelabel.grid(row=0, column=0) self.recording_framerate = tk.Entry(recording_framerate_frame, width=5, textvariable=self.controller.all_common_variables.framerate_entry_variable) self.recording_framerate.grid(row=0, column=1) self.update_framerate = tk.Button(recording_framerate_frame, text='Update Preview Framerate', command=lambda: self.controller.all_common_functions.update_framerate_func( new_framerate=int(self.controller.all_common_variables.framerate_entry_variable.get()) )) self.update_framerate.grid(row=1, column=0, columnspan=2) self.backlight_intensity_scale = tk.Scale(child_frame_led, from_=0, to=1000000, resolution=50000, label='Backlight Intensity', variable=self.controller.all_common_variables.backlight_intensity_variable, orient='horizontal', len=180) self.backlight_intensity_scale.grid(row=2, column=0) self.backlight_intensity_scale.set(self.controller.all_common_variables.backlight_intensity_variable.get()) self.backlight_two_intensity_scale = tk.Scale(child_frame_led, from_=0, to=1000000, resolution=50000, label='Backlight 2 Intensity', variable=self.controller.all_common_variables.backlight_two_intensity_variable, orient='horizontal', len=180) self.backlight_two_intensity_scale.grid(row=2, column=1) self.backlight_two_intensity_scale.set(self.controller.all_common_variables.backlight_two_intensity_variable.get()) if RASPBERRY: resolution_of_analog_output_scale = int(self.controller.all_common_variables.pwm_range / 20) range_of_analog_output_scale = self.controller.all_common_variables.pwm_range else: range_of_analog_output_scale = PWM_RANGE resolution_of_analog_output_scale = PWM_RANGE/20 # todo - put in ifs so that high speed PWM can be controlled as well!!!!!! self.analog_output_channel_one_scale = tk.Scale(child_frame_led, from_=0, to=range_of_analog_output_scale, resolution=resolution_of_analog_output_scale, label='Channel 1', variable=self.controller.all_common_variables.channel_one_variable, orient='horizontal', len=180) self.analog_output_channel_one_scale.grid(row=3, column=0) self.analog_output_channel_one_scale.set(self.controller.all_common_variables.channel_one_dutycycle) self.analog_output_channel_two_scale = tk.Scale(child_frame_led, from_=0, to=range_of_analog_output_scale, resolution=resolution_of_analog_output_scale, label='Channel 2', variable=self.controller.all_common_variables.channel_two_variable, orient='horizontal', len=180) self.analog_output_channel_two_scale.grid(row=3, column=1) self.analog_output_channel_two_scale.set(self.controller.all_common_variables.channel_two_dutycycle) self.analog_output_channel_three_scale = tk.Scale(child_frame_led, from_=0, to=range_of_analog_output_scale, resolution=resolution_of_analog_output_scale, label='Channel 3', variable=self.controller.all_common_variables.channel_three_variable, orient='horizontal', len=180) self.analog_output_channel_three_scale.grid(row=4, column=0) self.analog_output_channel_three_scale.set(self.controller.all_common_variables.channel_three_dutycycle) self.analog_output_channel_four_scale = tk.Scale(child_frame_led, from_=0, to=range_of_analog_output_scale, resolution=resolution_of_analog_output_scale, label='Channel 4', variable=self.controller.all_common_variables.channel_four_variable, orient='horizontal', len=180) self.analog_output_channel_four_scale.grid(row=4, column=1) self.analog_output_channel_four_scale.set(self.controller.all_common_variables.channel_four_dutycycle) width=400 height=350 xoffset=400 yoffset=0 child_window_optimize_image.geometry("%dx%d%+d%+d" % (width, height, xoffset, yoffset)) def turn_GPIO_fully_off(self, output_channel_one, output_channel_two, output_channel_three, output_channel_four): """ This function turns off all the Channels (*not* the background) by turning the dutycylce to 0 (or the PWM_RANGE ( should be 100) in the high power version). This is achieved by using a list comprehension and cycling through the GPIOs of each channel. """ # turn off GPIOs of Channel one - keep in loop instead of just # saying GPIO17 off for forward compatibility!! # list comprehension of Channel 1 if self.controller.all_common_variables.high_power_LEDs_bool.get(): off_value = self.controller.all_common_variables.pwm_range else: off_value = 0 [self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=output_channel_one[i_stim][0], dutycycle=off_value) for i_stim in range(len(output_channel_one))] # list comprehension of Channel 2 [self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=output_channel_two[i_stim][0], dutycycle=off_value) for i_stim in range(len(output_channel_two))] # list comprehension of Channel 3 [self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=output_channel_three[i_stim][0], dutycycle=off_value) for i_stim in range(len(output_channel_three))] # list comprehension of Channel 4 [self.controller.all_common_variables.pwm_object.set_PWM_dutycycle( user_gpio=output_channel_four[i_stim][0], dutycycle=off_value) for i_stim in range(len(output_channel_four))] def vr_body_part_stim_func(self): """ bla """ child_window_vr_body_stim = tk.Toplevel() child_window_vr_body_stim.wm_title('Select body part') child_window_vr_body_stim.attributes("-topmost", True) #force on top # disable the main window child_window_vr_body_stim.grab_set() explanation_vr_body_stim = tk.Label( child_window_vr_body_stim, justify=tk.LEFT, wraplength=300, text='When presenting the animal with a virtual reality, ' 'the sensory organs that are being probed can be ' 'located at different parts of the body. PiVR allows* ' 'the presentation of the virtual reality depending on ' 'the position of the following body parts:' ) explanation_vr_body_stim.grid(row=0, column=0,columnspan=2) vr_stim_head_button = tk.Radiobutton( child_window_vr_body_stim, justify=tk.LEFT, text='Head', variable=self.controller.all_common_variables.vr_stim_loc_var, value='Head' ) vr_stim_head_button.grid(row=1, column=0, sticky='W') vr_stim_centroid_button = tk.Radiobutton( child_window_vr_body_stim, justify=tk.LEFT, text='Centroid', variable=self.controller.all_common_variables.vr_stim_loc_var, value='Centroid' ) vr_stim_centroid_button.grid(row=2, column=0, sticky='W') vr_stim_midpoint_button = tk.Radiobutton( child_window_vr_body_stim, justify=tk.LEFT, text='Midpoint (seems a bit unstable', variable=self.controller.all_common_variables.vr_stim_loc_var, value='Midpoint' ) vr_stim_midpoint_button.grid(row=3, column=0, sticky='W') vr_stim_tail_button = tk.Radiobutton( child_window_vr_body_stim, justify=tk.LEFT, text='Tail', variable=self.controller.all_common_variables.vr_stim_loc_var, value='Tail' ) vr_stim_tail_button.grid(row=4, column=0, sticky='W') disclaimer = tk.Label( child_window_vr_body_stim, justify=tk.LEFT, wraplength=300, text='*Please note that the head/tail classification ' 'algorithm is not perfect! You must ensure that the ' 'algorithm works reasonably well for you experiment.' ) disclaimer.grid(row=5, column=0, columnspan=2)
[docs]class TrackingFrame(tk.Frame): """ The constructor class used to create the “Tracking” frame. """ def __init__(self, parent, controller, camera_class=None): # discussion about different ways to create the class # https://stackoverflow.com/questions/7300072/inheriting-from-frame-or-not-in-a-tkinter-application and # https://stackoverflow.com/questions/17466561/best-way-to-structure-a-tkinter-application/17470842#17470842 tk.Frame.__init__(self, parent) # reference the camera and the controller self.camera_class = camera_class self.cam = self.camera_class.cam self.controller = controller # Here the frame that will hold all the camera controls is being prepared. # self.subframe_preexperiment = tk.LabelFrame(self, text='Tracking') # self.subframe_preexperiment.grid(row=1, column=0) # construct the camera frame by calling the function 'camera_frame' in the class SubFrames which is referenced # by the controller as 'sub_frames' # self.controller.sub_frames.camera_frame(self.subframe_preexperiment) # self.controller.sub_frames.misc_frame(self.subframe_preexperiment, # observation_mode = True, distance_configuration=True, # model_organism = True) self.sub_frames = SubFrames(self.camera_class, self.controller, cam_frame=True, misc_frame=True, observation_mode=False, distance_configuration=False, model_organism=False, exp_ctr_frame=True, start_text='Start Tracking', experiment_name='Online Tracking', frame=self, quit_frame=False, time_dependent_stim_Frame=True) # After the construction of the frame it needs to watch out for user input. # not sure if this is needed! Maybe we only need to call this once as tall the variables are anyway in # all_common_variables self.controller.all_common_functions.menu_callback_shared(cam=True, backlight=True, analog_output_one=True, ) # todo - continue here by adding the ifs of the callback function # This function defines what should happen when the user presses on the 'Start Tracking' Button
[docs] def start_experiment_function(self): """ Each constructor class which is used to start an experiment has this function. They all have the same name. This is the one in the "TrackingFrame" It checks for: #) correct camera resolution, #) that the user has specified the pixel per mm If one of these tests fails, the user gets an error message and the experiment will not start. If the experiment does start, the :py:class:`control_file.ControlTracking` is called that then handles the detection and tracking of the animal. """ # currently ony resolution of 640x480 is allowed. Might be a new feature in the future if self.controller.all_common_variables.resolution == '640x480': # also make sure the user defined the pixel/mm - otherwise the experiment can not start! if self.controller.all_common_variables.pixel_per_mm_var.get() \ != 0: # boxsize is the area in all four directions starting # from the bounding box of the animal that will be # used in the next frame to look for the animal. It # depends on the speed of the animal and the framerate # boxsize is calculated for each experiment: # max_speed_of_animal_in_mm_per_sec / framerate (to # get speed in mm/frames) then multiplied by pixel # per mm to get speed in pixel/frame, the actualy # parameter that is needed for the program to function boxsize = (organisms_and_heuristics[ self.controller.all_common_variables.model_organism_variable.get()][ 'max_speed_animal_mm_per_s'] / int(self.controller.all_common_variables.framerate_entry_variable.get()) * self.controller.all_common_variables.pixel_per_mm_var.get()) # since the boxsize now also depends on the max speed # of the animal and the framerate it can become # extremely small (i.e. a larva that moves 2mm/s at # 30frames will only move 0.066mm which at 5px/mm is # only 0.33pixel # If in any frame the animal is not completely # detected the algorithm could never recover. This is # why the length of the animal must be taken into # account as well! boxsize = boxsize \ + (organisms_and_heuristics[ self.controller.all_common_variables.model_organism_variable.get()][ 'max_skeleton_length_mm'] * self.controller.all_common_variables.pixel_per_mm_var.get() ) print('boxsize is ' + repr(boxsize)) # TODO THIS IS REALLY HIDDEN! THINK OF A BETTER WAY TO MAKE THIS EXPLICIT! # It might be better to leave this here, of course. # If user changes the bool without restarting it will # still work as expected, namely the stim file will # be inverted at this point if self.controller.all_common_variables.high_power_LEDs_bool.get() \ and \ self.controller.all_common_variables.time_dependent_stimulation_file \ is not None: self.controller.all_common_variables.time_dependent_stimulation_file \ = self.controller.all_common_variables.pwm_range \ - self.controller.all_common_variables.time_dependent_stimulation_file control_file.ControlTracking( boxsize=boxsize, signal=self.controller.all_common_variables.signal, cam=self.controller.all_common_variables.cam, base_path=self.controller.all_common_variables.path_entry_variable.get(), genotype= self.controller.all_common_variables.genotype_entry_variable.get(), recording_framerate=int(self.controller.all_common_variables.framerate_entry_variable.get()), resolution=self.controller.all_common_variables.resolution, recordingtime=int(self.controller.all_common_variables.recording_time_variable.get()), # preview=self.controller.all_common_variables.experiment_observation_mode_output, # preview_resize=self.controller.all_common_variables.observation_resize_variable.get(), pixel_per_mm=self.controller.all_common_variables.pixel_per_mm_var.get(), model_organism=self.controller.all_common_variables.model_organism_value, pwm_object=self.controller.all_common_variables.pwm_object, high_power_led_bool=self.controller.all_common_variables.high_power_LEDs_bool.get(), # put somewhere else, confusing, same for other line time_dependent_stim_file=self.controller.all_common_variables.time_dependent_stimulation_file, time_dependent_stim_file_name=self.controller.all_common_variables.time_dependent_stim_file_name, organisms_and_heuristics=organisms_and_heuristics, debug_mode=self.controller.all_common_variables.debug_mode_var.get(), animal_detection_mode=self.controller.all_common_variables.animal_detection_method_var.get(), output_channel_one=self.controller.all_common_variables.channel_one, output_channel_two=self.controller.all_common_variables.channel_two, output_channel_three=self.controller.all_common_variables.channel_three, output_channel_four=self.controller.all_common_variables.channel_four, controller = self.controller, background_channel = self.controller.all_common_variables.background, background_2_channel = self.controller.all_common_variables.background_two, background_dutycycle=self.controller.all_common_variables.backlight_intensity_value, background_2_dutycycle=self.controller.all_common_variables.backlight_two_intensity_value ) else: tk.messagebox.showerror('Define Pixel/mm','You have to define pixel per mm before starting\n' 'an experiment!\n' 'Please go to "options">"Define Pixel/mm" to do so!') else: ''' This might be untrue with the the new recording class! Test! But not Necessarily useful as it will strongly impact performance! ''' tk.messagebox.showerror('Invalid resolution', 'It is only possible to do a tracking experiment\n' 'using the 640x480 resolution!\n' 'Please change resolution to start experiment!')
class VirtualRealityFrame(tk.Frame): ''' This class constructs the window that lets the user track an animal while also displaying what is being tracked. We tested this for up to 5 frames per second, anything that needs to be tracked with a higher framerate needs to be called from the FastTrackingFrame ''' def __init__(self, parent, controller, camera_class=None): # discussion about different ways to create the class # https://stackoverflow.com/questions/7300072/inheriting- # from-frame-or-not-in-a-tkinter-application and # https://stackoverflow.com/questions/17466561/best-way- # to-structure-a-tkinter-application/17470842#17470842 tk.Frame.__init__(self, parent) # reference the camera and the controller self.camera_class = camera_class self.cam = self.camera_class.cam self.controller = controller # Here the frame that will hold all the camera controls is # being prepared. self.sub_frames = SubFrames(self.camera_class, self.controller, cam_frame=True, misc_frame=True, observation_mode=False, distance_configuration=False, model_organism=False, exp_ctr_frame=True, start_text='Start Tracking VR', experiment_name='Closed Loop stimulation', VR_arena=True, frame=self, quit_frame=False) # After the construction of the frame it needs to watch out for user input. self.controller.all_common_functions.menu_callback_shared( cam=True, backlight=True, analog_output_one=True, ) # todo - continue here by adding the ifs of the callback # function # This function defines what should happen when the user # presses on the 'Start Tracking' Button def start_experiment_function(self): experiment_is_go = True # currently ony resolution of 640x480 is allowed. Might be a # new feature in the future if self.controller.all_common_variables.resolution != '640x480': tk.messagebox.showerror( 'Invalid resolution', 'It is only possible to do a tracking experiment\n' 'using the 640x480 resolution!\n' 'Please change resolution to start experiment!') experiment_is_go = False # also make sure the user defined the pixel/mm - otherwise # the experiment can not start! if self.controller.all_common_variables.pixel_per_mm_var.get() == 0: tk.messagebox.showerror( 'Define Pixel/mm', 'You have to define pixel per mm before starting\n' 'an experiment!\n' 'Please go to "options">"Define Pixel/mm" to do so!') experiment_is_go = False # make sure the intensity scaling is done between 0 and 100% # percent! if not 0 \ <= float(self.controller.all_common_variables.vr_intensity_adjustment_variable.get()) \ <= 100: tk.messagebox.showerror( 'Adjust power in percent', 'Power is adjusted in percent. The value has to be ' 'between 0 and 100. You have entered ' + repr( float(self.controller.all_common_variables.vr_intensity_adjustment_variable.get()))) experiment_is_go = False # if arena is chosen where the animal angle is taken into # account the animal detection mode must be mode 3! # It wouldn't make sense otherwise as the software can not # know in which direction the animal is heading if self.controller.all_common_variables.placed_animal is not None: if len(self.controller.all_common_variables.placed_animal) == 3 \ and self.controller.all_common_variables.animal_detection_method_var.get() != 'Mode 3': tk.messagebox.showerror( 'Can not define orientation', 'You have selected an arena which is supposed to ' 'be positioned relative to the orientation of the ' 'animal.\n' 'This is only possible with Animal Detection Mode 3!\n' 'Either choose an arena without alignment of arena ' 'to orientation of the animal or select Mode 3 in' '"options">"Animal Detection Method"' ) experiment_is_go = False # if user selects time varying arena and wants to adjust the # arena intensity, throw error as this is not implement! if self.controller.all_common_variables.vr_arena_multidimensional \ and float(self.controller.all_common_variables.vr_intensity_adjustment_variable.get()) != 100.0: tk.messagebox.showwarning( 'Time varying arena can not be scaled', 'You have selected a arena that varies in time and ' 'you try to scale it by ' + repr(float(self.controller.all_common_variables.vr_intensity_adjustment_variable.get())) + '.The scaling of time varying arenas is currently ' 'not implemented. To start the experiment enter "100" ' 'in "Adjust Power [%]"' ) # Here the arena is translated into the proper number range. # Implicit assumptions at this point: # 1) Multidimensional arenas are in uint8, the number space goes from 0 to 255 # 2) static virtual arenas are in uint16, the number space goes from 0 to 65535 # # The reasons: # obviously uint16 allows for much finer grain gradients than uint8. A static, and therefore 2-dimensional # uint16 array is neglible small, considering RAM. # A 3D, time-varying array is much larger. On RAM, uint8 is about half the size of uint16. I chose, at this # point, to just make the time-varying arrays uint8 to have more timepoints I can use. This can easily be # changed in the future, of course if self.controller.all_common_variables.vr_arena_multidimensional: try: #vr_arena = self.controller.all_common_variables.vr_arena * \ # (self.controller.all_common_variables.pwm_range / 255) if RASPBERRY: # first, make an explicit copy - very memory inefficient. Strongly constrains how large the # dynamic arena can be - in the future improve this! But make sure not to introduce a bug that will # only appear after running the arena a couple of times! vr_arena = self.controller.all_common_variables.vr_arena.copy() except MemoryError: tk.messagebox.showerror( 'Memory Error', 'The arena you attempted to run the experiment ' 'with is too large for the ' 'RaspberryPi to handle and it ran out of RAM.\n' 'Tips to reduce size of your time-varying ' 'virtual arena:\n' '1.) Make sure you are using uint8 number space\n' '2.) Reduce the number of timepoints') experiment_is_go = False else: if RASPBERRY: # first, make an explicit copy - memory is not a # problem when not working with dynamical arrays! # this is explicit and can't really break as the # original vr_arena is never touched, just a copy of it vr_arena = self.controller.all_common_variables.vr_arena.copy() # Now calculate the actual pwm range #vr_arena *= (self.controller.all_common_variables.pwm_range / 65535) if experiment_is_go: # boxsize is the area in all four directions starting # from the bounding box of the animal that will be used # in the next frame to look for the animal. It depends on # the speed of the animal and the framerate # boxsize is calculated for each experiment: # max_speed_of_animal_in_mm_per_sec / framerate (to get # speed in mm/frames) then multiplied by pixel per mm to # get speed in pixel/frame, the actualy parameter that is # needed for the program to function boxsize = (organisms_and_heuristics[ self.controller.all_common_variables.model_organism_variable.get()][ 'max_speed_animal_mm_per_s'] / int( self.controller.all_common_variables.framerate_entry_variable.get()) * self.controller.all_common_variables.pixel_per_mm_var.get()) # since the boxsize now also depends on the max speed of # the animal and the framerate it can become extremely # small (i.e. a larva that moves 2mm/s at 30frames will # only move 0.066mm which at 5px/mm is only 0.33pixel. If # in any frame the animal is not completely detected the # algorithm could never recover. This is why the length # of the animal must be taken into account as well! boxsize = boxsize + (organisms_and_heuristics[ self.controller.all_common_variables.model_organism_variable.get()][ 'max_skeleton_length_mm'] * self.controller.all_common_variables.pixel_per_mm_var.get()) print('boxsize is ' + repr(boxsize)) print('starting experiment from the vr class in the GUI') print(np.amax(vr_arena)) vr_arena_name = self.controller.all_common_variables.vr_arena_name.split('/')[-1] control_file.ControlTracking( boxsize=boxsize, signal=self.controller.all_common_variables.signal, cam=self.controller.all_common_variables.cam, base_path=self.controller.all_common_variables.path_entry_variable.get(), genotype= self.controller.all_common_variables.genotype_entry_variable.get(), recording_framerate=int(self.controller.all_common_variables.framerate_entry_variable.get()), resolution=self.controller.all_common_variables.resolution, recordingtime=int(self.controller.all_common_variables.recording_time_variable.get()), #preview=self.controller.all_common_variables.experiment_observation_mode_output, #preview_resize=self.controller.all_common_variables.preview_resize, pixel_per_mm=self.controller.all_common_variables.pixel_per_mm_var.get(), model_organism=self.controller.all_common_variables.model_organism_variable.get(), vr_arena=vr_arena, pwm_object=self.controller.all_common_variables.pwm_object, placed_animal=self.controller.all_common_variables.placed_animal, vr_arena_name=vr_arena_name, high_power_led_bool=self.controller.all_common_variables.high_power_LEDs_bool.get(), organisms_and_heuristics=organisms_and_heuristics, debug_mode=self.controller.all_common_variables.debug_mode_var.get(), animal_detection_mode=self.controller.all_common_variables.animal_detection_method_var.get(), output_channel_one=self.controller.all_common_variables.channel_one, output_channel_two=self.controller.all_common_variables.channel_two, output_channel_three=self.controller.all_common_variables.channel_three, output_channel_four=self.controller.all_common_variables.channel_four, overlay_bool=self.controller.all_common_variables.overlay_bool, controller=self.controller, background_channel = self.controller.all_common_variables.background, background_2_channel = self.controller.all_common_variables.background_two, background_dutycycle=self.controller.all_common_variables.backlight_intensity_value, background_2_dutycycle=self.controller.all_common_variables.backlight_two_intensity_value, #vr_update_rate=self.controller.all_common_variables.vr_update_rate, pwm_range=self.controller.all_common_variables.pwm_range, adjust_intensity=float(self.controller.all_common_variables.vr_intensity_adjustment_variable.get()), vr_stim_location=self.controller.all_common_variables.vr_stim_loc_var.get(), )
[docs]class DynamicVirtualRealityFrame(tk.Frame): """ The constructor class used to create the "Dynamic VR Arena" frame. """ def __init__(self, parent, controller, camera_class=None): # discussion about different ways to create the class # https://stackoverflow.com/questions/7300072/inheriting-from-frame-or-not-in-a-tkinter-application and # https://stackoverflow.com/questions/17466561/best-way-to-structure-a-tkinter-application/17470842#17470842 tk.Frame.__init__(self, parent) # reference the camera and the controller self.camera_class = camera_class self.cam = self.camera_class.cam self.controller = controller # Here the frame that will hold all the camera controls is # being prepared. self.sub_frames = SubFrames( self.camera_class, self.controller, cam_frame=True, misc_frame=True, observation_mode=False, distance_configuration=False, model_organism=False, exp_ctr_frame=True, start_text='Start Tracking, dynamic VR', experiment_name='Dynamic VR', VR_arena=True, frame=self, quit_frame=False, dynamic_VR_arena=True) # After the construction of the frame it needs to watch out for user input. self.controller.all_common_functions.menu_callback_shared( cam=True, backlight=True, analog_output_one=True, ) # todo - continue here by adding the ifs of the callback function
[docs] def start_experiment_function(self): """ Each constructor class which is used to start an experiment has this function. They all have the same name. This is the one in the "DynamicVirtualRealityFrame" It checks for: #) correct camera resolution, #) that the user has specified the pixel per mm #) that a copy of the dynamic virtual reality fits into RAM memory. If one of these tests fails, the user gets an error message and the experiment will not start. If the experiment does start, the :py:class:`control_file.ControlTracking` is called that then handles the detection and tracking of the animal. """ experiment_is_go = True # currently ony resolution of 640x480 is allowed. Might be a # new feature in the future if self.controller.all_common_variables.resolution != '640x480': tk.messagebox.showerror( 'Invalid resolution', 'It is only possible to do a tracking experiment' '\nusing the 640x480 resolution!' '\nPlease change resolution to start experiment!') experiment_is_go = False # also make sure the user defined the pixel/mm - otherwise # the experiment can not start! if self.controller.all_common_variables.pixel_per_mm_var.get() == 0: tk.messagebox.showerror( 'Define Pixel/mm', 'You have to define pixel per mm before starting' '\nan experiment!' '\nPlease go to "options">"Define Pixel/mm" to do so!') experiment_is_go = False try: if RASPBERRY: # first, make an explicit copy - very memory # inefficient. Strongly constrains how large the # dynamic arena can be - in the future improve this! # But make sure not to introduce a bug that will # only appear after running the arena a couple # of times! vr_arena = self.controller.all_common_variables.vr_arena.copy() except MemoryError: tk.messagebox.showerror( 'Memory Error', 'The arena you attempted to run the experiment with ' 'is too large for the RaspberryPi to handle and ' 'it ran out of RAM.' '\nTips to reduce size of your time-varying virtual arena:' '\n1.) Make sure you are using uint8 number space' '\n2.) Reduce the number of timepoints') experiment_is_go = False if experiment_is_go: # boxsize is the area in all four directions starting # from the bounding box of the animal that will be used # in the next frame to look for the animal. It depends on # the speed of the animal and the framerate. # boxsize is calculated for each experiment: # max_speed_of_animal_in_mm_per_sec / framerate (to get # speed in mm/frames) then multiplied by pixel per mm to # get speed in pixel/frame, the actualy parameter that is # needed for the program to function. boxsize = ( organisms_and_heuristics[ self.controller.all_common_variables.model_organism_variable.get()][ 'max_speed_animal_mm_per_s'] / int( self.controller.all_common_variables.framerate_entry_variable.get()) * self.controller.all_common_variables.pixel_per_mm_var.get()) # since the boxsize now also depends on the max speed of # the animal and the framerate it can become extremely # small (i.e. a larva that moves 2mm/s at 30frames will # only move 0.066mm which at 5px/mm is only 0.33pixel # If in any frame the animal is not completely detected # the algorithm could never recover. This is why the # length of the animal must be taken into account as well! boxsize = boxsize \ + (organisms_and_heuristics[ self.controller.all_common_variables.model_organism_variable.get()][ 'max_skeleton_length_mm'] \ * self.controller.all_common_variables.pixel_per_mm_var.get()) # Finally, grab the name of the arena vr_arena_name = self.controller.all_common_variables.vr_arena_name.split('/')[-1] control_file.ControlTracking( boxsize=boxsize, signal=self.controller.all_common_variables.signal, cam=self.controller.all_common_variables.cam, base_path=self.controller.all_common_variables.path_entry_variable.get(), genotype= self.controller.all_common_variables.genotype_entry_variable.get(), recording_framerate=int(self.controller.all_common_variables.framerate_entry_variable.get()), resolution=self.controller.all_common_variables.resolution, recordingtime=int(self.controller.all_common_variables.recording_time_variable.get()), pixel_per_mm=self.controller.all_common_variables.pixel_per_mm_var.get(), model_organism=self.controller.all_common_variables.model_organism_variable.get(), vr_arena=vr_arena, pwm_object=self.controller.all_common_variables.pwm_object, placed_animal=self.controller.all_common_variables.placed_animal, vr_arena_name=vr_arena_name, high_power_led_bool=self.controller.all_common_variables.high_power_LEDs_bool.get(), organisms_and_heuristics=organisms_and_heuristics, debug_mode=self.controller.all_common_variables.debug_mode_var.get(), animal_detection_mode=self.controller.all_common_variables.animal_detection_method_var.get(), output_channel_one=self.controller.all_common_variables.channel_one, output_channel_two=self.controller.all_common_variables.channel_two, output_channel_three=self.controller.all_common_variables.channel_three, output_channel_four=self.controller.all_common_variables.channel_four, overlay_bool=self.controller.all_common_variables.overlay_bool, controller=self.controller, background_channel = self.controller.all_common_variables.background, background_2_channel = self.controller.all_common_variables.background_two, background_dutycycle=self.controller.all_common_variables.backlight_intensity_value, background_2_dutycycle=self.controller.all_common_variables.backlight_two_intensity_value, vr_update_rate=self.controller.all_common_variables.vr_update_rate, pwm_range=self.controller.all_common_variables.pwm_range, adjust_intensity=float(self.controller.all_common_variables.vr_intensity_adjustment_variable.get()), vr_stim_location=self.controller.all_common_variables.vr_stim_loc_var.get(), )
class FullFrameImagesRecording(tk.Frame): def __init__(self, parent, controller, camera_class=None): tk.Frame.__init__(self, parent) self.controller = controller self.camera_class = camera_class self.cam = self.camera_class.cam # Here the frame that will hold all the camera controls is being prepared. #self.subframe_preexperiment = tk.LabelFrame(self, text='Full Frame Image Recording') #self.subframe_preexperiment.grid(row=1, column=0) # construct the window by calling the SubFrames class with whatever we need. This instance is then bound to the # variable self.sub_frames to make it's variables etc available self.sub_frames = SubFrames(self.camera_class, self.controller, cam_frame=True, misc_frame=True, observation_mode=False, distance_configuration=False, model_organism=False, exp_ctr_frame=True, start_text='Start Recording Images', experiment_name='Image Sequence', VR_arena=False, frame=self, quit_frame=False, time_dependent_stim_Frame=True ) # After the construction of the frame it needs to watch out for user input. self.controller.all_common_functions.menu_callback_shared(cam=True, backlight=True, analog_output_one=True, ) # todo - continue here by adding the ifs of the callback function # This function defines what should happen when the user presses on the 'Start Tracking' Button if RASPBERRY: def start_experiment_function(self): self.cam.framerate = int(self.controller.all_common_variables.framerate_entry_variable.get()) print('starting experiment from tracking frame') record_videos_and_image_sequences.RecordFullFrameImages( cam=self.controller.all_common_variables.cam, base_path=self.controller.all_common_variables.path_entry_variable.get(), genotype= self.controller.all_common_variables.genotype_entry_variable.get(), recording_framerate=int(self.controller.all_common_variables.framerate_entry_variable.get()), resolution=self.controller.all_common_variables.resolution, recording_time=int(self.controller.all_common_variables.recording_time_variable.get()), pixel_per_mm=self.controller.all_common_variables.pixel_per_mm_var.get(), model_organism=self.controller.all_common_variables.model_organism_variable.get(), time_dependent_stim_file=self.controller.all_common_variables.time_dependent_stimulation_file, #stim_GPIO=STIM_GPIO_1, pwm_object=self.controller.all_common_variables.pwm_object, output_channel_one=self.controller.all_common_variables.channel_one, output_channel_two=self.controller.all_common_variables.channel_two, output_channel_three=self.controller.all_common_variables.channel_three, output_channel_four=self.controller.all_common_variables.channel_four, image_format = self.controller.all_common_variables.image_sequence_format_var.get(), high_power_led_bool=self.controller.all_common_variables.high_power_LEDs_bool.get(), pwm_range = self.controller.all_common_variables.pwm_range, background_channel=self.controller.all_common_variables.background, background_2_channel=self.controller.all_common_variables.background_two, background_dutycycle=self.controller.all_common_variables.backlight_intensity_value, background_2_dutycycle=self.controller.all_common_variables.backlight_two_intensity_value ) print('calling GPIO fully off now') self.controller.all_common_functions.turn_GPIO_fully_off( output_channel_one=self.controller.all_common_variables.channel_one, output_channel_two=self.controller.all_common_variables.channel_two, output_channel_three=self.controller.all_common_variables.channel_three, output_channel_four=self.controller.all_common_variables.channel_four) else: def start_experiment_function(self): print('you can not record images while not on the Raspberry Pi') class VideoFrame(tk.Frame): def __init__(self, parent, controller, camera_class=None): tk.Frame.__init__(self, parent) self.controller = controller self.camera_class = camera_class self.cam = self.camera_class.cam # Here the frame that will hold all the camera controls is being prepared. #self.subframe_preexperiment = tk.LabelFrame(self, text='Video') #self.subframe_preexperiment.grid(row=1, column=0) # construct the window by calling the SubFrames class with whatever we need. This instance is then bound to the # variable self.sub_frames to make it's variables etc available self.sub_frames = SubFrames(self.camera_class, self.controller, cam_frame=True, misc_frame=True, observation_mode=False, distance_configuration=False, model_organism=False, exp_ctr_frame=True, start_text='Start Video Recording', experiment_name='Video', VR_arena=False, frame=self, quit_frame=False, time_dependent_stim_Frame=True ) # After the construction of the frame it needs to watch out for user input. self.controller.all_common_functions.menu_callback_shared(cam=True, backlight=True, analog_output_one=True, ) # todo - continue here by adding the ifs of the callback function if RASPBERRY or virtual_raspberry: def start_experiment_function(self): record_videos_and_image_sequences.RecordVideo(genotype= self.controller.all_common_variables.genotype_entry_variable.get(), recording_framerate=int(self.controller.all_common_variables.framerate_entry_variable.get()), resolution=self.controller.all_common_variables.resolution, recordingtime=int(self.controller.all_common_variables.recording_time_variable.get()), signal=self.controller.all_common_variables.signal, cam=self.cam, base_path=self.controller.all_common_variables.path_entry_variable.get(), time_dependent_stim_file=self.controller.all_common_variables.time_dependent_stimulation_file, #stim_GPIO=[STIM_GPIO_1, STIM_GPIO_2, STIM_GPIO_3], pwm_object=self.controller.all_common_variables.pwm_object, model_organism=self.controller.all_common_variables.model_organism_value, pixel_per_mm=self.controller.all_common_variables.pixel_per_mm_var.get(), output_channel_one=self.controller.all_common_variables.channel_one, output_channel_two=self.controller.all_common_variables.channel_two, output_channel_three=self.controller.all_common_variables.channel_three, output_channel_four=self.controller.all_common_variables.channel_four, high_power_led_bool=self.controller.all_common_variables.high_power_LEDs_bool.get(), pwm_range = self.controller.all_common_variables.pwm_range ) # turn of GPIOs of Channel one - keep in loop instead of just saying GPIO17 off for forward compatibility!! # list comprehension of Channel 1 self.controller.all_common_functions.turn_GPIO_fully_off( output_channel_one=self.controller.all_common_variables.channel_one, output_channel_two=self.controller.all_common_variables.channel_two, output_channel_three=self.controller.all_common_variables.channel_three, output_channel_four=self.controller.all_common_variables.channel_four) else: def start_experiment_function(self): print('you can not record a video if not on the RaspberryPi') class TrackedAnalysisFrame(tk.Frame): def __init__(self, parent, controller, camera_class=None): """ This constructor class used to create the “Analysis” frame in the "Tools" Menu. This frame allows the user to select either a single or a number of folders to analyze in several different ways. """ tk.Frame.__init__(self, parent) self.controller = controller # the variable that gets changed when the option menu for # tools is selected self.analysis_type_var = tk.StringVar() self.analysis_available_modes = ('Distance to source', 'Distance to source, VR', 'Single animal tracking') self.analysis_type_var.set(self.analysis_available_modes[0]) # the variable that is assinged to the Checkbutton below self.multiplefolders_var = tk.IntVar() self.multiplefolders = True # todo import previous variables bla self.just_changed = True self.files_and_folders_common = None # size of window relative to display screen self.size_of_window = tk.StringVar() # available options for window size self.available_size_of_window = ('Small', 'Medium', 'Large') self.size_of_window.set(self.available_size_of_window[0]) self.subframe_title = tk.Label( self, text='Analysis', font='Helvetica 12 bold') self.subframe_title.grid(row=0, column=0, columnspan=2) # Buttons etc. to select the desired folder(s) self.subframe_folder = tk.LabelFrame(self, text='Data') self.subframe_folder.grid(row=1, column=0, columnspan=2, sticky='nsew') self.pathlabel = tk.Label(self.subframe_folder, text='Data to be analyzed') self.pathlabel.grid(row=0, column=0) self.pathbutton = tk.Button(self.subframe_folder, text='Press to select data to analyze', command=self.select_images_tracked_analysis) self.pathbutton.grid(row=1, column=0) self.pathchosen = tk.Label(self.subframe_folder, text='no path chosen') self.pathchosen.grid(row=2, column=0) self.multiplecheck = tk.Checkbutton(self.subframe_folder, text='More than one folder', variable=self.multiplefolders_var, command=self.multiplefolder_callback, onvalue=True, offvalue=False) self.multiplefolders_var.set(self.multiplefolders) self.multiplecheck.grid(row=0, column=1) self.common_str_label = tk.Label(self.subframe_folder, text='What character string ' '\ndo all folders you want' '\nto analyze, share? ') self.common_str_label.grid(row=1, column=1) self.common_str = tk.StringVar() self.common_str_entry = tk.Entry(self.subframe_folder, width=10, textvariable=self.common_str) self.common_str_entry.grid(row=2, column=1) self.common_str.set('*') self.common_str_counted = tk.Label(self.subframe_folder, text='') self.common_str_counted.grid(row=3, column=1) # Other options self.subframe_option = tk.LabelFrame(self, text='') self.subframe_option.grid(row=2, column=0, sticky='nsew') self.analysis_type_label = tk.Label(self.subframe_option, text='What Analysis ' 'do\nyou want to do?') self.analysis_type_label.grid(row=0, column=0) self.analysis_type = tk.OptionMenu(self.subframe_option, self.analysis_type_var, *self.analysis_available_modes) self.analysis_type.grid(row=1, column=0) self.subframe_figure_size = tk.LabelFrame(self, text='') self.subframe_figure_size.grid(row=2, column=1, sticky='nsew') self.size_selection_label = tk.Label(self.subframe_figure_size, text='Select size\nof ' 'Figure') self.size_selection_label.grid(row=0, column=1) # make a button for user to change how large the display window should be self.size_button = tk.OptionMenu(self.subframe_figure_size, self.size_of_window, *self.available_size_of_window) self.size_button.grid(row=1, column=1) self.start_analysis_button = tk.Button(self, text='Press to start ' 'analysis', command=self.start_analysis) self.start_analysis_button.grid(row=3, column=0, columnspan=2) # callback every 700 ms self.menu_callback_shared() def start_analysis(self): """ This function is called when the user presses the "Press to start analysis" button. It checks which of the analysis options has been chosen: #. Distance to source: this will pass the image files to :py:class:`analysis_scripts.AnalysisDistanceToSource` #. Distance to source, VR: this will pass the image files to :py:class:`analysis_scripts.AnalysisVRDistanceToSource` #. Single animal tracking: this will pass the image file to :py:class:`control_file.ControlTracking` """ if self.analysis_type_var.get() == 'Distance to source': print(self.analysis_type_var.get()) analysis_scripts.AnalysisDistanceToSource( path=self.controller.all_common_variables.data_path, multiple_files=self.multiplefolders_var.get(), string=self.common_str.get(), size_of_window=self.size_of_window) elif self.analysis_type_var.get() == 'Distance to source, VR': print(self.analysis_type_var.get()) analysis_scripts.AnalysisVRDistanceToSource( path=self.controller.all_common_variables.data_path, multiple_files=self.multiplefolders_var.get(), string=self.common_str.get()) elif self.analysis_type_var.get() == 'Single animal tracking': # This variable is necessary as the code will go briefly # back to the main GUI while being in the wrong folder. # It will then crash. The fix is to save the state of the # variable self.files_and_folders_common in a new # variable that is not affected by GUI common_files_and_folders = self.files_and_folders_common def collect_info_and_start_tracking(): images, fps = initialize_image_data.get_self_images() save_experiment_settings = False # Will be changed # to True in case the experiment_settings file does # not exists yet! try: with open((os.getcwd() + '/experiment_settings.json'),'r') as file: self.controller.all_common_variables.experimental_metadata = json.load( file) try: self.controller.all_common_variables.framerate_read_from_experiment_settings = \ self.controller.all_common_variables.experimental_metadata[ 'Framerate'] framerate = \ self.controller.all_common_variables.framerate_read_from_experiment_settings except KeyError: self.controller.all_common_variables.framerate_read_from_experiment_settings = None try: pixel_per_mm = \ self.controller.all_common_variables.experimental_metadata[ 'Pixel per mm'] except ValueError: pixel_per_mm = None try: self.controller.all_common_variables.organism_read_from_experiment_settings = \ self.controller.all_common_variables.experimental_metadata[ 'Model Organism'] except KeyError: self.controller.all_common_variables.organism_read_from_experiment_settings = None except (ValueError, AttributeError, FileNotFoundError): save_experiment_settings = True # if pixel_per_mm never got defined ask user to do it # here! tk.messagebox.showinfo('Define Pixel per mm', 'To enable tracking, ' 'please select a file' '\n(image, video etc.) ' 'and define a known ' '\ndistance in that image.' '\n\n' 'Please consult the manual if ' 'unclear what to do!') distance_factor = distance_configuration_module \ .DistanceConfigurationStatic( known_distance=None) pixel_per_mm = ( round(distance_factor.distance_factor, 3)) print(pixel_per_mm) if self.controller.all_common_variables.framerate_read_from_experiment_settings is None: if fps is not None: framerate = int(fps) else: # child = tk.Toplevel() # child.grab_set() framerate = simpledialog.askinteger( "Framerate", "What is the framerate" "\nof the image sequence/video?", parent=self, minvalue=0, maxvalue=100000) # child.destry() else: framerate = self.controller.all_common_variables.framerate_read_from_experiment_settings # As this means that no experiment_settings.json file # exists yet, it can be created now and be used in # the future save_experiment_settings = True experiment_settings = {} experiment_settings["Pixel per mm"] = pixel_per_mm experiment_settings["Framerate"] = framerate experiment_settings["Resolution"] = repr( images.shape[1]) + 'x' + repr( images.shape[0]) experiment_settings['Recording time'] = \ images.shape[2] \ / framerate playback_speed = 100000 # todo - no playbay possible # anyway! This is an orphan variable, only used # to pass something to the controlTracking class - probably can get rid off # not sure this is true as it's possible to run this # with Debug Mode on # define the boxsize try: # boxsize is the area in all four directions # starting from the bounding box of the animal # that will be used in the next frame to look for # the animal. It depends on the spee of the # animal and the framerate boxsize is calculated # for each experiment: # max_speed_of_animal_in_mm_per_sec / framerate ( # to get speed in mm/frames) then multiplied by # pixel per mm to get speed in pixel/frame, # the actual parameter that is needed for the program to # function. This is then multiplied by two to # give more wiggle room as some animals move very # fast sometimes boxsize = (organisms_and_heuristics[ self.controller.all_common_variables.organism_read_from_experiment_settings][ 'max_speed_animal_mm_per_s'] / int( framerate) * pixel_per_mm) # since the boxsize now also depends on the max # speed of the animal and the framerate it can # become extremely small (i.e. a larva that moves # 2mm/s at 30frames will only move 0.066mm which # at 5px/mm is only 0.33pixel # If in any frame the animal is not completely # detected the algorithm could never recover. # This is why the length of the animal must be # taken into account as well! boxsize = boxsize + (organisms_and_heuristics[ self.controller.all_common_variables.organism_read_from_experiment_settings][ 'max_skeleton_length_mm'] * pixel_per_mm) except KeyError: # This happens for example when # experiment_settings.json # does not exists tk.messagebox.showinfo( "Not in List", "Can not find your organism in the " "'list_of_available_organisms.json'\n" "You are either missing the " "experiment_settings.json file in your " "experimental folder or\n" "use an undefined animal\n") max_speed_animal = simpledialog.askinteger( "Estimate movement speed", "Estimate the maximal movement speed" "\nof the animal you are tracking here." "\n\n" "For your reference:" "\na fruit fly larva crawls at up to 2mm/s and " "\nan adult fruit fly walks at up to 150mm/s", parent=self, minvalue=0, maxvalue=100000) boxsize = ( max_speed_animal/ int(framerate) * pixel_per_mm) skel_leng = simpledialog.askinteger( "Estimate animal length", "Estimate the maximal animal length of" "\nthe animal you are tracking here." "\n\n" "For you reference, a fruit fly larva is about" "\n5mm long", parent=self, minvalue=0, maxvalue=100000) boxsize = \ boxsize \ + (skel_leng* pixel_per_mm) print('boxsize' + repr(boxsize)) # get the model organism model_organism = self.controller.all_common_variables.organism_read_from_experiment_settings if model_organism is None: model_organism = 'Not in list' try: experiment_settings["Model Organism"] = \ model_organism except NameError: # not defined: pass # get the genotype genotype = self.controller.all_common_variables.genotype_read_from_experiment_settings if save_experiment_settings: with open(('experiment_settings.json'), 'w') as file: json.dump(experiment_settings, file, sort_keys=True, indent=4) control_file.ControlTracking( boxsize=boxsize, signal=self.controller.all_common_variables.signal, cam=images, genotype=genotype, recording_framerate=framerate, recordingtime=None, pixel_per_mm=pixel_per_mm, model_organism=model_organism, display_framerate=playback_speed, offline_analysis=True, organisms_and_heuristics=organisms_and_heuristics, post_hoc_tracking=True, debug_mode=self.controller.all_common_variables.debug_mode_var.get() ) if self.multiplefolders_var.get(): print('Will analyze ' + repr(len(self.files_and_folders_common)) + ' folders') for i_folder in range(len(common_files_and_folders)): print('Analyzing Folder: ' + self.controller.all_common_variables.data_path + '//' + common_files_and_folders[i_folder]) os.chdir( self.controller.all_common_variables.data_path + '//' + common_files_and_folders[i_folder]) collect_info_and_start_tracking() else: os.chdir(self.controller.all_common_variables.data_path) collect_info_and_start_tracking() def multiplefolder_callback(self): if self.multiplefolders_var.get(): print('multiplefolders') self.controller.access_subframes( 'TrackedAnalysisFrame').common_str_label.config( state='normal') self.controller.access_subframes( 'TrackedAnalysisFrame').common_str_entry.config( state='normal') else: print('one folder') self.controller.access_subframes( 'TrackedAnalysisFrame').common_str_label.config( state='disabled') self.controller.access_subframes( 'TrackedAnalysisFrame').common_str_entry.config( state='disabled') self.controller.access_subframes( 'TrackedAnalysisFrame').common_str_counted.configure(text='') self.just_changed = True def menu_callback_shared(self): # call this after every 700ms self.after(700, self.menu_callback_shared) if self.multiplefolders_var.get() and self.just_changed: # self.common_str_label.grid() # self.common_str.grid() pass elif self.just_changed: # self.common_str_label.grid_remove() # self.common_str_label.grid_remove() pass self.just_changed = False entered_text = self.common_str.get() self.files_and_folders_common = [p.replace('\\', '') for p in glob('*' + entered_text + '*/')] try: if self.controller.access_subframes( 'TrackedAnalysisFrame').multiplefolders_var.get(): self.common_str_counted.configure( text='Number of files: ' + repr(len(self.files_and_folders_common))) except KeyError: # Happens during instantiation pass # label = tk.Label(self, text="This is page is for Analysis - \nstill needs to be implemente", font=controller.title_font) # label.pack(side="top", fill="x", pady=10) # button = tk.Button(self, text="Go to the start page", # command=lambda: controller.show_frame("TrackingFrame")) # button.pack() def select_images_tracked_analysis(self): ''' self.image_path = filedialog.askdirectory() os.chdir(self.image_path) self.cam = self.image_path + '\\all_images.npy' path_to_show = '...' + self.image_path[-20:] self.pathchosen.configure(text=path_to_show) ''' self.controller.all_common_variables.data_path = filedialog.askdirectory() os.chdir(self.controller.all_common_variables.data_path) self.cam = self.controller.all_common_variables.data_path + DIRECTORY_INDICATOR + 'all_images.npy' path_to_show = '...' + self.controller.all_common_variables.data_path[-20:] self.pathchosen.configure(text=path_to_show) class ImageDataHandling(tk.Frame): def __init__(self, parent, controller, camera_class=None): """ This constructor class is used to create the "Image Data Handling" frame in the "Tools" Menu. This frame allows the user to select either a single of a number of folders to analyze in several different ways """ tk.Frame.__init__(self, parent) self.controller = controller # the variable that gets changed when the option menu for # tools is selected self.conversion_type_var = tk.StringVar() # the variable that is assinged to the Checkbutton below self.multiplefolders_var = tk.IntVar() self.multiplefolders = True # todo import previous variables bla self.files_and_folders_common = None self.conversion_available_modes = ('Image Seq. to matrix file', 'Video conversion', 'Undistort Video') self.conversion_type_var.set(self.conversion_available_modes[0]) self.video_type_var = tk.StringVar() self.video_formats_available = ('avi', 'mp4', 'None') self.video_type_var.set(self.video_formats_available[0]) self.video_codec_var = tk.StringVar() self.video_codec_available = ('h264', #'mpeg2video', Terrible quality 'rawvideo') self.video_codec_var.set(self.video_codec_available[0]) self.video_color_var = tk.StringVar() self.video_color_available = ('greyscale', 'color') self.video_color_var.set(self.video_color_available[0]) self.image_color_var = tk.StringVar() self.image_color_available = ('greyscale', 'color') self.image_color_var.set(self.image_color_available[0]) self.image_output_zip_var = tk.IntVar() self.image_output_zip_var.set(1) self.delete_images_var = tk.IntVar() self.delete_images_var.set(1) self.image_output_npy_var = tk.IntVar() self.image_output_npy_var.set(1) self.image_output_mat_var = tk.IntVar() self.image_output_mat_var.set(0) self.video_output_npy_var = tk.IntVar() self.video_output_npy_var.set(0) self.video_output_mat_var = tk.IntVar() self.video_output_mat_var.set(0) self.subframe_title = tk.Label( self, text='Image Data Handling', font='Helvetica 12 bold') self.subframe_title.grid(row=0, column=0, columnspan=3) # Buttons etc. to select the desired folder(s) self.subframe_folder = tk.LabelFrame(self, text='Data') self.subframe_folder.grid(row=1, column=0, columnspan=3, sticky='nsew') self.pathlabel = tk.Label(self.subframe_folder, text='Image data to modify') self.pathlabel.grid(row=0, column=0) self.pathbutton = tk.Button(self.subframe_folder, text='Press to select data to ' 'modify', command=self.select_folder) self.pathbutton.grid(row=1, column=0) self.pathchosen = tk.Label(self.subframe_folder, text='no path chosen') self.pathchosen.grid(row=2, column=0) self.multiplecheck = tk.Checkbutton(self.subframe_folder, text='More than one folder', variable=self.multiplefolders_var, command=self.multiplefolder_callback, onvalue=True, offvalue=False) self.multiplefolders_var.set(self.multiplefolders) self.multiplecheck.grid(row=0, column=1) self.common_str_label = tk.Label(self.subframe_folder, text='What character string ' '\ndo all folders you want' '\nto modify, share? ') self.common_str_label.grid(row=1, column=1) self.common_str = tk.StringVar() self.common_str_entry = tk.Entry(self.subframe_folder, width=10, textvariable=self.common_str) self.common_str_entry.grid(row=2, column=1) self.common_str.set('*') self.common_str_counted = tk.Label(self.subframe_folder, text='') self.common_str_counted.grid(row=3, column=1) # Other options self.subframe_option = tk.LabelFrame(self, text='') self.subframe_option.grid(row=2, column=0, sticky='nsew') self.conversion_type_label = tk.Label(self.subframe_option, text='What modifications ' 'do\nyou want to do?') self.conversion_type_label.grid(row=0, column=0) self.conversion_type = tk.OptionMenu(self.subframe_option, self.conversion_type_var, *self.conversion_available_modes) self.conversion_type.grid(row=1, column=0) # Let user select desired video output self.subframe_video_options = tk.LabelFrame( self, text='Video options') self.subframe_video_options.grid(row=2, column=1, sticky='nsew') self.select_output_video_label = tk.Label( self.subframe_video_options, text='Format') self.select_output_video_label.grid(row=0,column=0) self.select_output_video_format = tk.OptionMenu( self.subframe_video_options, self.video_type_var, *self.video_formats_available) self.select_output_video_format.grid(row=0, column=1) self.select_codec_video_label = tk.Label( self.subframe_video_options, text='Codec') self.select_codec_video_label.grid(row=1, column=0) self.select_output_video_codec = tk.OptionMenu( self.subframe_video_options, self.video_codec_var, *self.video_codec_available) self.select_output_video_codec.grid(row=1, column=1) self.select_color_menu = tk.OptionMenu( self.subframe_video_options, self.video_color_var, *self.video_color_available, ) self.select_color_menu.grid(row=2, column=0, columnspan=2) self.npy_button_video = tk.Checkbutton( self.subframe_video_options, text='Save *.npy', variable=self.video_output_npy_var, onvalue=True, offvalue=False) self.npy_button_video.grid(row=3,column=0, columnspan=2) self.mat_button_video = tk.Checkbutton( self.subframe_video_options, text='Save *.mat', variable=self.video_output_mat_var, onvalue=True, offvalue=False) self.mat_button_video.grid(row=4,column=0, columnspan=2) # Let user select output of image packing self.subframe_image_options = tk.LabelFrame( self, text='Image options') self.subframe_image_options.grid(row=2, column=2, sticky='nsew') self.zip_button = tk.Checkbutton( self.subframe_image_options, text='Zip images', variable=self.image_output_zip_var, onvalue=True, offvalue=False) self.zip_button.grid(row=0, column=0, sticky="W") self.delete_images = tk.Checkbutton( self.subframe_image_options, text='Delete original', variable=self.delete_images_var, onvalue=True, offvalue=False) self.delete_images.grid(row=1, column=0, sticky="W") self.select_color_images_menu = tk.OptionMenu( self.subframe_image_options, self.image_color_var, *self.image_color_available, ) self.select_color_images_menu.grid(row=2, column=0, sticky="W") self.npy_button = tk.Checkbutton( self.subframe_image_options, text='Save *.npy', variable=self.image_output_npy_var, onvalue=True, offvalue=False) self.npy_button.grid(row=3, column=0, sticky="W") self.mat_button = tk.Checkbutton( self.subframe_image_options, text='Save *.mat', variable=self.image_output_mat_var, onvalue=True, offvalue=False) self.mat_button.grid(row=4, column=0, sticky="W") self.start_conversion_button = tk.Button(self, text='Press to start ' 'conversion', command=self.start_conversion) self.start_conversion_button.grid(row=3, column=0, columnspan=3) # callback every 700 ms self.menu_callback_shared() def start_conversion(self): """ bar :return: """ if self.conversion_type_var.get() == 'Image Seq. to matrix file': image_data_handling.PackingImages( controller=self.controller, path = self.controller.all_common_variables.data_path, multiplefolders = self.multiplefolders_var.get(), folders = self.files_and_folders_common, zip=self.image_output_zip_var.get(), delete=self.delete_images_var.get(), npy=self.image_output_npy_var.get(), mat=self.image_output_mat_var.get(), color_mode = self.image_color_var.get() ) elif self.conversion_type_var.get() == 'Video conversion': image_data_handling.ConvertH264( path=self.controller.all_common_variables.data_path, multiplefolders=self.multiplefolders_var.get(), folders=self.files_and_folders_common, save_npy=self.video_output_npy_var.get(), save_mat=self.video_output_mat_var.get(), color_mode = self.video_color_var.get(), output_video_format = self.video_type_var.get(), codec = self.video_codec_var.get() ) elif self.conversion_type_var.get() == 'Undistort Video': image_data_handling.UndistortH264( path=self.controller.all_common_variables.data_path, multiplefolders=self.multiplefolders_var.get(), folders=self.files_and_folders_common, save_npy=self.video_output_npy_var.get(), save_mat=self.video_output_mat_var.get(), #color_mode = self.video_color_var.get(), output_video_format = self.video_type_var.get(), codec=self.video_codec_var.get() ) def multiplefolder_callback(self): if self.multiplefolders_var.get(): print('multiplefolders') self.controller.access_subframes( 'ImageDataHandling').common_str_label.config( state='normal') self.controller.access_subframes( 'ImageDataHandling').common_str_entry.config( state='normal') else: print('one folder') self.controller.access_subframes( 'ImageDataHandling').common_str_label.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').common_str_entry.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').common_str_counted.configure(text='') def menu_callback_shared(self): # call this after every 700ms self.after(700, self.menu_callback_shared) entered_text = self.common_str.get() self.files_and_folders_common = [p.replace('\\', '') for p in glob( '*' + entered_text + '*/')] try: if self.controller.access_subframes( 'ImageDataHandling').multiplefolders_var.get(): self.common_str_counted.configure( text='Number of files: ' + repr(len(self.files_and_folders_common))) except KeyError: # Happens during instantiation pass try: if self.conversion_type_var.get() == 'Image Seq. to matrix file': self.controller.access_subframes( 'ImageDataHandling').select_output_video_format.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').select_output_video_codec.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').select_color_menu.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').npy_button_video.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').mat_button_video.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').zip_button.config( state='normal') self.controller.access_subframes( 'ImageDataHandling').delete_images.config( state='normal') self.controller.access_subframes( 'ImageDataHandling').npy_button.config( state='normal') self.controller.access_subframes( 'ImageDataHandling').mat_button.config( state='normal') elif self.conversion_type_var.get() == 'Video conversion'\ or 'Undistort Video': self.controller.access_subframes( 'ImageDataHandling').select_output_video_format.config( state='normal') self.controller.access_subframes( 'ImageDataHandling').select_output_video_codec.config( state='normal') self.controller.access_subframes( 'ImageDataHandling').npy_button_video.config( state='normal') self.controller.access_subframes( 'ImageDataHandling').mat_button_video.config( state='normal') self.controller.access_subframes( 'ImageDataHandling').zip_button.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').delete_images.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').npy_button.config( state='disabled') self.controller.access_subframes( 'ImageDataHandling').mat_button.config( state='disabled') # the color is a bit special - only works for video # conversion, not for undistort! So force greyscale # in Undistort! if self.conversion_type_var.get() == 'Video conversion': self.controller.access_subframes( 'ImageDataHandling').select_color_menu.config( state='normal') else: self.controller.access_subframes( 'ImageDataHandling').video_color_var.set( self.video_color_available[0]) self.controller.access_subframes( 'ImageDataHandling').select_color_menu.config( state='disabled') except KeyError: # Breaks during instantiations pass def select_folder(self): """ When user clicks on "Press to select data to modify" this function is called: It lets the user select a folder, changes the current working directory and changes the path shown in the GUI. """ self.controller.all_common_variables.data_path = filedialog.askdirectory() os.chdir(self.controller.all_common_variables.data_path) path_to_show = '...' + self.controller.all_common_variables.data_path[-20:] self.pathchosen.configure(text=path_to_show) class DisplayTrackedImage(tk.Frame): def __init__(self, parent, controller, camera_class=None): tk.Frame.__init__(self, parent) self.controller = controller # if previous_variables bla # get image path # self.data_path = None # todo don't think we need, get rid after testing self.framerate = 0 self.colormap_options = ('Greys_r', 'viridis', 'plasma', 'magma', 'afmhot', 'cool') self.colormap_variable = tk.StringVar() self.colormap_variable.set(self.colormap_options[0]) self.subframe_title = tk.Label( self, text='Display Tracked Experiment', font='Helvetica 12 bold') self.subframe_title.grid(row=0, column=0, columnspan=4) self.pathbutton = tk.Button(self, text='Select data to analyze', command=self.select_images_display_tracked_image) self.pathbutton.grid(row=1, column=0, columnspan=2) self.pathchosen = tk.Label(self, text='no data chosen yet') self.pathchosen.grid(row=2, column=0, columnspan=2) self.experiment_date_n_time_frame = tk.LabelFrame(self, text='Experiment Date/Time') self.experiment_date_n_time_frame.grid(row=3, column=0, sticky='nsew') self.experiment_date_n_time_label = tk.Label(self.experiment_date_n_time_frame, text='') self.experiment_date_n_time_label.grid(row=0, column=0) self.framerate_label_frame = tk.LabelFrame(self, text='Framerate') self.framerate_label_frame.grid(row=4, column=0, sticky='nsew') self.framerate_label_label = tk.Label(self.framerate_label_frame, text='') self.framerate_label_label.grid(row=0, column=0) self.recording_time_frame = tk.LabelFrame(self, text='Recorded Time') self.recording_time_frame.grid(row=5, column=0, sticky='nsew') self.recording_time_label = tk.Label(self.recording_time_frame, text='') self.recording_time_label.grid(row=0, column=0) self.resolution_frame = tk.LabelFrame(self, text='Resolution') self.resolution_frame.grid(row=6, column=0, sticky='nsew') self.resolution_label = tk.Label(self.resolution_frame, text='') self.resolution_label.grid(row=0, column=0) self.species_frame = tk.LabelFrame(self, text='Species') self.species_frame.grid(row=3, column=1, sticky='nsew') self.species_label = tk.Label(self.species_frame, text='') self.species_label.grid(row=0, column=0) self.genotype_frame = tk.LabelFrame(self, text='Exp. group') self.genotype_frame.grid(row=4, column=1, sticky='nsew') self.genotype_label = tk.Label(self.genotype_frame, text='') self.genotype_label.grid(row=0, column=0) self.pixel_per_mm_frame = tk.LabelFrame(self, text='Pixel per mm') self.pixel_per_mm_frame.grid(row=6, column=1, sticky='nsew') self.pixel_per_mm_label = tk.Label(self.pixel_per_mm_frame, text='') self.pixel_per_mm_label.grid(row=0, column=0) self.colormap_label = tk.Label(self, text='Select Colormap') self.colormap_label.grid(row=5, column=3) self.colormap_menu = tk.OptionMenu(self, self.colormap_variable, *self.colormap_options) self.colormap_menu.grid(row=5, column=4) self.start_analysis_button = tk.Button(self, text='Press to show \nthe behavior of the animal', command=self.visualize_experiment_func) self.start_analysis_button.grid(row=6, column=3, columnspan=2) # Display the image of the tracked animal # Due to the garbage collection of Python we need to keep the reference of the self.image_object! self.image_object = ImageTk.PhotoImage(Image.open(self.controller.path_of_program + 'pics/tracked_placeholder.jpg').resize((160, 120))) self.image_label = tk.Label(self, image=self.image_object) self.image_label.grid(row=3, column=2, rowspan=4) self.updated_image = None self.background_image = None self.experiment_csv = None self.common_str_counted = tk.Label(self, text='') self.common_str_counted.grid(row=4, column=1) # callback every 700 ms self.menu_callback() def menu_callback(self): # call this after every 700ms self.after(700, self.menu_callback) def select_images_display_tracked_image(self): if self.controller.all_common_variables.data_path is not None: self.controller.all_common_variables.data_path = \ filedialog.askdirectory(initialdir=self.controller.all_common_variables.data_path) else: self.controller.all_common_variables.data_path = filedialog.askdirectory() os.chdir(self.controller.all_common_variables.data_path) self.cam = self.controller.all_common_variables.data_path + '/all_images.npy' path_to_show = '...' + self.controller.all_common_variables.data_path[-30:] self.pathchosen.configure(text=path_to_show) with open((self.controller.all_common_variables.data_path + '/experiment_settings.json'), 'r') as file: experiment_settings = json.load(file) try: self.experiment_date_n_time_label.configure(text=experiment_settings['Experiment Date and Time']) except KeyError: # if post-hoc experiment, this Key is not created and # would lead to a Key error without this try..except pass self.framerate_label_label.configure(text=repr(experiment_settings['Framerate']) + 'fps') self.framerate = experiment_settings['Framerate'] self.recording_time_label.configure(text=repr(experiment_settings['Recording time']) + 's') self.resolution_label.configure(text=experiment_settings['Resolution']) self.species_label.configure(text=experiment_settings['Model Organism']) if 'Exp. group' in experiment_settings: self.genotype_label.configure(text=experiment_settings['Exp. group']) elif 'Genotype' in experiment_settings: self.genotype_label.configure(text=experiment_settings['Genotype']) self.pixel_per_mm_label.configure(text=experiment_settings['Pixel per mm']) # todo - kick this out at one point - at the moment still have mixed folders! try: self.updated_image = ImageTk.PhotoImage(Image.open(self.controller.all_common_variables.data_path + '/Overview of SmA-T tracking.png').resize((160, 120))) except FileNotFoundError: try: self.updated_image = ImageTk.PhotoImage(Image.open(self.controller.all_common_variables.data_path + '/Overview of SmAl-VR tracking.png').resize( (160, 120))) except FileNotFoundError: try: self.updated_image = ImageTk.PhotoImage(Image.open(self.controller.all_common_variables.data_path + '/Overview of smAL-VR tracking.png').resize( (160, 120))) except FileNotFoundError: self.updated_image = ImageTk.PhotoImage(Image.open(self.controller.all_common_variables.data_path + '/Overview of tracking.png').resize( (160, 120))) self.image_label.configure(image=self.updated_image) self.image_label.image = self.updated_image self.background_image = imageio.imread( self.controller.all_common_variables.data_path + '/Background.jpg') files = [p.replace('\\', '') for p in glob('*')] for i in files: if 'data.csv' in i: data_name = i self.experiment_csv = pd.read_csv(self.controller.all_common_variables.data_path + '/' + data_name, sep=',') def visualize_experiment_func(self): visualize_tracked_experiment.VisualizeTrackedExperiment(csv_data=self.experiment_csv, background_image=self.background_image, data_path=self.controller.all_common_variables.data_path, recording_framerate=self.framerate, colormap=self.colormap_variable.get()) class SimulateOnlineExperiment(tk.Frame): def __init__(self, parent, controller, camera_class=None): tk.Frame.__init__(self, parent) # reference the camera and the controller self.camera_class = camera_class self.cam = self.camera_class.cam self.controller = controller # only start experiment if all conditions are fullfilled! self.can_experiment_start = True # self.data_path = None # todo Don't think we need, get rid after testing self.entered_text = None self.timestamps = None self.framerate = None # can't use a textvariable as we'll use both strings and numbers here! self.species = None self.genotype = None # Here the frame that will hold all the camera controls is being prepared. self.subframe_preexperiment = tk.LabelFrame(self, text='') self.subframe_preexperiment.grid(row=0, column=0) # construct the window by calling the SubFrames class with whatever we need. This instance is then bound to the # variable self.sub_frames to make it's variables etc available self.sub_frames = SubFrames(self.camera_class, self.controller, cam_frame=False, subframe_preexperiment=self.subframe_preexperiment, misc_frame=True, observation_mode=False, distance_configuration=False, model_organism=False, exp_ctr_frame=False, VR_arena=False, frame=self, quit_frame=False, display_experiment_settings=True, convert_images_frame=True ) def start_experiment_function(self): if self.controller.all_common_variables.framerate_read_from_experiment_settings is None: tk.messagebox.showerror("Warning", "No Framerate specified!\n" "Please define framerate that was used to record\n" "this video/image sequence in the 'Fix Metadata'\n" "menu before simulating the tracking") self.can_experiment_start = False else: framerate = self.controller.all_common_variables.framerate_read_from_experiment_settings if self.controller.all_common_variables.pixel_per_mm_read_from_experiment_settings is None: tk.messagebox.showerror("Warning", "No Pixel per mm specified!\n" "Please define pixel/mm that was used to record\n" "this video/image sequence in the 'Fix Metadata'\n" "menu before simulating the tracking") self.can_experiment_start = False else: pixel_per_mm = self.controller.all_common_variables.pixel_per_mm_read_from_experiment_settings if self.can_experiment_start: images, fps = initialize_image_data.get_self_images() # currently ony resolution of 640x480 is allowed. Might be a new feature in the future if images.shape[0] != 480 or images.shape[1] != 640: tk.messagebox.showinfo('Incompatible resolution', 'You have selected an experiment with resolution ' + repr(images.shape[1]) + 'x' + repr(images.shape[0])+'\n' 'You can analyze this experiment but for online tracking\n' 'you must select a resolution of 640x480') if self.controller.all_common_variables.playback_speed_var.get() == '0.1X': playback_speed = framerate * 0.1 elif self.controller.all_common_variables.playback_speed_var.get() == '0.5X': playback_speed = framerate * 0.5 elif self.controller.all_common_variables.playback_speed_var.get() == '1X': playback_speed = framerate * 1 elif self.controller.all_common_variables.playback_speed_var.get() == '2X': playback_speed = framerate * 2 elif self.controller.all_common_variables.playback_speed_var.get() == '5X': playback_speed = framerate * 5 elif self.controller.all_common_variables.playback_speed_var.get() == 'Fastest': playback_speed = 100000 # as long as no one is using a supercomputer we should be fine, # otherwise add a zero! print('playback speed will be: ' + repr(playback_speed) + 'fps') # boxsize is the area in all four directions starting from the bounding box of the animal that will # be used in the next frame to look for the animal. It depends on the speed of the animal and the # framerate # boxsize is calculated for each experiment: # max_speed_of_animal_in_mm_per_sec / framerate (to get speed in mm/frames) then multiplied by # pixel per mm to get speed in pixel/frame, the actualy parameter that is needed for the program to # function. This is then multiplied by two to give more wiggle room as some animals move very fast sometimes boxsize = (organisms_and_heuristics[ self.controller.all_common_variables.organism_read_from_experiment_settings][ 'max_speed_animal_mm_per_s'] / int(framerate) * pixel_per_mm) # since the boxsize now also depends on the max speed of the animal and the framerate it can become extremely # small (i.e. a larva that moves 2mm/s at 30frames will only move 0.066mm which at 5px/mm is only 0.33pixel # If in any frame the animal is not completely detected the algorithm could never recover. This is why the # length of the animal must be taken into account as well! boxsize = boxsize + (organisms_and_heuristics[ self.controller.all_common_variables.organism_read_from_experiment_settings][ 'max_skeleton_length_mm'] * pixel_per_mm) print('boxsize is ' + repr(boxsize)) control_file.ControlTracking(boxsize=boxsize, signal=self.controller.all_common_variables.signal, cam=images, base_path=None, genotype=self.controller.all_common_variables.genotype_read_from_experiment_settings, recording_framerate=framerate, recordingtime=None, resolution=[images.shape[1], images.shape[0]], # preview=None, # preview_resize=self.controller.all_common_variables.observation_resize_variable.get(), pixel_per_mm=float(self.controller.access_subframes( self.controller.current_window).sub_frames.pixel_per_mm_label['text']), model_organism=self.controller.all_common_variables.organism_read_from_experiment_settings, pwm_object=None, time_dependent_stim_file=None, organisms_and_heuristics=organisms_and_heuristics, debug_mode='ON', animal_detection_mode=self.controller.all_common_variables.animal_detection_method_var.get(), display_framerate=playback_speed, simulated_online_analysis=True ) ''' # KEEP - might be implemented in a future version class FixMetadata(tk.Frame): def __init__(self, parent, controller, camera_class=None): tk.Frame.__init__(self, parent) # reference the camera and the controller self.camera_class = camera_class self.cam = self.camera_class.cam self.controller = controller self.entered_text = None self.timestamps = None self.framerate = None # can't use a textvariable as we'll use both strings and numbers here! self.species = None self.genotype = None # Here the frame that will hold all the camera controls is being prepared. self.subframe_preexperiment = tk.LabelFrame(self, text='Fix Metadata') self.subframe_preexperiment.grid(row=0, column=0) # construct the window by calling the SubFrames class with whatever we need. This instance is then bound to the # variable self.sub_frames to make it's variables etc available self.sub_frames = SubFrames(self.camera_class, self.controller, cam_frame=False, subframe_preexperiment=self.subframe_preexperiment, misc_frame=True, observation_mode=False, distance_configuration=False, model_organism=False, update_metadata=True, exp_ctr_frame=False, VR_arena=False, frame=self, quit_frame=False, display_experiment_settings=True, fix_metadata=True, convert_images_frame=False ) ''' class MultiAnimalTracking(tk.Frame): def __init__(self, parent, controller, camera_class=None): tk.Frame.__init__(self, parent) self.controller = controller # if previous_variables bla # get image path self.data_path = None self.framerate = 0 self.colormap_options = ('Greys_r', 'viridis', 'plasma', 'magma', 'afmhot', 'cool') self.colormap_variable = tk.StringVar() self.colormap_variable.set(self.colormap_options[0]) self.subframe_title = tk.Label( self, text='Multi-Animal Tracking', font='Helvetica 12 bold') self.subframe_title.grid(row=0, column=0, columnspan=5) self.pathbutton = tk.Button(self, text='Select data to analyze', command=self.select_images_multi_animal_tracking) self.pathbutton.grid(row=1, column=0, columnspan=2) self.pathchosen = tk.Label(self, text='no data chosen yet') self.pathchosen.grid(row=2, column=0, columnspan=2) self.experiment_date_n_time_frame = tk.LabelFrame(self, text='Experiment Date/Time') self.experiment_date_n_time_frame.grid(row=3, column=0, sticky='nsew') self.experiment_date_n_time_label = tk.Label( self.experiment_date_n_time_frame, text='') self.experiment_date_n_time_label.grid(row=0, column=0) self.framerate_label_frame = tk.LabelFrame(self, text='Framerate') self.framerate_label_frame.grid(row=4, column=0, sticky='nsew') self.framerate_label_label = tk.Label(self.framerate_label_frame, text='') self.framerate_label_label.grid(row=0, column=0) self.recording_time_frame = tk.LabelFrame(self, text='Recorded Time') self.recording_time_frame.grid(row=5, column=0, sticky='nsew') self.recording_time_label = tk.Label(self.recording_time_frame, text='') self.recording_time_label.grid(row=0, column=0) self.resolution_frame = tk.LabelFrame(self, text='Resolution') self.resolution_frame.grid(row=6, column=0, sticky='nsew') self.resolution_label = tk.Label(self.resolution_frame, text='') self.resolution_label.grid(row=0, column=0) self.species_frame = tk.LabelFrame(self, text='Species') self.species_frame.grid(row=3, column=1, sticky='nsew') self.species_label = tk.Label(self.species_frame, text='') self.species_label.grid(row=0, column=0) self.genotype_frame = tk.LabelFrame(self, text='Exp. group') self.genotype_frame.grid(row=4, column=1, sticky='nsew') self.genotype_label = tk.Label(self.genotype_frame, text='') self.genotype_label.grid(row=0, column=0) self.pixel_per_mm_frame = tk.LabelFrame(self, text='Pixel per mm') self.pixel_per_mm_frame.grid(row=6, column=1, sticky='nsew') self.pixel_per_mm_label = tk.Label(self.pixel_per_mm_frame, text='') self.pixel_per_mm_label.grid(row=0, column=0) self.colormap_label = tk.Label(self, text='Select Colormap') self.colormap_label.grid(row=5, column=3) self.colormap_menu = tk.OptionMenu(self, self.colormap_variable, *self.colormap_options) self.colormap_menu.grid(row=5, column=4) self.start_analysis_button = tk.Button(self, text='Press to show \nthe behavior of the animals', command=self.visualize_experiment_func) self.start_analysis_button.grid(row=6, column=3, columnspan=2) self.background_image = None self.experiment_csv = None self.common_str_counted = tk.Label(self, text='') self.common_str_counted.grid(row=5, column=1) # callback every 700 ms self.menu_callback() def menu_callback(self): # call this after every 700ms self.after(700, self.menu_callback) def select_images_multi_animal_tracking(self): if self.data_path is not None: self.data_path = filedialog.askdirectory(initialdir=self.data_path) else: self.data_path = filedialog.askdirectory() os.chdir(self.data_path) self.cam = self.data_path + '/all_images.npy' path_to_show = '...' + self.data_path[<