def __init__(self,
name,
city_name,
depth_camera_name,
flags,
log_file_name=None,
csv_file_name=None):
super(ERDOSAgentOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._map = CarlaMap(city_name)
self._pid = PID(p=self._flags.pid_p,
i=self._flags.pid_i,
d=self._flags.pid_d)
self._world_transform = []
self._depth_imgs = []
self._traffic_lights = []
self._obstacles = []
self._vehicle_pos = None
self._vehicle_acc = None
self._vehicle_speed = None
self._wp_angle = None
self._wp_vector = None
self._wp_angle_speed = None
(self._depth_intrinsic, self._depth_transform,
self._depth_img_size) = self.__setup_camera_tranforms(
name=depth_camera_name, postprocessing='Depth')
def __init__(self, name, flags, log_file_name=None, csv_file_name=None):
super(CameraLoggerOp, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._last_bgr_timestamp = -1
self._last_segmented_timestamp = -1
def __init__(self,
name,
output_stream_name,
tracker_type,
flags,
log_file_name=None,
csv_file_name=None):
super(ObjectTrackerOp, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._output_stream_name = output_stream_name
try:
if tracker_type == 'cv2':
from trackers.cv2_tracker import MultiObjectCV2Tracker
self._tracker = MultiObjectCV2Tracker(self._flags)
elif tracker_type == 'crv':
from trackers.crv_tracker import MultiObjectCRVTracker
self._tracker = MultiObjectCRVTracker(self._flags)
elif tracker_type == 'da_siam_rpn':
from trackers.da_siam_rpn_tracker import MultiObjectDaSiamRPNTracker
self._tracker = MultiObjectDaSiamRPNTracker(self._flags)
else:
self._logger.fatal(
'Unexpected tracker type {}'.format(tracker_type))
except ImportError:
self._logger.fatal('Error importing {}'.format(tracker_type))
# True when the tracker is ready to update bboxes.
self._ready_to_update = False
self._ready_to_update_timestamp = None
self._to_process = deque()
self._last_seq_num = -1
self._lock = threading.Lock()
def __init__(self,
name,
rgb_camera_setup,
flags,
log_file_name=None,
csv_file_name=None):
super(GroundTruthObjectLoggerOp, self).__init__(name)
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._flags = flags
# Queue of incoming data.
self._bgr_imgs = deque()
self._world_transforms = deque()
self._depth_imgs = deque()
self._pedestrians = deque()
self._segmented_imgs = deque()
self._vehicles = deque()
(camera_name, pp, img_size, pos) = rgb_camera_setup
(self._rgb_intrinsic, self._rgb_transform,
self._rgb_img_size) = get_camera_intrinsic_and_transform(
name=camera_name,
postprocessing=pp,
image_size=img_size,
position=pos)
self._last_notification = -1
def __init__(self,
name,
longitudinal_control_args,
flags,
log_file_name=None,
csv_file_name=None):
""" Initializes the operator to send out control information given
waypoints on its input streams.
Args:
name: The name of the operator.
longitudinal_control_args: A dictionary of arguments to be used to
initialize the longitudinal controller. It needs to contain
three floating point values with the keys K_P, K_D, K_I, where
K_P -- Proportional Term
K_D -- Differential Term
K_I -- Integral Term
flags: A handle to the global flags instance to retrieve the
configuration.
log_file_name: The file to log the required information to.
csv_file_name: The CSV file to log info to.
"""
super(PIDControlOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._longitudinal_control_args = longitudinal_control_args
self._pid = PID(
p=longitudinal_control_args['K_P'],
i=longitudinal_control_args['K_I'],
d=longitudinal_control_args['K_D'],
)
self._vehicle_transform = None
self._last_waypoint_msg = None
self._latest_speed = 0
def __init__(self, name, flags, log_file_name=None, csv_file_name=None):
super(SegmentationEvalGroundOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._time_delta = None
self._ground_masks = deque()
def __init__(self,
name,
rgb_camera_setup,
flags,
log_file_name=None,
csv_file_name=None):
super(DetectionEvalGroundOperator, self).__init__(name)
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._flags = flags
# Queue of incoming data.
self._bgr_imgs = deque()
self._world_transforms = deque()
self._depth_imgs = deque()
self._pedestrians = deque()
self._ground_bboxes = deque()
(camera_name, pp, img_size, pos) = rgb_camera_setup
(self._rgb_intrinsic, self._rgb_transform,
self._rgb_img_size) = get_camera_intrinsic_and_transform(
name=camera_name,
postprocessing=pp,
image_size=img_size,
position=pos)
self._last_notification = -1
self._iou_thresholds = [0.1 * i for i in range(1, 10)]
def __init__(self,
name,
output_stream_name,
flags,
log_file_name=None,
csv_file_name=None):
super(SegmentationDRNOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._output_stream_name = output_stream_name
arch = "drn_d_22"
classes = 19
pretrained = "dependencies/data/drn_d_22_cityscapes.pth"
self._pallete = drn.segment.CITYSCAPE_PALETTE
# TODO(ionel): Figure out how to set GPU memory fraction.
self._model = DRNSeg(arch,
classes,
pretrained_model=None,
pretrained=False)
self._model.load_state_dict(torch.load(pretrained))
# TODO(ionel): Automatically detect if GPU is available.
if self._flags.segmentation_gpu:
self._model = torch.nn.DataParallel(self._model).cuda()
self._last_seq_num = -1
def __init__(self,
name,
output_stream_name,
flags,
log_file_name=None,
csv_file_name=None):
"""Initializes the PerfectTracker Operator. """
super(PerfectTrackerOp, self).__init__(name)
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._flags = flags
self._output_stream_name = output_stream_name
# Queues of incoming data.
self._vehicles_raw_msgs = deque()
self._pedestrians_raw_msgs = deque()
self._can_bus_msgs = deque()
# Processed data. Key is actor id, value is deque containing the past
# trajectory of the corresponding actor. Trajectory is stored in world
# coordinates, for ease of transformation.
trajectory = lambda: deque(maxlen=self._flags.perfect_tracking_num_steps)
self._vehicles = defaultdict(trajectory)
self._pedestrians = defaultdict(trajectory)
self._lock = threading.Lock()
self._frame_cnt = 0
def __init__(self,
name,
rgb_camera_setup,
flags,
log_file_name=None,
csv_file_name=None):
super(ObstacleAccuracyOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._world_transforms = []
self._pedestrians = []
self._vehicles = []
self._traffic_lights = []
self._traffic_signs = []
self._depth_imgs = []
self._bgr_imgs = []
(camera_name, pp, img_size, pos) = rgb_camera_setup
(self._rgb_intrinsic, self._rgb_transform, self._rgb_img_size
) = detection_utils.get_camera_intrinsic_and_transform(
name=camera_name,
postprocessing=pp,
image_size=img_size,
position=pos)
self._last_notification = -1
# Buffer of detected obstacles.
self._detected_obstacles = []
# Buffer of ground truth bboxes.
self._ground_obstacles = []
# Heap storing pairs of (ground/output time, game time).
self._detector_start_end_times = []
self._sim_interval = None
self._iou_thresholds = [0.1 * i for i in range(1, 10)]
def __init__(self, name, flags, log_file_name=None, csv_file_name=None):
super(CarlaReplayOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._client = None
self._world = None
# Lock to ensure that the callbacks do not execute simultaneously.
self._lock = threading.Lock()
def __init__(self,
name,
output_stream_name,
flags,
log_file_name=None,
csv_file_name=None):
super(LaneDetectionOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._output_stream_name = output_stream_name
def __init__(self, name, flags, log_file_name=None, csv_file_name=None):
super(CameraLoggerOp, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._bgr_frame_cnt = 0
self._segmented_frame_cnt = 0
self._top_down_segmented_frame_cnt = 0
self._depth_frame_cnt = 0
self._left_bgr_frame_cnt = 0
self._right_bgr_frame_cnt = 0
def __init__(self,
name,
flags,
goal_location=None,
log_file_name=None,
csv_file_name=None):
super(PlanningOperator, self).__init__(name)
self._log_file_name = log_file_name
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._flags = flags
# Initialize the state of the behaviour planner.
# XXX(ionel): The behaviour planner is not ready yet.
self.__initialize_behaviour_planner()
# We do not know yet the vehicle's location.
self._vehicle_transform = None
# Deque of waypoints the vehicle must follow. The waypoints are either
# received on the global trajectory stream when running using the
# scenario runner, or computed using the Carla global planner when
# running in stand-alone mode. The waypoints are Pylot transforms.
self._waypoints = deque()
# The operator picks the wp_num_steer-th waypoint to compute the angle
# it has to steer by when taking a turn.
self._wp_num_steer = 9 # use 9th waypoint for steering
# The operator picks the wp_num_speed-th waypoint to compute the angle
# it has to steer by when driving straight.
self._wp_num_speed = 4 # use 4th waypoint for speed
# We're not running in challenge mode if no track flag is present.
# Thus, we can directly get the map from the simulator.
if not hasattr(self._flags, 'track'):
self._map = HDMap(
get_map(self._flags.carla_host, self._flags.carla_port,
self._flags.carla_timeout), log_file_name)
self._logger.info('Planner running in stand-alone mode')
assert goal_location, 'Planner has not received a goal location'
# Transform goal location to carla.Location
self._goal_location = carla.Location(*goal_location)
# Do not recompute waypoints upon each run.
self._recompute_waypoints = True
else:
# Recompute waypoints upon each run.
self._recompute_waypoints = False
# TODO(ionel): HACK! In Carla challenge track 1 and 2 the waypoints
# are coarse grained (30 meters apart). We pick the first waypoint
# to compute the angles. However, we should instead implement
# trajectory planning.
if self._flags.track == 1 or self._flags == 2:
self._wp_num_steer = 1
self._wp_num_speed = 1
def __init__(self, name, flags, log_file_name=None, csv_file_name=None):
super(CarlaReplayOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
# Connect to CARLA and retrieve the world running.
self._client, self._world = get_world(self._flags.carla_host,
self._flags.carla_port,
self._flags.carla_timeout)
if self._client is None or self._world is None:
raise ValueError('There was an issue connecting to the simulator.')
# Lock to ensure that the callbacks do not execute simultaneously.
self._lock = threading.Lock()
def __init__(self,
name,
city_name,
goal_location,
goal_orientation,
flags,
log_file_name=None,
csv_file_name=None):
super(LegacyPlanningOperator, self).__init__(name)
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._goal_location = goal_location
self._goal_orientation = goal_orientation
self._waypointer = Waypointer(city_name)
self._wp_num_steer = 0.9
self._wp_num_speed = 0.4
def __init__(self,
name,
city_name,
goal_location,
goal_orientation,
flags,
log_file_name=None,
csv_file_name=None):
super(WaypointerOperator, self).__init__(name)
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._goal_location = goal_location
self._goal_orientation = goal_orientation
self._waypointer = Waypointer(city_name)
self._wp_num_steer = 0.9 # Select WP - Reverse Order: 1 - closest, 0 - furthest
self._wp_num_speed = 0.4 # Select WP - Reverse Order: 1 - closest, 0 - furthest
def __init__(self, name, flags, log_file_name=None, csv_file_name=None):
super(GroundAgentOperator, self).__init__(name)
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._flags = flags
self._map = HDMap(
get_map(self._flags.carla_host, self._flags.carla_port,
self._flags.carla_timeout), log_file_name)
self._pid = PID(p=flags.pid_p, i=flags.pid_i, d=flags.pid_d)
self._can_bus_msgs = deque()
self._pedestrian_msgs = deque()
self._vehicle_msgs = deque()
self._traffic_light_msgs = deque()
self._speed_limit_sign_msgs = deque()
self._waypoint_msgs = deque()
self._lock = threading.Lock()
def __init__(self,
name,
output_stream_name,
flags,
log_file_name=None,
csv_file_name=None):
super(SegmentationDLAOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._output_stream_name = output_stream_name
# TODO(ionel): Figure out how to set GPU memory fraction.
self._network = dla.DLASeg.DLASeg()
self._network.load_state_dict(
torch.load(self._flags.segmentation_dla_model_path))
if self._flags.segmentation_gpu:
self._network = self._network.cuda()
def __init__(self,
name,
output_stream_name,
flags,
log_file_name=None,
csv_file_name=None):
super(DetectionCenterNetOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._output_stream_name = output_stream_name
self._opt = opts().init()
self._opt.load_model = self._flags.detector_center_net_model_path
Detector = detector_factory[self._opt.task]
self._detector = Detector(self._opt)
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
def __init__(self,
name,
flags,
log_file_name=None,
csv_file_name=None):
super(ObstacleAccuracyOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._last_notification = None
# Buffer of detected obstacles.
self._detected_obstacles = []
# Buffer of ground truth bboxes.
self._ground_obstacles = []
# Heap storing pairs of (ground/output time, game time).
self._detector_start_end_times = []
self._sim_interval = None
self._iou_thresholds = [0.1 * i for i in range(1, 10)]
def __init__(self,
name,
flags,
output_stream_name,
log_file_name=None,
csv_file_name=None,
camera_fov=np.pi / 4,
rgbd_max_range=1000):
super(FusionOperator, self).__init__(name)
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._flags = flags
self._output_stream_name = output_stream_name
self._segments = []
self._objs = []
self._rgbd_max_range = rgbd_max_range
# TODO(ionel): Check fov is same as the camere fov.
self._camera_fov = camera_fov
self._car_positions = deque()
self._distances = deque()
self._objects = deque()
def __init__(self,
name,
output_stream_name,
flags,
log_file_name=None,
csv_file_name=None):
super(SegmentationDRNOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._output_stream_name = output_stream_name
arch = "drn_d_22"
classes = 19
self._pallete = drn.segment.CITYSCAPE_PALETTE
# TODO(ionel): Figure out how to set GPU memory fraction.
self._model = DRNSeg(
arch, classes, pretrained_model=None, pretrained=False)
self._model.load_state_dict(
torch.load(self._flags.segmentation_drn_model_path))
if torch.cuda.is_available():
self._model = torch.nn.DataParallel(self._model).cuda()
def __init__(self,
name,
output_stream_name,
model_path,
flags,
log_file_name=None,
csv_file_name=None):
super(DetectionOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._output_stream_name = output_stream_name
self._detection_graph = tf.Graph()
# Load the model from the model file.
with self._detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(model_path, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
self._gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=flags
.obj_detection_gpu_memory_fraction)
# Create a TensorFlow session.
self._tf_session = tf.Session(
graph=self._detection_graph,
config=tf.ConfigProto(gpu_options=self._gpu_options))
# Get the tensors we're interested in.
self._image_tensor = self._detection_graph.get_tensor_by_name(
'image_tensor:0')
self._detection_boxes = self._detection_graph.get_tensor_by_name(
'detection_boxes:0')
self._detection_scores = self._detection_graph.get_tensor_by_name(
'detection_scores:0')
self._detection_classes = self._detection_graph.get_tensor_by_name(
'detection_classes:0')
self._num_detections = self._detection_graph.get_tensor_by_name(
'num_detections:0')
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
