def test_validate_pdesc_failed(self):
# test setting of parameter where the automatic conversion fails
# set
test_param = 'focus_distance_m'
test_val = 'foo'
expecting_type = float
param = Parameter(test_param, test_val, expecting_type)
# we know the parameter, this should not raise anything
ParametersStore.get(test_param)
# same as this one
self.assertRaises(ValueError, ParametersStore.set,
param.name, param.value)
self.assertRaises(ValueError, ParametersStore.validate,
param.name, param.value)
self.assertRaises(ValueError, ParametersStore.validate_desc,
param)
# change value to correct one
param.value = 10
try:
ParametersStore.validate_desc(param)
except Exception as err:
self.fail("Exception raised")
def _set_servo_params_status(cls, pstatus):
"""Update status of parameters that are applied to servo"""
for pname in SERVO_PARAMETERS:
pdesc = ParametersStore.get(pname)
pdesc_status = pdesc.status
pdesc_status.set_status(pstatus)
ParametersStore.set_status(pname, pdesc_status)
def _record_timestamp(self):
"""Helper for updating current timestamp in parameters"""
now = datetime.datetime.now()
ParametersStore.set('record_date', now.strftime('%Y-%m-%d'),
notify=False)
ParametersStore.set('record_time', now.strftime('%H:%M:%S'),
notify=False)
def test_set_validate_failed(self):
# test setting of parameter where the automatic conversion fails
# set
test_param = 'focus_distance_m'
test_val = 'foo'
expecting_type = float
# this will raise ValueError obviously
self.assertRaises(ValueError, expecting_type, test_val)
focus_before = ParametersStore.get(test_param)
# same as this one
self.assertRaises(ValueError, ParametersStore.set,
test_param, test_val)
self.assertRaises(ValueError, ParametersStore.validate,
test_param, test_val)
self.assertRaises(KeyError, ParametersStore.validate,
test_param + '=foo', test_val)
self.assertRaises(KeyError, ParametersStore.set,
test_param + '=foo', test_val)
# try to fetch the parameter again to compare that its value
# is unchaged
focus_after = ParametersStore.get(test_param)
self.assertIs(focus_before, focus_after)
def _camera_parameter_changed(self, key, val):
self.logger.debug('camera parameter changed: %s: %s', key, val)
if key not in CAMERA_PARAMETERS:
self.logger.debug('parameter %s is not a camera parameter', key)
return
try:
ParametersStore.set(key, val)
except KeyError:
self.logger.exception('parameter %s = %s not supported', key, val)
def test_set(self):
# test that a parameter can be set
test_param = 'focus_distance_m'
test_val = 10.0
self.assertTrue(ParametersStore.set(test_param, test_val))
focus_set = ParametersStore.get(test_param)
self.assertEqual(focus_set.value, test_val)
def _record_timestamp(self):
"""Helper for updating current timestamp in parameters"""
now = datetime.datetime.now()
ParametersStore.set('record_date',
now.strftime('%Y-%m-%d'),
notify=False)
ParametersStore.set('record_time',
now.strftime('%H:%M:%S'),
notify=False)
def test_load_clear(self):
self.assertEqual(ParametersStore.PARAMETERS, {})
ParametersStore.load_parameters(self.PARAMETERS)
self.assertNotEqual(ParametersStore.PARAMETERS, {})
self.assertIn('foo', ParametersStore.PARAMETERS)
self.assertIn('bar', ParametersStore.PARAMETERS)
ParametersStore.clear_parameters()
self.assertEqual(ParametersStore.PARAMETERS, {})
def test_get_value(self):
for param_in in self.PARAMETERS:
pdesc = ParametersStore.get(param_in.name)
self.assertEqual(param_in.name, pdesc.name)
self.assertEqual(param_in.value, pdesc.value)
self.assertEqual(param_in.value_type, pdesc.value_type)
pvalue = ParametersStore.get_value(param_in.name)
self.assertEqual(pvalue, param_in.value)
self.assertEqual(type(pvalue), param_in.value_type)
def _update_camera_parameters(self, cam):
"""Update camera related parameters"""
self.logger.debug('updating camera parameters')
for param in CAMERA_PARAMETERS:
try:
val = self._get_param(cam, param)
self.logger.debug('current value: %s -> %s', param, val)
ParametersStore.set(param, val)
except dbus.DBusException:
self.logger.exception('failed to obtain parameter %s from camera %s',
param, cam.object_path)
def apply_other_parameter(self, param):
"""Apply parameter directly in parameter store, i.e. skipping any
interaction with external devices.
:param param Parameter:
:rtype: bool
:return: True"""
value = param.value
name = param.name
ParametersStore.set(name, value)
return True
def apply_other_parameter(self, param):
"""Apply parameter directly in parameter store, i.e. skipping any
interaction with external devices.
:param param Parameter:
:rtype: bool
:return: True"""
value = param.value
name = param.name
ParametersStore.set(name, value)
return True
def _update_servo_parameters(self):
"""Update servo parameters after connecting"""
if not self.servo:
return
for param in SERVO_PARAMETERS:
try:
val = self.servo.getValue(param)
ParametersStore.set(param, val)
except dbus.DBusException:
self.logger.exception('failed to update parameter %s from servo',
param)
def _camera_state_changed(self, state):
self.logger.debug('camera status changed: %d -> %d',
self.camera_state, state)
if state == self.CAMERA_STATE_ACTIVE_RECORDING:
record_state = 1
else:
record_state = 0
ParametersStore.set('record_state', record_state)
if (state, self.camera_state) in self.SNAPSHOT_STATES:
# take snapshot
self.service.controller.take_snapshot()
# update current camera state
self.camera_state = state
def test_apply(self):
to_apply = [
Parameter('foo-writable', 'test', str),
Parameter('foo-readonly', 'test2', str)
]
applied = self.ctrl.apply_parameters(to_apply)
# only one parameter was applied
self.assertEqual(len(applied), 1)
app_param = applied[0]
self.assertEqual(app_param.name, 'foo-writable')
self.assertEqual(app_param.value, 'test')
# writable parameter was set
self.assertEqual(ParametersStore.get('foo-writable').value, 'test')
# readonly remains unchanged
self.assertEqual(ParametersStore.get('foo-readonly').value, 'baz')
def test_called(self):
# verify that a callback was called only once for each set
tmock = mock.Mock()
test_param = 'focus_distance_m'
test_value = 10.0
# register mock callback a couple of times, only one
# registration is used
ParametersStore.change_listeners.add(tmock)
ParametersStore.change_listeners.add(tmock)
ParametersStore.change_listeners.add(tmock)
# set a parameter
ParametersStore.set(test_param, test_value)
# has to be called
self.assertTrue(tmock.called)
# called only once
self.assertEquals(tmock.call_count, 1)
self.assertEquals(len(tmock.call_args), 2)
# grab the first list parameter
pdesc = tmock.call_args[0][0]
self.assertIsInstance(pdesc, Parameter)
self.assertEquals(pdesc.name, test_param)
self.assertEquals(pdesc.value, test_value)
# set once again
ParametersStore.set(test_param, test_value + 1)
self.assertEquals(tmock.call_count, 2)
# grab the first list parameter
pdesc = tmock.call_args[0][0]
self.assertEquals(pdesc.value, test_value + 1)
# remove callback
ParametersStore.change_listeners.remove(tmock)
# and again, should not fail
ParametersStore.change_listeners.remove(tmock)
# now something different
ParametersStore.change_listeners.remove(None)
def test_set_convert(self):
# test that parameter can be set, and the value is
# automatically converted to proper type
test_param = 'focus_distance_m'
test_val = 10
expecting_type = float
# test value is an int
self.assertIsInstance(test_val, int)
# first read it
param = ParametersStore.get(test_param)
self.assertEqual(param.value_type, expecting_type)
self.assertIsInstance(param.value, expecting_type)
# set
ParametersStore.set(test_param, test_val)
as_set = ParametersStore.get(test_param)
# the type should have been converted according to parameter
# description
self.assertIsInstance(as_set.value, expecting_type)
self.assertEqual(as_set.value, expecting_type(test_val))
def test_get_existing(self):
from ros3ddevcontroller.param.sysparams import SYSTEM_PARAMETERS
for param in SYSTEM_PARAMETERS:
name = param.name
value = param.value
try:
from_store = ParametersStore.get(param.name)
except KeyError:
self.fail('Expecting key in the set')
self.assertEqual(name, from_store.name)
self.assertEqual(value, from_store.value)
self.assertEqual(param.value_type, from_store.value_type)
def test_set_value(self):
self.assertNotEqual(ParametersStore.DEPENDENCIES, {})
pdesc_bar = ParametersStore.get('bar')
ParametersStore.set('foo', 3)
bar_val = ParametersStore.get_value('bar')
# bar = foo + 1
self.assertEqual(bar_val, 4)
baz_val = ParametersStore.get_value('baz')
# baz = foo * bar + 1
self.assertEqual(baz_val, 13)
# cafe = baz ** 2 + bar
cafe_val = ParametersStore.get_value('cafe')
self.assertEqual(cafe_val, 173)
def apply_parameters(self, params):
"""Apply a parameter set
:param params list of ParamDesc: list of parameters to apply
:rtype: list(Parameter)
:return: list of parameters applied"""
# record changed parameter descriptors
changed_params = []
# apply parameters serially, note that if any parameter takes
# longer to aplly this will contribute to wait time of the
# whole request
for param in params:
applied = self.apply_single_parameter(param)
# param validation was successful and was applied to servo
if applied:
par = ParametersStore.get(param.name)
changed_params.append(par)
return changed_params
def apply_parameters(self, params):
"""Apply a parameter set
:param params list of ParamDesc: list of parameters to apply
:rtype: list(Parameter)
:return: list of parameters applied"""
# record changed parameter descriptors
changed_params = []
# apply parameters serially, note that if any parameter takes
# longer to aplly this will contribute to wait time of the
# whole request
for param in params:
applied = self.apply_single_parameter(param)
# param validation was successful and was applied to servo
if applied:
par = ParametersStore.get(param.name)
changed_params.append(par)
return changed_params
def is_servo_parameter(cls, param):
"""Return true if parameter is applicable to servo"""
return ParametersStore.is_servo_parameter(param.name)
def is_parameter_writable(cls, param):
"""Return True if parameter is applicable to camera"""
return ParametersStore.is_read_only(param.name) == False
def tearDown(self):
ParametersStore.clear_parameters()
def is_camera_parameter(cls, param):
"""Return True if parameter is applicable to camera"""
return ParametersStore.is_camera_parameter(param.name)
def get_parameters(self):
"""Return a dict with all parameters in the system"""
return ParametersStore.parameters_as_dict()
def setUp(self):
ParametersStore.load_parameters(self.PARAMETERS)
def _servo_value_changed(self, parameter, motor, limit, in_progress, value):
"""pl.ros3d.servo.valueChanged signal handler"""
self.logger.debug('got signal for parameter %s, value: %d', parameter, value)
value = Infinity.convert_from(value)
ParametersStore.set(parameter, value)
self.logger.debug('parameter value updated')
def setUp(self):
ParametersStore.load_parameters([
ReadOnlyParameter('foo-readonly', 'bar', str),
Parameter('foo-writable', 'bar', str)
])
def test_camera(self):
for p in self.camera_parameters:
self.assertTrue(ParametersStore.is_camera_parameter(p))
for p in self.servo_parameters:
self.assertFalse(ParametersStore.is_camera_parameter(p))
def get_parameters(self):
"""Return a dict with all parameters in the system"""
return ParametersStore.parameters_as_dict()
def setUp(self):
ParametersStore.clear_parameters()
def is_servo_parameter(cls, param):
"""Return true if parameter is applicable to servo"""
return ParametersStore.is_servo_parameter(param.name)
def _set_camera_status(self, pstatus):
for pname in CAMERA_PARAMETERS:
pdesc = ParametersStore.get(pname)
pdesc_status = pdesc.status
pdesc_status.set_status(pstatus)
ParametersStore.set_status(pname, pdesc_status)
def setUp(self):
ParametersStore.load_parameters(self.PARAMETERS)
for param in self.PARAMETERS:
self.PARAMETERS_DICT[param.name] = param
self.ctrl = Controller()
def is_camera_parameter(cls, param):
"""Return True if parameter is applicable to camera"""
return ParametersStore.is_camera_parameter(param.name)
def test_parameter_readonly(self):
self.assertTrue(ParametersStore.is_read_only('foo-readonly'))
self.assertFalse(ParametersStore.is_read_only('foo-writable'))
def test_focal_length_changed(self):
#Set initial values
ParametersStore.set('focal_length_mm', 25, evaluate=False)
ParametersStore.set('baseline_mm', 50.0, evaluate=False)
ParametersStore.set('frame_width_mm', 15.84, evaluate=False)
ParametersStore.set('frame_height_mm', 8.91, evaluate=False)
ParametersStore.set('distance_screen_m', 3.15, evaluate=False)
ParametersStore.set('distance_near_m', 1.04, evaluate=False)
#Change focal_length to check evaluation
ParametersStore.set('focal_length_mm', 20, evaluate=True)
#Check new values
parallax_near_percent = ParametersStore.get_value(
'parallax_near_percent')
self.assertEquals(round(parallax_near_percent, 2), -4.07)
real_width_near_m = ParametersStore.get_value('real_width_near_m')
self.assertEquals(round(real_width_near_m, 2), 0.82)
real_height_near_m = ParametersStore.get_value('real_height_near_m')
self.assertEquals(round(real_height_near_m, 2), 0.46)
