def news(self, news):
if isinstance(news, list):
for index, item in enumerate(news):
if not isinstance(item, Body):
raise type_error("index {} of news".format(index), Body, type(item))
self.__news = news
else:
raise type_error("obstacles", list, type(news))
def collidable(self, collidable):
if isinstance(collidable, list):
for index, item in enumerate(collidable):
if not isinstance(item, Body):
raise type_error(
"index {} of collidable".format(index), Body, type(item)
)
self.__collidable = collidable
else:
raise type_error("collidable", list, type(collidable))
def obstacles(self, obstacles):
if isinstance(obstacles, list):
for index, item in enumerate(obstacles):
if not isinstance(item, Body):
raise type_error(
"index {} of obstacles".format(index), Body, type(item)
)
self.__obstacles = obstacles
else:
raise type_error("obstacles", list, type(obstacles))
def movable(self, movable):
if isinstance(movable, list):
for index, item in enumerate(movable):
if not isinstance(item, Body):
raise type_error(
"index {} of movable".format(index), Body, type(item)
)
self.__movable = movable
else:
raise type_error("movable", list, type(movable))
def init_color(self, color):
if isinstance(color, list):
for index, item in enumerate(color):
if not isinstance(item, float):
raise type_error(
"index {} of init color".format(index), float, type(item)
)
if item > 1.0 or item < 0.0:
raise value_error("index {} of init color", "0 >= x >= 1", item)
self.__init_color = color
else:
raise type_error("init color", list, type(color))
def constraints(self, constraints):
"""Setter for the constraints property."""
if not isinstance(constraints, list):
raise type_error("constraints", list, type(constraints))
for index, item in enumerate(constraints):
if not isinstance(item, Constraint):
raise type_error(
"index {} of constraints".format(index), Constraint, type(item)
)
self.__constraints = constraints
def z_off(self, z_off):
"""Setter for the z_off property."""
if not isinstance(z_off, float):
raise type_error("z_off", float, type(z_off))
self.__z_off = z_off
def pose(self, pose):
if isinstance(pose, list):
for index, item in enumerate(pose):
if not isinstance(item, float):
raise type_error(
"index {} of pose".format(index), float, type(item)
)
if not len(pose) == 3:
raise length_error("pose", 3, len(pose))
pose = self._get_constrained_pose(pose)
self.__pose = pose
pos = [pose[0], pose[1], self.z_off]
orn = to_quaternion([0, 0, pose[2]])
p.resetBasePositionAndOrientation(self.__bid, pos, orn)
else:
raise type_error("pose", list, type(pose))
def area(self, area):
if isinstance(area, float):
if area < 0.0:
raise value_error("area", "x >= 0", area)
self.__area = area
else:
raise type_error("area", float, type(area))
def configurations(self, configurations):
if isinstance(configurations, list):
# for configuration in configurations:
# self.engine.push_bodies(configuration)
self.__configurations = configurations
else:
raise type_error("configurations", list, type(configurations))
def continuous_configuration(self, continuous_configuration):
if isinstance(continuous_configuration, Configuration):
self.__continuous_configuration = continuous_configuration
else:
raise type_error(
"continuous_configuration",
Configuration,
type(continuous_configuration),
)
def color(self, color):
if isinstance(color, list):
for index, item in enumerate(color):
if not isinstance(item, float):
raise type_error(
"index {} of color".format(index), float, type(item)
)
if item > 1.0 or item < 0.0:
raise value_error("index {} of color", "0 >= x >= 1", item)
# TODO: handle multiple links better
p.changeVisualShape(self.__bid, -1, rgbaColor=color)
p.changeVisualShape(self.__bid, 0, rgbaColor=color)
p.changeVisualShape(self.__bid, 1, rgbaColor=color)
p.changeVisualShape(self.__bid, 2, rgbaColor=color)
self.__color = color
else:
raise type_error("color", list, type(color))
def configuration(self, configuration):
if isinstance(configuration, Configuration):
if self.configuration is not None:
for body in configuration.movable:
# body.set_color([1,0,0,1])
loaded_body = copy.deepcopy(
self.configuration.find_body(body.oid))
loaded_body.constraints = copy.deepcopy(body.constraints)
loaded_body.pose = body.pose
self.__configuration = configuration
elif configuration is None:
self.__configuration = configuration
else:
raise type_error("configuration", Configuration,
type(configuration))
def problem(self, problem):
if isinstance(problem, Problem):
self.__problem = problem
else:
raise type_error("problem", Problem, type(problem))
def random_restart(self, random_restart):
if isinstance(random_restart, bool):
self.__random_restart = random_restart
else:
raise type_error("random_restart", Problem, type(random_restart))
def timeout(self, timeout):
if isinstance(timeout, float):
self.__timeout = timeout
else:
raise type_error("timeout", float, type(timeout))
def visual(self, visual):
if isinstance(visual, bool) or visual is None:
self.__visual = visual
else:
raise type_error("visual", bool, type(visual))
def start_time(self, start_time):
if isinstance(start_time, float):
self.__start_time = start_time
else:
raise type_error("start_time", float, type(start_time))
def connected(self, connected):
if isinstance(connected, bool):
self.__connected = connected
else:
raise type_error("connected", bool, type(connected))
def path(self, path):
if isinstance(path, str):
self.__path = path
else:
raise type_error("path", str, type(path))
def batch_size(self, batch_size):
if isinstance(batch_size, int):
self.__batch_size = batch_size
else:
raise type_error("batch_size", int, type(batch_size))
def const_dict(self, const_dict):
if isinstance(const_dict, dict):
self.__const_dict = const_dict
else:
raise type_error("const_dict", dict, type(const_dict))
def collision_threshold(self, col_thresh):
if isinstance(col_thresh, float):
self.__collision_threshold = col_thresh
else:
raise type_error("collision_threshold", float, type(col_thresh))
def lexi(self, lexi):
if isinstance(lexi, bool):
self.__lexi = lexi
else:
raise type_error("lexi", Problem, type(lexi))
def maximality(self, maximality):
if isinstance(maximality, bool):
self.__maximality = maximality
else:
raise type_error("maximality", Problem, type(maximality))
def coverage(self, coverage):
if isinstance(coverage, float):
self.__coverage = coverage
else:
raise type_error("coverage", float, type(coverage))
def engine(self, engine):
if isinstance(engine, Engine):
self.__engine = engine
else:
raise type_error("engine", Engine, type(engine))
def surface(self, surface):
if isinstance(surface, Body):
self.__surface = surface
else:
raise type_error("surface", Body, type(surface))
def oid(self, oid):
if isinstance(oid, uuid.UUID):
self.__oid = oid
else:
raise type_error("oid", uuid.UUID, type(oid))
def eid(self, eid):
if isinstance(eid, int) or eid is None:
self.__eid = eid
else:
raise type_error("eid", int, type(eid))
