def clearing_polygon(self, clearing_polygon): """Set the clearing polygon for this configuration. :param clearing_polygon: The polygon for clearing. :type: A list of three or more dicts, each containing number values for keys 'x' and 'y' """ if clearing_polygon is None: self._set('clearing_polygon', clearing_polygon) elif isinstance(clearing_polygon, (list, tuple)): if len(clearing_polygon) < 3: raise ValidationError( "Length of clearing polygon entry must be greater than or equal to 3 (given " "length was %s)." % len(clearing_polygon)) for item in clearing_polygon: if not isinstance(item, dict): raise ValidationError( "Provided point '%s' for clearing polygon entry is a %s instead of a dict." % (item, type(item).__name__)) if len(item) == 2 and all(key in item for key in ('x', 'y')) and \ all(Number.is_finite(num) and Number.is_real_number(num) for num in item.values()): continue else: raise ValidationError( "Provided point %s for clearing polygon is not a length 2 dictionary " "containing real, finite numbers for 'x' and 'y'." % item) self._set('clearing_polygon', clearing_polygon) else: raise ValidationError( "Clearing polygon must be a list, tuple, or None, not a %s." % type(clearing_polygon).__name__)
def planning_robot_radius(self, planning_robot_radius): """Set the robot's estimated radius for planning. :param float planning_robot_radius: The robot radius for planning. :raise: fetchcore.exceptions.ValidationError: Thrown if planning_robot_radius is: - not a finite non-negative number. - None while the planning footprint type is 'radius'. """ if planning_robot_radius is None: if self.planning_footprint_type == FootprintTypes.RADIUS: raise ValidationError( "Planning robot radius cannot be set to None if planning footprint type is %s." % FootprintTypes.RADIUS) self._set('planning_robot_radius', planning_robot_radius) elif Number.is_real_number(planning_robot_radius): if not Number.is_finite_non_negative(planning_robot_radius): raise ValidationError( "Planning robot radius must be a finite non-negative number (was given as %s)." % planning_robot_radius) self._set('planning_robot_radius', planning_robot_radius) else: raise ValidationError( "Planning Robot radius must be a real number (was given as %s)." % planning_robot_radius)
def travel_distance(self, value): if not Number.is_real_number(value): raise ValidationError("Travel distance must be a number (value is %s)" % value) elif not Number.is_finite(value): raise ValidationError("Travel distance must be a finite number (value is %s)" % value) else: self.set_input("travel_distance", value)
def planning_inflation_factor(self, planning_inflation_factor): """Set the factor by which to inflate the robot's radius for planning. :param float planning_inflation_factor: The inflation factor for planning. :raise: fetchcore.exceptions.ValidationError: Thrown if planning_inflation_factor is: - not a finite non-negative number. - None while the planning footprint type is 'radius'. """ if planning_inflation_factor is None: if self.planning_footprint_type == FootprintTypes.RADIUS: raise ValidationError( "Planning robot radius cannot be set to None if planning footprint type is %s." % FootprintTypes.RADIUS) self._set('planning_inflation_factor', planning_inflation_factor) elif Number.is_real_number(planning_inflation_factor): if not Number.is_finite_non_negative(planning_inflation_factor): raise ValidationError( "Planning inflation factor must be a finite positive number (was given as %s)." % planning_inflation_factor) self._set('planning_inflation_factor', planning_inflation_factor) else: raise ValidationError( "Planning inflation factor must be a real number (was given as %s)." % planning_inflation_factor)
def radius(self, value): if Number.is_real_number(value) and (Number.is_finite_positive(value) or value == 0): self._set('radius', value) else: raise ValidationError( "Radius must be a real, finite, positive number, not '%s'" % value)
def _validate_point(self, point): """Validate a point entry. :returns: True if the point is a dictionary with exact keys 'x' and 'y' that are each real, finite numbers. """ return isinstance(point, dict) and {'x', 'y'} == set( point.keys()) and all( Number.is_finite(num) and Number.is_real_number(num) for num in point.values())
def goal_yaw_tolerance(self, value): if not Number.is_real_number(value): raise ValidationError( "Goal yaw tolerance must be a number (value is %s)" % value) elif not Number.is_finite(value): raise ValidationError( "Goal yaw tolerance must be a finite number (value is %s)" % value) else: self.set_input("goal_yaw_tolerance", value)
def hint_position_tolerance(self, value): if not Number.is_real_number(value): raise ValidationError( "Hint position tolerance must be a number (value is %s)" % value) elif not Number.is_finite(value): raise ValidationError( "Hint position tolerance must be a finite number (value is %s)" % value) else: self.set_input("hint_position_tolerance", value)
def distance_ratio(self, distance_ratio): """Sets the distance along the edge where this pose sits (bound between 0 and 1). :param float distance_ratio: The distance ratio. :raise fetchcore.exceptions.ValidationError: Thrown if distance_ratio is not a finite number in between 0 and 1. """ if not Number.is_real_number(distance_ratio): raise ValidationError("Distance ratio must be a number (distance_ratio is %s)" % distance_ratio) elif distance_ratio < 0 or distance_ratio > 1: raise ValidationError("Distance ratio must be between 0 and 1 (distance_ratio is %s)" % distance_ratio) else: self._set("distance_ratio", distance_ratio)
def x(self, value): """Sets the X position of the point within the associated map :param value: A float :raises ValidationError if value is not a number :raises ValidationError if value is not a finite number """ if Number.is_real_number(value): if not Number.is_finite(value): raise ValidationError("X position must be a finite number (value is %s)" % value) self._set("x", value) else: raise ValidationError("X position must be a number (value is %s)" % value)
def y(self, value): """Sets the Y position of the survey node within the associated map. :param value: A float. :raises ValidationError if value is not a number. :raises ValidationError if value is not a finite number. """ if Number.is_real_number(value): if not Number.is_finite(value): raise ValidationError("Y must be a finite number (value is %s)" % value) self._set("y", value) else: raise ValidationError("Y must be a number (value is %s)" % value)
def max_velocity(self, velocity): """Sets the max velocity that robot should go during data survey :param velocity: (float) The max velocity :raises ValidationError if velocity is not a number :raises ValidationError if velocity is not a non-negative finite number """ if velocity and not Number.is_real_number(velocity): raise ValidationError("Max velocity must be a number (value is %s)" % velocity) elif velocity and not Number.is_finite_non_negative(velocity): raise ValidationError("Max velocity must be a finite non-negative number " "(value is %s)" % velocity) else: self.set_input("max_velocity", velocity)
def dock_pose_y(self, y): """Sets the y-coordinate of dock position :param y: (float) Y value :raises ValidationError if y is not a number :raises ValidationError if y is not a finite number """ if not Number.is_real_number(y): raise ValidationError( "Y coordinate must be a number (value is %s)" % y) elif not Number.is_finite(y): raise ValidationError("Y coordinate must be a finite number " "(value is %s)" % y) else: self.set_input("dock_pose_y", y)
def dock_pose_x(self, x): """Sets the x-coordinate of dock position :param x: (float) X value :raises ValidationError if x is not a number :raises ValidationError if x is not a finite number """ if not Number.is_real_number(x): raise ValidationError( "X coordinate must be a number (value is %s)" % x) elif not Number.is_finite(x): raise ValidationError("X coordinate must be a finite number " "(value is %s)" % x) else: self.set_input("dock_pose_x", x)
def x(self, x): """Sets the X position of the lower-left corner of the map (in meters). :param float x: The x position. :raise fetchcore.exceptions.ValidationError: Thrown if x is not a finite number. """ if Number.is_real_number(x): if not Number.is_finite(x): raise exceptions.ValidationError( "X position must be a finite non-negative number (x is %s)" % x) self._set("x", x) else: raise exceptions.ValidationError( "X position must be a number (x is %s)" % x)
def y(self, y): """Sets the Y position of the lower-left corner of the map (in meters). :param float y: The y position. :raise fetchcore.exceptions.ValidationError: Thrown if y is not a finite number. """ if Number.is_real_number(y): if not Number.is_finite(y): raise exceptions.ValidationError( "Y position must be a finite non-negative number (y is %s)" % y) self._set("y", y) else: raise exceptions.ValidationError( "Y position must be a number (y is %s)" % y)
def resolution(self, resolution): """Set the resolution of the map in meters/pixel. :param float resolution: The map resolution. :raise fetchcore.exceptions.ValidationError: Thrown if resolution is not a finite non-negative number. """ if Number.is_real_number(resolution): if not Number.is_finite_non_negative(resolution): raise exceptions.ValidationError( "Resolution must be a finite non-negative number (resolution is %s)" % resolution) self._set("resolution", resolution) else: raise exceptions.ValidationError( "Resolution must be a number (resolution is %s)" % resolution)
def dock_pose_qz(self, qz): """Sets the z component of the dock quaternion :param qz: (float) Z component :raises ValidationError if qz is not a number :raises ValidationError if qz is not a finite number """ if not Number.is_real_number(qz): raise ValidationError( "Quarternion z component must be a number (value is %s)" % qz) elif not Number.is_finite(qz): raise ValidationError( "Quaternion z component must be a finite number " "(value is %s)" % qz) else: self.set_input("dock_pose_qz", qz)
def max_velocity(self, value): """ :param value: A new maximum linear velocity for robots in this system. :raise ValidationError if value is: - Not a number - A negative number """ if not Number.is_real_number(value) or isinstance(value, bool): raise ValidationError( "Max velocity must be a number (max velocity is %s)" % value) elif value < 0.3 or value > 1.5: raise ValidationError( "Max velocity must be between 0.3 and 1.5 (max velocity is %s)" % value) else: self._set("max_velocity", value)
def dock_pose_qx(self, qx): """Sets the x component of the dock quaternion :param qx: (float) X component :raises ValidationError if qx is not a number :raises ValidationError if qx is not a finite number """ if not Number.is_real_number(qx): raise ValidationError( "Quarternion x component must be a number (value is %s)" % qx) elif not Number.is_finite(qx): raise ValidationError( "Quaternion x component must be a finite number " "(value is %s)" % qx) else: self.set_input("dock_pose_qx", qx)
def dock_pose_qy(self, qy): """Sets the y component of the dock quaternion :param qy: (float) Y component :raises ValidationError if qy is not a number :raises ValidationError if qy is not a finite number """ if not Number.is_real_number(qy): raise ValidationError( "Quarternion y component must be a number (value is %s)" % qy) elif not Number.is_finite(qy): raise ValidationError( "Quaternion y component must be a finite number " "(value is %s)" % qy) else: self.set_input("dock_pose_qy", qy)
def dock_pose_qw(self, qw): """Sets the w component of the dock quaternion :param qw: (float) W component :raises ValidationError if qw is not a number :raises ValidationError if qw is not a finite number """ if not Number.is_real_number(qw): raise ValidationError( "Quarternion w component must be a number (value is %s)" % qw) elif not Number.is_finite(qw): raise ValidationError( "Quaternion w component must be a finite number " "(value is %s)" % qw) else: self.set_input("dock_pose_qw", qw)
def value(self, value): """Sets the scaled value in the range [0, 1] associated with the area :param value: A number in between 0 and 1 :raises ValidationError if value is not a number or none :raises ValidationError if value is not greater than or equal to zero and less than or equal to one """ if Number.is_real_number(value) or value is None: if not Number.is_finite_non_negative(value) and value is not None: raise ValidationError( "Value must be in between 0 and 1 (value is %s)" % value) if value > 1.0 and value is not None: raise ValidationError( "Value must be in between 0 and 1 (value is %s)" % value) self._set("value", value) else: raise ValidationError("Value must be a number (value is %s" % value)
def volume(self, volume): """Sets the volume that sound should be played at :param volume: (float) The volume :raises ValidationError if volume is not a number :raises ValidationError if volume is not a non-negative finite number """ if volume and not Number.is_real_number(volume): raise ValidationError("Volume must be a number (value is %s)" % volume) elif volume and not Number.is_finite_non_negative(volume): raise ValidationError( "Volume must be a finite non-negative number " "(value is %s)" % volume) elif not 0 <= volume <= 1: raise ValidationError( "Volume must be between 0 and 1 (value is %s)" % volume) else: self.set_input("volume", volume)
def task_id(self, task_id): """Set the task ID for the task that generated this log. :param int task_id: The ID of the task that generated this log. :raise: fetchcore.exceptions.ValidationError Thrown if the ID is not a finite positive number. """ # Task ID is optional, we can unset it if task_id is None: self._set('task', task_id) elif not Number.is_real_number(task_id): raise ValidationError("Task ID must be a number (value is %s)." % str(task_id)) elif not Number.is_finite_positive(task_id): raise ValidationError( "Task ID must be a finite positive number (value is %s)." % str(task_id)) elif not Number.is_integer(task_id): raise ValidationError("Task ID must be an integer (value is %s)." % str(task_id)) else: self._set('task', task_id)
def laser_clearing_robot_radius(self, laser_clearing_robot_radius): """Set the robot's estimated radius for laser_clearing. :param float laser_clearing_robot_radius: The robot radius for laser_clearing. :raise: fetchcore.exceptions.ValidationError: Thrown if laser_clearing_robot_radius is: - not a finite non-negative number. """ if laser_clearing_robot_radius is None: self._set('laser_clearing_robot_radius', laser_clearing_robot_radius) elif Number.is_real_number(laser_clearing_robot_radius): if not Number.is_finite_non_negative(laser_clearing_robot_radius): raise ValidationError( "Robot radius must be a finite non-negative number (was given as %s)." % laser_clearing_robot_radius) self._set('laser_clearing_robot_radius', laser_clearing_robot_radius) else: raise ValidationError( "Laser clearing robot radius must be a real number (was given as %s)." % laser_clearing_robot_radius)
def laser_clearing_inflation_factor(self, laser_clearing_inflation_factor): """Set the factor by which to inflate the robot's radius for laser_clearing. :param float laser_clearing_inflation_factor: The inflation factor for laser_clearing. :raise: fetchcore.exceptions.ValidationError: Thrown if laser_clearing_inflation_factor is: - not a finite non-negative number. """ if laser_clearing_inflation_factor is None: self._set('laser_clearing_inflation_factor', laser_clearing_inflation_factor) elif Number.is_real_number(laser_clearing_inflation_factor): if not Number.is_finite_non_negative( laser_clearing_inflation_factor): raise ValidationError( "Laser clearing inflation factor must be a finite positive number (was given as %s)." % laser_clearing_inflation_factor) self._set('laser_clearing_inflation_factor', laser_clearing_inflation_factor) else: raise ValidationError( "Laser clearing inflation factor must be a real number (was given as %s)." % laser_clearing_inflation_factor)