def _create_behavior(self):
"""
After invoking this scenario, cyclist will wait for the user
controlled vehicle to enter the in the trigger distance region,
the cyclist starts crossing the road once the condition meets,
ego vehicle has to avoid the crash after a left turn, but
continue driving after the road is clear.If this does not happen
within 90 seconds, a timeout stops the scenario.
"""
root = py_trees.composites.Parallel(
policy=py_trees.common.ParallelPolicy.SUCCESS_ON_ONE, name="IntersectionLeftTurn")
lane_width = self._reference_waypoint.lane_width
dist_to_travel = lane_width + (1.10 * lane_width * self._num_lane_changes)
bycicle_start_dist = 13 + dist_to_travel
if self._ego_route is not None:
trigger_distance = InTriggerDistanceToLocationAlongRoute(self.ego_vehicles[0], self._ego_route, self._other_actor_transform.location, bycicle_start_dist)
else:
trigger_distance = InTriggerDistanceToVehicle(self.other_actors[0],
self.ego_vehicles[0],
bycicle_start_dist)
actor_velocity = KeepVelocity(self.other_actors[0], self._other_actor_target_velocity)
actor_traverse = DriveDistance(self.other_actors[0], 0.30 * dist_to_travel)
post_timer_velocity_actor = KeepVelocity(self.other_actors[0], self._other_actor_target_velocity)
post_timer_traverse_actor = DriveDistance(self.other_actors[0], 0.70 * dist_to_travel)
end_condition = TimeOut(5)
# non leaf nodes
scenario_sequence = py_trees.composites.Sequence()
actor_ego_sync = py_trees.composites.Parallel(
"Synchronization of actor and ego vehicle",
policy=py_trees.common.ParallelPolicy.SUCCESS_ON_ONE)
after_timer_actor = py_trees.composites.Parallel(
"After timeout actor will cross the remaining lane_width",
policy=py_trees.common.ParallelPolicy.SUCCESS_ON_ONE)
# building the tree
root.add_child(scenario_sequence)
scenario_sequence.add_child(ActorTransformSetter(self.other_actors[0], self._other_actor_transform, name='TransformSetterTS4'))
scenario_sequence.add_child(HandBrakeVehicle(self.other_actors[0], True))
scenario_sequence.add_child(trigger_distance)
scenario_sequence.add_child(HandBrakeVehicle(self.other_actors[0], False))
scenario_sequence.add_child(actor_ego_sync)
scenario_sequence.add_child(after_timer_actor)
scenario_sequence.add_child(end_condition)
scenario_sequence.add_child(ActorDestroy(self.other_actors[0]))
actor_ego_sync.add_child(actor_velocity)
actor_ego_sync.add_child(actor_traverse)
after_timer_actor.add_child(post_timer_velocity_actor)
after_timer_actor.add_child(post_timer_traverse_actor)
return root
def _create_behavior(self):
"""
After invoking this scenario, cyclist will wait for the user
controlled vehicle to enter the in the trigger distance region,
the cyclist starts crossing the road once the condition meets,
ego vehicle has to avoid the crash after a turn, but
continue driving after the road is clear.If this does not happen
within 90 seconds, a timeout stops the scenario.
"""
sequence = py_trees.composites.Sequence()
collision_location = self._collision_wp.transform.location
collision_distance = collision_location.distance(self._adversary_transform.location)
collision_duration = collision_distance / self._adversary_speed
collision_time_trigger = collision_duration + self._reaction_time
# On trigger behavior
if self._ego_route is not None:
sequence.add_child(Scenario4Manager(self._spawn_dist))
# First waiting behavior
sequence.add_child(WaitEndIntersection(self.ego_vehicles[0]))
# Adversary trigger behavior
trigger_adversary = py_trees.composites.Parallel(
policy=py_trees.common.ParallelPolicy.SUCCESS_ON_ONE, name="TriggerAdversaryStart")
trigger_adversary.add_child(InTimeToArrivalToLocation(
self.ego_vehicles[0], collision_time_trigger, collision_location))
trigger_adversary.add_child(InTriggerDistanceToLocation(
self.ego_vehicles[0], collision_location, self._min_trigger_dist))
sequence.add_child(trigger_adversary)
sequence.add_child(HandBrakeVehicle(self.other_actors[0], False))
# Move the adversary.
speed_duration = 2.0 * collision_duration
speed_distance = 2.0 * collision_distance
sequence.add_child(KeepVelocity(
self.other_actors[0],
self._adversary_speed,
True,
speed_duration,
speed_distance,
name="AdversaryCrossing")
)
# Remove everything
sequence.add_child(ActorDestroy(self.other_actors[0], name="DestroyAdversary"))
sequence.add_child(DriveDistance(self.ego_vehicles[0], self._ego_end_distance, name="EndCondition"))
return sequence
def _create_behavior(self):
"""
After invoking this scenario, cyclist will wait for the user
controlled vehicle to enter trigger distance region,
the cyclist starts crossing the road once the condition meets,
then after 60 seconds, a timeout stops the scenario
"""
root = py_trees.composites.Parallel(
policy=py_trees.common.ParallelPolicy.SUCCESS_ON_ONE,
name="OccludedObjectCrossing")
lane_width = self._reference_waypoint.lane_width
lane_width = lane_width + (1.25 * lane_width * self._num_lane_changes)
dist_to_trigger = 12 + self._num_lane_changes
# leaf nodes
if self._ego_route is not None:
start_condition = InTriggerDistanceToLocationAlongRoute(
self.ego_vehicles[0], self._ego_route, self.transform.location,
dist_to_trigger)
else:
start_condition = InTimeToArrivalToVehicle(self.other_actors[0],
self.ego_vehicles[0],
self._time_to_reach)
actor_velocity = KeepVelocity(self.other_actors[0],
self._other_actor_target_velocity,
name="walker velocity")
actor_drive = DriveDistance(self.other_actors[0],
0.5 * lane_width,
name="walker drive distance")
actor_start_cross_lane = AccelerateToVelocity(
self.other_actors[0],
1.0,
self._other_actor_target_velocity,
name="walker crossing lane accelerate velocity")
actor_cross_lane = DriveDistance(
self.other_actors[0],
lane_width,
name="walker drive distance for lane crossing ")
actor_stop_crossed_lane = StopVehicle(self.other_actors[0],
self._other_actor_max_brake,
name="walker stop")
ego_pass_machine = DriveDistance(self.ego_vehicles[0],
5,
name="ego vehicle passed prop")
actor_remove = ActorDestroy(self.other_actors[0],
name="Destroying walker")
static_remove = ActorDestroy(self.other_actors[1],
name="Destroying Prop")
end_condition = DriveDistance(self.ego_vehicles[0],
self._ego_vehicle_distance_driven,
name="End condition ego drive distance")
# non leaf nodes
scenario_sequence = py_trees.composites.Sequence()
keep_velocity_other = py_trees.composites.Parallel(
policy=py_trees.common.ParallelPolicy.SUCCESS_ON_ONE,
name="keep velocity other")
keep_velocity = py_trees.composites.Parallel(
policy=py_trees.common.ParallelPolicy.SUCCESS_ON_ONE,
name="keep velocity")
# building tree
root.add_child(scenario_sequence)
scenario_sequence.add_child(
ActorTransformSetter(self.other_actors[0],
self.transform,
name='TransformSetterTS3walker',
physics=False))
scenario_sequence.add_child(
ActorTransformSetter(self.other_actors[1],
self.transform2,
name='TransformSetterTS3coca',
physics=False))
scenario_sequence.add_child(
HandBrakeVehicle(self.other_actors[0], True))
scenario_sequence.add_child(start_condition)
scenario_sequence.add_child(
HandBrakeVehicle(self.other_actors[0], False))
scenario_sequence.add_child(keep_velocity)
scenario_sequence.add_child(keep_velocity_other)
scenario_sequence.add_child(actor_stop_crossed_lane)
scenario_sequence.add_child(actor_remove)
scenario_sequence.add_child(static_remove)
scenario_sequence.add_child(end_condition)
keep_velocity.add_child(actor_velocity)
keep_velocity.add_child(actor_drive)
keep_velocity_other.add_child(actor_start_cross_lane)
keep_velocity_other.add_child(actor_cross_lane)
keep_velocity_other.add_child(ego_pass_machine)
return root
