def visible(self, value):
_u.validate_attr_type(self, "visible", value, bool)
if value:
self.show()
else:
self.hide()
self._log_property_changed(self, "visible")
def _set_property(self, prop_name, value, prop_type, allow_single_value=True, allow_none=True):
multiple_values = False
#convert CSV input string to expyriment colour object
if prop_type == 'RGB' and type(value[0])== str:
temp = ()
for i in value:
temp = temp + (int(i),)
newValue = Colour(temp)
value = newValue
if value is None and not allow_none:
raise ttrk.TypeError("{:}.{:} cannot be set to None".format(_u.get_type_name(self), prop_name))
if value is not None:
multiple_values = self._is_multiple_values(value, prop_type)
if multiple_values and (prop_type != 'RGB'):
for v in value:
_u.validate_attr_type(self, prop_name, v, prop_type)
value = list(value)
elif allow_single_value:
_u.validate_attr_type(self, prop_name, value, prop_type, none_allowed=True)
else:
raise ttrk.TypeError("{:}.{:} must be set to a list of values; a single {:} is invalid".format(
_u.get_type_name(self), prop_name, prop_type.__name__ if isinstance(prop_type, type) else prop_type))
setattr(self, "_" + prop_name, value)
setattr(self, "_" + prop_name + "_multiple", multiple_values)
def visible(self, visible):
_u.validate_attr_type(self, "visible", visible, bool)
self._visible = visible
self._gauge_stimulus.visible = visible and (self._current_value
is not None)
self._stimulus.visible = visible
self._log_property_changed("visible")
def trial_configured_event(self, event):
_u.validate_attr_type(self, "registration_event", event, Event)
if self._event_manager is not None:
raise ttrk.InvalidStateError(("{:}.trial_configured_event cannot be changed after " +
"registering to the event manager".format(_u.get_type_name(self))))
self._trial_configured_event = event
self._log_property_changed("trial_configured_event")
def start_zoom_event(self, value):
_u.validate_attr_type(self,
"start_zoom_event",
value,
ttrk.events.Event,
none_allowed=True)
self._start_zoom_event = value
self._log_property_changed(self, "start_zoom_event")
def can_exit_in_any_direction(self, value):
if self._preloaded:
raise ttrk.InvalidStateError(
"{:}.can_exit_in_any_direction cannot be set after the object was preloaded"
.format(_u.get_type_name(self)))
_u.validate_attr_type(self, "can_exit_in_any_direction", value, bool)
self._can_exit_in_any_direction = value
self._log_property_changed("can_exit_in_any_direction")
def axis(self, value):
_u.validate_attr_type(self, "axis", value, ValidationAxis)
if value == ValidationAxis.xy:
raise ValueError(
_u.ErrMsg.attr_invalid_value(self.__class__, "axis", value))
self._axis = value
self._log_setter("axis")
def axis(self, value):
_u.validate_attr_type(self, "axis", value, ValidationAxis)
if value == ValidationAxis.xy:
raise trajtracker.ValueError(
_u.ErrMsg.attr_invalid_value(self.__class__, "axis", value))
self._axis = value
self._log_property_changed("axis")
def default_value(self, value):
_u.validate_attr_type(self,
"default_value",
value,
Number,
none_allowed=True)
self._default_value = value
self._log_property_changed("default_value")
def guide_line_length(self, value):
_u.validate_attr_type(self,
"guide_line_length",
value,
numbers.Number,
none_allowed=True)
if value is not None:
_u.validate_attr_positive(self, "guide_line_length", value)
self._guide_line_length = value
self._guide = GlobalSpeedGuide(self)
def enable_events(self, value):
value = _u.validate_attr_is_collection(self,
"enable_events",
value,
none_allowed=True)
for v in value:
_u.validate_attr_type(self, "enable_events", v, Event)
if self._registered:
raise trajtracker.InvalidStateError(
"{:}.enable_events cannot be set after the object was registered to the event manager"
.format(_u.get_type_name(self)))
self._enable_events = tuple(value)
self._log_property_changed("enable_events")
def _get_colors_as_ints(self, value, attr_name):
if u.is_rgb(value):
value = (value, )
_u.validate_attr_type(self, attr_name, value, (list, tuple, set))
colors = set()
for c in value:
if not u.is_rgb(c):
raise ValueError(
_u.ErrMsg.attr_invalid_type(type(self), attr_name, "color",
value))
colors.add(u.color_rgb_to_num(c))
return colors
def position(self, value):
if value is None:
value = (0, 0)
_u.validate_attr_anylist(self, "position", value, 2, 2)
_u.validate_attr_type(self, "position[0]", value[0], numbers.Number)
_u.validate_attr_type(self, "position[1]", value[1], numbers.Number)
self._position = (value[0], value[1])
self._log_setter("position")
#-- Find top-left coordinates. The rounding is done in the same way as Expyriment does.
self._top_left_x = value[0] - int(np.floor((self._width - 1) / 2))
self._top_left_y = value[1] - int(np.floor((self._height - 1) / 2))
def single_color(self, value):
_u.validate_attr_type(self,
"single_color",
value,
str,
none_allowed=True)
if value is not None and value not in self._colormaps:
raise trajtracker.ValueError(
"invalid value for {:}.single_color ({:}) - valid values are {:}"
.format(_u.get_type_name(self), value,
",".join(self._colormaps.keys())))
self._single_color = value
self._lcm.colormap = u.color_rgb_to_num if value is None else self._colormaps[
value]
self._calc_min_max_colors()
self._log_property_changed("single_color")
def available_stimuli(self, value):
_u.validate_attr_type(self,
"available_stim",
value,
dict,
none_allowed=True)
value = {} if value is None else dict(value) # fix/copy
for stim_id, stim in value.items():
_u.validate_attr_type(self, "available_stim(key)", stim_id, str)
if "is_preloaded" not in dir(stim) or "present" not in dir(stim):
raise ttrk.TypeError(
"Invalid stimulus in {:}.add_stimulus() - {:}".format(
_u.get_type_name(self), stim))
if not stim.is_preloaded:
stim.preload()
self._container.add(stim, stim_id, visible=False)
self._available_stimuli = value
def slidable_range(self, value):
_u.validate_attr_is_collection(self,
"slide_coord_range",
value,
min_length=2,
max_length=2,
none_allowed=True)
if value is None:
self._slidable_range = None
else:
for i in range(2):
_u.validate_attr_type(self, "slide_coord_range[%d]" % i,
value[i], Number)
#-- Make sure that first value is the smaller one
if value[0] > value[1]:
value = value[1], value[0]
self._slidable_range = tuple(value)
self._log_property_changed("slide_coord_range")
def degrees_per_sec(self, value):
_u.validate_attr_type(self, "degrees_per_sec", value, numbers.Number)
_u.validate_attr_positive(self, "degrees_per_sec", value)
self._degrees_per_sec = value % 360
def radius(self, value):
_u.validate_attr_type(self, "radius", value, numbers.Number)
_u.validate_attr_positive(self, "radius", value)
self._radius = value
def position(self, value):
_u.validate_attr_type(self, "position", value, ttrk.TYPE_COORD)
self.x = value[0]
self.y = value[1]
def track_if_no_movement(self, value):
_u.validate_attr_type(self, "track_if_no_movement", value, bool)
self._track_if_no_movement = value
self._log_property_changed("track_if_no_movement")
def rgb_should_ascend(self, value):
_u.validate_attr_type(self, "rgb_should_ascend", value, bool)
self._rgb_should_ascend = value
self._log_setter("rgb_should_ascend")
def use_mapping(self, value):
_u.validate_attr_type(self, "use_mapping", value, bool)
self._use_mapping = value
self._log_setter("use_mapping")
def calculation_interval(self, value):
_u.validate_attr_type(self, "calculation_interval", value,
numbers.Number)
_u.validate_attr_not_negative(self, "calculation_interval", value)
self._calculation_interval = value
self._log_setter("calculation_interval")
def units_per_mm(self, value):
_u.validate_attr_type(self, "units_per_mm", value, numbers.Number)
_u.validate_attr_positive(self, "units_per_mm", value)
self._units_per_mm = value
self._log_setter("units_per_mm")
def cyclic(self, value):
_u.validate_attr_type(self, "interpolate", value, bool)
self._cyclic = value
self._validation_err = None
def interpolate(self, value):
_u.validate_attr_type(self, "interpolate", value, bool)
self._interpolate = value
def tracking_active(self, value):
_u.validate_attr_type(self, "tracking_active", value, bool)
self._tracking_active = value
self._log_setter("tracking_active")
def full_rotation_duration(self, value):
_u.validate_attr_type(self, "degrees_per_sec", value, numbers.Number)
_u.validate_attr_positive(self, "degrees_per_sec", value)
self._degrees_per_sec = (360 / value) % 360
def default_valid(self, value):
_u.validate_attr_type(self, "default_valid", value, bool)
self._default_valid = value
self._log_property_changed("default_valid")
def line_width(self, value):
_u.validate_attr_type(self, "line_width", value, int)
self._line_width = value
self._create_guide_line()
self._log_property_changed("line_width")
