def _process(self, im, image_scale: Param(0.5, (0.05, 1.0)),
filter_size: Param(2, (0, 15)), color_invert: Param(True),
clip: Param(140, (0, 255)), **extraparams):
"""Optionally resizes, smooths and inverts the image
:param im:
:param state:
:param filter_size:
:param image_scale:
:param color_invert:
:return:
"""
if image_scale != 1:
im = cv2.resize(im,
None,
fx=image_scale,
fy=image_scale,
interpolation=cv2.INTER_AREA)
if filter_size > 0:
im = cv2.boxFilter(im, -1, (filter_size, filter_size))
if color_invert:
im = 255 - im
if clip > 0:
im = np.maximum(im, clip) - clip
if self.set_diagnostic == "filtered":
self.diagnostic_image = im
return NodeOutput([], im)
def __init__(self, **kwargs):
super().__init__(name="video_params", **kwargs)
self.framerate = Param(
100.0, limits=(10, 700), unit="Hz", desc="Framerate (Hz)"
)
self.offset = Param(50)
self.paused = Param(False)
def __init__(self):
super().__init__()
# Here we define these attributes as Param s. This will automatically
# build a control for them and make them modifiable live from the
# interface.
self.period_sec = Param(10.0, limits=(0.2, None))
self.flash_duration = Param(1.0, limits=(0.0, None))
def __init__(self, *args, **kwargs):
super().__init__(*args, name="general/animal", **kwargs)
self.species = Param("")
self.age = Param("")
self.id = Param("0")
self.comments = Param("", desc="Comments on the animal or experiment")
self.genotype = Param("WT")
def __init__(self):
super().__init__()
self.n_trials = Param(120, (0, 2400))
self.stim_on_duration = Param(10, (0, 30))
self.stim_off_duration = Param(10, (0, 30))
self.center_offset = Param(0, (-100, 100))
self.brightness = Param(255, (0, 255))
def __init__(self):
super().__init__()
self.inter_stim_pause = Param(20.0)
self.grating_vel = Param(10.0)
self.grating_duration = Param(10.0)
self.grating_cycle = Param(10.0)
def setup(self, tree=None):
""" Due to multiprocessing limitations, the setup is
run separately from the constructor
"""
diag_images = []
for node in PreOrderIter(self.root):
node.setup()
if node._params is not None:
self.all_params[node.strpath] = node._params
if tree is not None:
tree.add(node._params)
self.node_dict[node.strpath] = node
diag_images.extend((node.strpath + "/" + imname
for imname in node.diagnostic_image_options))
self.all_params["diagnostics"] = Parametrized(
name="tracking/diagnostics",
params=dict(image=Param("unprocessed", ["unprocessed"] +
diag_images)),
tree=tree,
)
self.all_params["reset"] = Parametrized(
name="tracking/reset",
params=dict(reset=Param(False, gui="button")),
tree=tree,
)
def __init__(self):
super().__init__()
self.name = "scanning/planar_scanning"
self.lateral_range = Param((0, 0.5), (-2, 2))
self.lateral_frequency = Param(500.0, (10, 1000), unit="Hz")
self.frontal_range = Param((0, 0.5), (-2, 2))
self.frontal_frequency = Param(500.0, (10, 1000), unit="Hz")
def __init__(self):
super().__init__()
self.inter_stim_pause = Param(10)
self.grating_vel = Param(10.0)
self.grating_duration = Param(30)
self.grating_cycle = Param(10)
self.target_vel = Param(-15.0, limits=(-50, 20))
def __init__(self):
super().__init__()
self.t_pre = Param(5.) # time of still gratings before they move
self.t_move = Param(5.) # time of gratings movement
self.grating_vel = Param(-10.) # gratings velocity
self.grating_period = Param(10) # grating spatial period
self.grating_angle_deg = Param(90.) # grating orientation
def __init__(self):
super().__init__()
self.name = "experiment_settings"
self.save_dir = Param(conf["default_paths"]["data"], gui=False)
self.notification_email = Param("")
self.overwrite_save_folder = Param(0, (0, 1),
gui=False,
loadable=False)
def __init__(self):
super().__init__(self)
self.name = "scanning/volumetric_recording"
self.piezo_scan_range = Param((180.0, 220.0), (0.0, 400.0), unit="um")
self.frequency = Param(3.0, (0.1, 100), unit="volumes/s (Hz)")
self.n_planes = Param(4, (2, 100))
self.n_skip_start = Param(0, (0, 20))
self.n_skip_end = Param(0, (0, 20))
def __init__(self, **kwargs):
super().__init__(name="a/gino", **kwargs)
self.random = 5
self.a = Param(1)
self.b = Param(2.0)
self.c = Param(5)
self.a_list = Param("a", ["a", "b", "c"])
self.sig_param_changed.connect(self.update_param)
def detect(
self,
im,
tail_start: Param((0, 0), gui=False),
n_segments: Param(7),
tail_length: Param((1, 1), gui=False),
**extraparams
):
"""Tail tracing based on min (or max) detection on arches. Wraps
_tail_trace_core_ls. Speed testing: 20 us for a 514x640 image without
smoothing, 300 us with smoothing.
Parameters
----------
img :
input image
tail_start :
tail starting point (x, y) (Default value = (0)
tail_length :
tail length (Default value = (1)
n_segments :
number of segments (Default value = 7)
dark_tail :
True for inverting image colors (Default value = False)
im :
0) :
1) :
image_scale :
(Default value = 1)
Returns
-------
"""
start_y, start_x = tail_start
tail_length_y, tail_length_x = tail_length
scale = im.shape[0]
# Calculate tail length:
length_tail = np.sqrt(tail_length_x**2 + tail_length_y**2) * scale
# Initial displacements in x and y:
disp_x = tail_length_x * scale / n_segments
disp_y = tail_length_y * scale / n_segments
start_x *= scale
start_y *= scale
# Use jitted function for the actual calculation:
angle_list = _tail_trace_core_ls(
im, start_x, start_y, disp_x, disp_y, n_segments, length_tail
)
return angle_list
def __init__(self):
super().__init__()
self.name = "recording"
self.n_planes = Param(1, (1, 500))
self.dz = Param(1.0, (0.1, 20.0), unit="um")
self.save_dir = Param(r"C:\Users\portugueslab\Desktop\test\python",
gui=False)
self.notification_email = Param("None")
self.notify_every_n_planes = Param(3, (1, 1000))
def __init__(self):
super().__init__()
self.name = "camera/parameters"
self.exposure_time = Param(conf["camera"]["default_exposure"],
(1, 1000),
unit="ms")
self.binning = Param(conf["camera"]["default_binning"], [1, 2, 4])
self.roi = Param(
roi_size, gui=False
) # order of params here is [hpos, vpos, hsize, vsize,]; h: horizontal, v: vertical
def __init__(self,
acc: QueueDataAccumulator,
i_fish=0,
n_bouts=10,
n_save_max=300):
super().__init__()
self.title = "Bout shape"
self.acc = acc
self.bouts = deque()
self.i_fish = i_fish
self.processed_index = 0
self.detection_params = Parametrized(params=dict(
threshold=Param(0.2, (0.01, 5.0)),
n_without_crossing=Param(5, (0, 10)),
pad_before=Param(5, (0, 20)),
pad_after=Param(5, (0, 20)),
min_bout_len=Param(1, (1, 30)),
))
self.n_bouts = n_bouts
self.old_coords = None
self.i_curve = 0
self.n_save_max = n_save_max
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.btn_editparam = QPushButton("Detection parameters")
self.btn_editparam.clicked.connect(self.edit_params)
self.layout().addWidget(self.btn_editparam)
self.wnd_params = None
self.vmax = 0
self.lbl_vmax = QLabel()
self.layout().addWidget(self.lbl_vmax)
self.display_widget = pg.GraphicsLayoutWidget()
self.layout().addWidget(self.display_widget)
self.vb_display = pg.ViewBox()
self.vb_display.setAspectLocked(True, 1)
self.vb_display.setRange(xRange=[-1, 5], disableAutoRange=True)
self.vb_display.invertY(True)
self.display_widget.addItem(self.vb_display)
self.bout_curves = [
pg.PlotCurveItem(connect="finite") for _ in range(self.n_bouts)
]
self.colors = np.zeros(self.n_bouts)
self.decay_constant = 0.99
self.bout_coords = None
self.bout_state = BoutState(0, 0.0, 0, 0, 0)
for c in self.bout_curves:
self.vb_display.addItem(c)
def __init__(self, **kwargs):
super().__init__(name="camera_params", **kwargs)
self.exposure = Param(1.,
limits=(0.1, 50),
unit="ms",
desc="Exposure (ms)")
self.framerate = Param(150.,
limits=(10, 700),
unit=" Hz",
desc="Framerate (Hz)")
self.gain = Param(1.,
limits=(0.1, 12),
desc="Camera amplification gain")
self.ring_buffer_length = Param(
300, (1, 2000),
desc="Rolling buffer that saves the last items",
gui=False)
self.paused = Param(False)
self.replay = Param(True, desc="Replaying", gui=False)
self.replay_fps = Param(
15,
(0, 500),
desc=
"If bigger than 0, the rolling buffer will be replayed at the given framerate",
)
self.replay_limits = Param((0, 600), gui=False)
def __init__(self, **kwargs):
# We will define all metadata as Parameters.
super().__init__(**kwargs)
# String parameter. Setting the loadable flag to false prevent this
# parameter to be restored frin the stytra_last_config file, and the
# editable to false to make it not changable in the interface:
self.species = Param("Kraken kraken", loadable=False, editable=False)
# String parameter with a default and a description.
# The description appears hovering with mouse.
self.location = Param("North Atlantic",
desc="Approximate location of the sightening")
# Drop down menu, for multiple choices:
self.diet = Param("Humans", ["Humans", "Ships", "Unknown"])
# Redefine age with units:
self.age = Param(500, limits=(1, 10000), unit="years")
# A simple integer, with limits:
self.n_tentacles = Param(8, limits=(1, 200))
# An integer with inferior boundary only (no upper limit for the terror):
self.n_casualties = Param(8, limits=(1, None))
# A simple float, with limits and measure units:
self.dimensions = Param(8.0, limits=(0.5, 100), unit="m")
# Some parameters are already defined in the AnimalMetadata class
# (species, genotype, comments, id). Here we overwrite them:
self.id = Param("")
def _process(self, im, learning_rate: Param(0.04, (0.0, 1.0)),
learn_every: Param(400, (1, 10000))):
messages = []
if self.background_image is None:
self.background_image = im.astype(np.float32)
messages.append("I:New backgorund image set")
elif self.i == 0:
self.background_image[:, :] = im.astype(np.float32) * np.float32(
learning_rate) + self.background_image * np.float32(
1 - learning_rate)
self.i = (self.i + 1) % learn_every
return NodeOutput(messages, negdif(self.background_image, im))
def __init__(self):
super().__init__()
self.name = "scanning"
self.aspect_ratio = Param(1.0, (0.2, 5.0))
self.voltage = Param(3.0, (0.2, 4.0))
self.framerate = Param(2.0, (0.1, 10.0))
self.reset_shutter = Param(False)
self.binning = Param(10, (1, 50))
self.output_rate_khz = Param(400, (50, 2000))
self.laser_power = Param(10.0, (0, 100))
self.n_turn = Param(10, (0, 100))
self.n_extra_init = Param(100, (0, 100))
def __init__(self):
super().__init__()
self.name = "general/scanning_state"
self.scanning_state = Param(
"Paused",
["Paused", "Calibration", "Planar", "Volume"],
)
def grow_rois(
stack,
corr_map,
init_corr_thresh: Param(0.15, (0.01, 0.95)) = 0.15,
corr_thresh_inc_dist: Param(1.0, (0.5, 15)) = 1,
final_corr_threshold: Param(0.0, (0, 0.95)) = 0,
max_radius: Param(10, (2, 100)) = 10,
min_area: Param(1, (1, 50)) = 1,
max_labels: Param(100, (10, 20000)) = 100,
max_investigate: Param(2000, (100, 30000)) = 2000,
across_planes: Param(True) = True,
voxel_size=(1, 1, 1),
) -> np.ndarray:
"""Find ROIs by taking local maxima of correlation maps and growing ROIs
around them
:param corr_map: input correlation map
:param init_corr_thresh: the threshold of correlation that gets added to
the roi, grows linearly until corr_thresh_inc_dist
:param corr_thresh_inc_dist: the distance until which the correlation
threshold increases, in voxels if voxel_size is not specified, otherwise
in um
:param final_corr_threshold: the correlation threshold reached over
corr_threshold_steps
:param max_radius: the maximum radius of a ROIs, so that they are
roughly circular
:param min_area: the minimum area of a ROI
:param max_labels: the maximal number of ROIs to search for
(if not across planes, in one plane)
:param max_investigate: the maximum number of potential ROIs to investigate
per slice or volume part (as small ROIs are discarded)
:param across_planes: True to grow ROIs across planes
:param voxel_size: (optional, size of voxels in mm)
:return: stack ROIs labeled
"""
# if we get the video or the correlation map of the wrong shape,
# expand it so that the algorithm still works
stack = to_4d(stack)
corr_map = to_3d(corr_map)
return _jit_flood(
stack,
corr_map,
init_corr_thresh,
max_labels,
final_corr_threshold,
max_radius,
corr_thresh_inc_dist,
max_investigate,
min_area,
across_planes,
voxel_size,
)
def _process(self, input, a: Param(1), set_diagnostic=None):
if self._output_type is None:
self._output_type = namedtuple("o", "inp par")
else:
self._output_type_changed = False
if self.set_diagnostic:
self.diagnostic_image = "img"
return NodeOutput([], self._output_type(par=a, inp=input))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.an_int = Param(1)
self.a_float = Param(1.0, (-1.0, 10.0))
self.a_str = Param("strstr")
self.a_folder = Param("", gui="folder")
self.a_list = Param("a", ["a", "b", "c"], editable=False)
self.a_bool = Param(False, editable=False)
self.a_range = Param((0.5, 1.5), (0.0, 2.0))
self.a_different_bool = Param(True, gui=False)
def _process(self, im, wnd_pos: Param((129, 20), gui=False),
threshold: Param(56, limits=(1, 254)), wnd_dim: Param(
(14, 22), gui=False), **extraparams):
"""
Parameters
----------
im :
image (numpy array);
win_pos :
position of the window on the eyes (x, y);
win_dim :
dimension of the window on the eyes (w, h);
threshold :
threshold for ellipse fitting (int).
Returns
-------
"""
message = ""
PAD = 0
cropped = _pad(
(im[wnd_pos[1]:wnd_pos[1] + wnd_dim[1], wnd_pos[0]:wnd_pos[0] +
wnd_dim[0], ] < threshold).view(dtype=np.uint8).copy(),
padding=PAD,
val=255,
)
# try:
e = _fit_ellipse(cropped)
if self.set_diagnostic == "thresholded":
self.diagnostic_image = (im < threshold).view(dtype=np.uint8)
if e is False:
e = (np.nan, ) * 10
message = "E: eyes not detected!"
else:
e = (e[0][0][::-1] + e[0][1][::-1] + (-e[0][2], ) + e[1][0][::-1] +
e[1][1][::-1] + (-e[1][2], ))
return NodeOutput([
message,
], self._output_type(*e))
def __init__(self):
super().__init__()
self.inter_stim_pause = Param(10.0)
self.theta_amp = Param(np.pi / 2)
self.windmill_freq = Param(0.2)
self.stim_duration = Param(20.0)
self.wave_shape = Param(value="sinusoidal", limits=["square", "sinusoidal"])
self.n_arms_min = Param(10)
self.n_arms_max = Param(60)
self.n_arms_steps = Param(5)
def __init__(self):
super().__init__()
# It is convenient for a protocol to be parametrized, so
# we name the parameters we might want to change,
# along with specifying the the default values.
# This automatically creates a GUI to change them
# (more elaborate ways of adding parameters are supported,
# see the documentation of lightparam)
# if you are not interested in parametrizing your
# protocol the the whole __init__ definition
# can be skipped
self.n_looms = Param(10, limits=(0, 1000))
self.max_loom_size = Param(60, limits=(0, 100))
self.max_loom_duration = Param(5, limits=(0, 100))
self.x_pos_pix = Param(10, limits=(0, 2000))
self.y_pos_pix = Param(10, limits=(0, 2000))
def __init__(self):
super().__init__()
self.inter_stim_pause = Param(20.0)
self.grating_vel = Param(10.0)
self.grating_duration = Param(10.0)
self.grating_cycle = Param(10)
self.low_gain = Param(0.5)
self.high_gain = Param(1.5)
self.protocol_reps = Param(6)
def __init__(self):
super().__init__()
self.velocity = Param(5.5, (0, 40))
self.max_coherent_for = Param(0.4, (0, 10))
self.dot_density = Param(0.113, (0.01, 1.0))
self.stimulus_duration = Param(20, (1, 100))
self.theta = Param(90, (-180, 180))
self.dot_radius = Param(0.6, (0, 1))
