def parse_NOC_nmea(mission, vehicle, category, ftype, outpath):
# parser meta data
sensor_string = "autosub"
category = category
output_format = ftype
if category == Category.USBL:
filepath = mission.usbl.filepath
timezone = mission.usbl.timezone
beacon_id = mission.usbl.label
timeoffset = mission.usbl.timeoffset
timezone_offset = read_timezone(timezone)
latitude_reference = mission.origin.latitude
longitude_reference = mission.origin.longitude
usbl = Usbl(
mission.usbl.std_factor,
mission.usbl.std_offset,
latitude_reference,
longitude_reference,
)
usbl.sensor_string = sensor_string
path = get_raw_folder(outpath / ".." / filepath)
file_list = get_file_list(path)
data_list = []
for file in file_list:
with file.open("r", errors="ignore") as nmea_file:
for line in nmea_file.readlines():
parts = line.split("\t")
if len(parts) < 2:
continue
msg = pynmea2.parse(parts[1])
if int(msg.ref_station_id) != beacon_id:
continue
date_str = line.split(" ")[0]
hour_str = str(parts[1]).split(",")[1]
yyyy = int(date_str[6:10])
mm = int(date_str[3:5])
dd = int(date_str[0:2])
hour = int(hour_str[0:2])
mins = int(hour_str[2:4])
secs = int(hour_str[4:6])
msec = int(hour_str[7:10])
epoch_time = date_time_to_epoch(yyyy, mm, dd, hour, mins,
secs, timezone_offset)
epoch_timestamp = epoch_time + msec / 1000 + timeoffset
msg.timestamp = epoch_timestamp
usbl.from_nmea(msg)
data = usbl.export(output_format)
data_list.append(data)
return data_list
def parse_NOC_polpred(mission, vehicle, category, ftype, outpath):
# parser meta data
sensor_string = "autosub"
category = category
output_format = ftype
if category == Category.TIDE:
filepath = mission.tide.filepath
timezone = mission.tide.timezone
timeoffset = mission.tide.timeoffset
timezone_offset = read_timezone(timezone)
tide = Tide(mission.tide.std_offset)
tide.sensor_string = sensor_string
path = get_raw_folder(outpath / ".." / filepath)
file_list = get_file_list(path)
data_list = []
Console.info("... parsing NOC tide data")
# Data format sample
# Date Time Level Speed Direc'n
# m m/s deg
# 6/ 9/2019 00:00 0.74 0.14 51
# 6/ 9/2019 01:00 0.58 0.15 56
for file in file_list:
with file.open("r", errors="ignore") as tide_file:
for line in tide_file.readlines()[6:]:
# we have to skip the first 5 rows of the file
dd = int(line[0:2])
mm = int(line[3:5])
yyyy = int(line[6:10])
hour = int(line[12:14])
mins = int(line[15:17])
secs = 0 # current models only provide resolution in minutes
msec = 0
epoch_time = date_time_to_epoch(yyyy, mm, dd, hour, mins,
secs, timezone_offset)
epoch_timestamp = epoch_time + msec / 1000 + timeoffset
tide.epoch_timestamp = epoch_timestamp
tide.height = float(line[22:28])
tide.height_std = tide.height * tide.height_std_factor
data = tide.export(output_format)
data_list.append(data)
return data_list
def epoch_timestamp_from_zone_offset(self, date, timezone, offset):
self.year, self.month, self.day = date
self.tz_offset = read_timezone(timezone)
self.offset = offset
def parse_gaps(mission, vehicle, category, ftype, outpath):
Console.info(" Parsing GAPS data...")
# parser meta data
class_string = "measurement"
sensor_string = "gaps"
frame_string = "inertial"
timezone = mission.usbl.timezone
timeoffset = mission.usbl.timeoffset
filepath = mission.usbl.filepath
usbl_id = mission.usbl.label
latitude_reference = mission.origin.latitude
longitude_reference = mission.origin.longitude
# define headers used in phins
header_absolute = "$PTSAG" # '<< $PTSAG' #georeferenced strings
header_heading = "$HEHDT" # '<< $HEHDT'
# gaps std models
distance_std_factor = mission.usbl.std_factor
distance_std_offset = mission.usbl.std_offset
broken_packet_flag = False
# read in timezone
timezone_offset = read_timezone(timezone)
# convert to seconds from utc
# timeoffset = -timezone_offset*60*60 + timeoffset
# determine file paths
path = (outpath / ".." / filepath).absolute()
filepath = get_raw_folder(path)
all_list = os.listdir(str(filepath))
gaps_list = [line for line in all_list if ".dat" in line]
Console.info(" " + str(len(gaps_list)) + " GAPS file(s) found")
# extract data from files
data_list = []
if ftype == "acfr":
data_list = ""
for i in range(len(gaps_list)):
path_gaps = filepath / gaps_list[i]
with path_gaps.open("r", errors="ignore") as gaps:
# initialise flag
flag_got_time = 0
for line in gaps.readlines():
line_split = line.strip().split("*")
line_split_no_checksum = line_split[0].strip().split(",")
broken_packet_flag = False
# print(line_split_no_checksum)
# keep on upating ship position to find the prior interpolation
# value of ship coordinates
# line_split_no_checksum[0] == header_absolute:
if header_absolute in line_split_no_checksum[0]:
# start with a ship coordinate
if line_split_no_checksum[6] == str(
usbl_id) and flag_got_time == 2:
if (line_split_no_checksum[11] == "F"
and line_split_no_checksum[13] == "1"):
# read in date
yyyy = int(line_split_no_checksum[5])
mm = int(line_split_no_checksum[4])
dd = int(line_split_no_checksum[3])
# read in time
time_string = str(line_split_no_checksum[2])
try:
hour = int(time_string[0:2])
mins = int(time_string[2:4])
secs = int(time_string[4:6])
msec = int(time_string[7:10])
except ValueError:
broken_packet_flag = True
pass
if secs >= 60:
mins += 1
secs = 0
broken_packet_flag = True
if mins >= 60:
hour += 1
mins = 0
broken_packet_flag = True
if hour >= 24:
dd += 1
hour = 0
broken_packet_flag = True
epoch_time = date_time_to_epoch(
yyyy, mm, dd, hour, mins, secs,
timezone_offset)
# dt_obj = datetime(yyyy,mm,dd,hour,mins,secs)
# time_tuple = dt_obj.timetuple()
# epoch_time = time.mktime(time_tuple)
epoch_timestamp = epoch_time + msec / 1000 + timeoffset
# get position
latitude_negative_flag = False
longitude_negative_flag = False
latitude_string = line_split_no_checksum[7]
latitude_degrees = int(latitude_string[0:2])
latitude_minutes = float(latitude_string[2:10])
if line_split_no_checksum[8] == "S":
latitude_negative_flag = True
longitude_string = line_split_no_checksum[9]
longitude_degrees = int(longitude_string[0:3])
longitude_minutes = float(longitude_string[3:11])
if line_split_no_checksum[10] == "W":
longitude_negative_flag = True
depth = float(line_split_no_checksum[12])
latitude = latitude_degrees + latitude_minutes / 60.0
longitude = longitude_degrees + longitude_minutes / 60.0
if latitude_negative_flag:
latitude = -latitude
if longitude_negative_flag:
longitude = -longitude
# flag raised to proceed
flag_got_time = 3
else:
flag_got_time = 0
if line_split_no_checksum[6] == "0":
if flag_got_time < 3:
# read in date
yyyy = int(line_split_no_checksum[5])
mm = int(line_split_no_checksum[4])
dd = int(line_split_no_checksum[3])
# print(yyyy,mm,dd)
# read in time
time_string = str(line_split_no_checksum[2])
# print(time_string)
hour = int(time_string[0:2])
mins = int(time_string[2:4])
secs = int(time_string[4:6])
try:
msec = int(time_string[7:10])
except ValueError:
broken_packet_flag = True
pass
if secs >= 60:
mins += 1
secs = 0
broken_packet_flag = True
if mins >= 60:
hour += 1
mins = 0
broken_packet_flag = True
if hour >= 24:
dd += 1
hour = 0
broken_packet_flag = True
epoch_time = date_time_to_epoch(
yyyy, mm, dd, hour, mins, secs,
timezone_offset)
# dt_obj = datetime(yyyy,mm,dd,hour,mins,secs)
# time_tuple = dt_obj.timetuple()
# epoch_time = time.mktime(time_tuple)
epoch_timestamp_ship_prior = (epoch_time +
msec / 1000 +
timeoffset)
# get position
latitude_string = line_split_no_checksum[7]
latitude_degrees_ship_prior = int(
latitude_string[0:2])
latitude_minutes_ship_prior = float(
latitude_string[2:10])
latitude_prior = (
latitude_degrees_ship_prior +
latitude_minutes_ship_prior / 60.0)
if line_split_no_checksum[8] == "S":
latitude_prior = -latitude_prior
longitude_string = line_split_no_checksum[9]
longitude_degrees_ship_prior = int(
longitude_string[0:3])
longitude_minutes_ship_prior = float(
longitude_string[3:11])
longitude_prior = (
longitude_degrees_ship_prior +
longitude_minutes_ship_prior / 60.0)
if line_split_no_checksum[10] == "W":
longitude_prior = -longitude_prior
# flag raised to proceed
if flag_got_time < 2:
flag_got_time = flag_got_time + 1
elif flag_got_time >= 3:
if line_split_no_checksum[6] == "0":
# read in date
yyyy = int(line_split_no_checksum[5])
mm = int(line_split_no_checksum[4])
dd = int(line_split_no_checksum[3])
# read in time
time_string = str(line_split_no_checksum[2])
hour = int(time_string[0:2])
mins = int(time_string[2:4])
secs = int(time_string[4:6])
msec = int(time_string[7:10])
# calculate epoch time
epoch_time = date_time_to_epoch(
yyyy,
mm,
dd,
hour,
mins,
secs,
timezone_offset,
)
# dt_obj = datetime(yyyy,mm,dd,hour,mins,secs)
# time_tuple = dt_obj.timetuple()
# epoch_time = time.mktime(time_tuple)
epoch_timestamp_ship_posterior = (epoch_time +
msec / 1000 +
timeoffset)
# get position
latitude_string = line_split_no_checksum[7]
latitude_degrees_ship_posterior = int(
latitude_string[0:2])
latitude_minutes_ship_posterior = float(
latitude_string[2:10])
latitude_posterior = (
latitude_degrees_ship_posterior +
latitude_minutes_ship_posterior / 60.0)
if line_split_no_checksum[8] == "S":
latitude_posterior = -latitude_posterior
longitude_string = line_split_no_checksum[9]
longitude_degrees_ship_posterior = int(
longitude_string[0:3])
longitude_minutes_ship_posterior = float(
longitude_string[3:11])
longitude_posterior = (
longitude_degrees_ship_posterior +
longitude_minutes_ship_posterior / 60.0)
if line_split_no_checksum[10] == "W":
longitude_posterior = -longitude_posterior
# flag raised to proceed
flag_got_time = flag_got_time + 1
# line_split_no_checksum[0] == header_heading:
if header_heading in line_split_no_checksum[0]:
if flag_got_time < 3:
heading_ship_prior = float(line_split_no_checksum[1])
if flag_got_time < 2:
flag_got_time = flag_got_time + 1
else:
heading_ship_posterior = float(
line_split_no_checksum[1])
flag_got_time = flag_got_time + 1
if flag_got_time >= 5:
# interpolate for the ships location and heading
inter_time = (epoch_timestamp - epoch_timestamp_ship_prior
) / (epoch_timestamp_ship_posterior -
epoch_timestamp_ship_prior)
longitude_ship = (inter_time *
(longitude_posterior - longitude_prior) +
longitude_prior)
latitude_ship = (inter_time *
(latitude_posterior - latitude_prior) +
latitude_prior)
heading_ship = (
inter_time *
(heading_ship_posterior - heading_ship_prior) +
heading_ship_prior)
while heading_ship > 360:
heading_ship = heading_ship - 360
while heading_ship < 0:
heading_ship = heading_ship + 360
lateral_distance, bearing = latlon_to_metres(
latitude, longitude, latitude_ship, longitude_ship)
# determine range to input to uncertainty model
distance = math.sqrt(lateral_distance * lateral_distance +
depth * depth)
distance_std = distance_std_factor * distance + distance_std_offset
# determine uncertainty in terms of latitude and longitude
latitude_offset, longitude_offset = metres_to_latlon(
abs(latitude),
abs(longitude),
distance_std,
distance_std,
)
latitude_std = abs(abs(latitude) - latitude_offset)
longitude_std = abs(abs(longitude) - longitude_offset)
# calculate in metres from reference
lateral_distance_ship, bearing_ship = latlon_to_metres(
latitude_ship,
longitude_ship,
latitude_reference,
longitude_reference,
)
eastings_ship = (math.sin(bearing_ship * math.pi / 180.0) *
lateral_distance_ship)
northings_ship = (
math.cos(bearing_ship * math.pi / 180.0) *
lateral_distance_ship)
lateral_distance_target, bearing_target = latlon_to_metres(
latitude,
longitude,
latitude_reference,
longitude_reference,
)
eastings_target = (
math.sin(bearing_target * math.pi / 180.0) *
lateral_distance_target)
northings_target = (
math.cos(bearing_target * math.pi / 180.0) *
lateral_distance_target)
if not broken_packet_flag:
if ftype == "oplab" and category == Category.USBL:
data = {
"epoch_timestamp":
float(epoch_timestamp),
"class":
class_string,
"sensor":
sensor_string,
"frame":
frame_string,
"category":
category,
"data_ship": [
{
"latitude": float(latitude_ship),
"longitude": float(longitude_ship),
},
{
"northings": float(northings_ship),
"eastings": float(eastings_ship),
},
{
"heading": float(heading_ship)
},
],
"data_target": [
{
"latitude": float(latitude),
"latitude_std": float(latitude_std),
},
{
"longitude": float(longitude),
"longitude_std": float(longitude_std),
},
{
"northings": float(northings_target),
"northings_std": float(distance_std),
},
{
"eastings": float(eastings_target),
"eastings_std": float(distance_std),
},
{
"depth": float(depth),
"depth_std": float(distance_std),
},
{
"distance_to_ship": float(distance)
},
],
}
data_list.append(data)
elif ftype == "oplab" and category == Category.DEPTH:
data = {
"epoch_timestamp":
float(epoch_timestamp),
"epoch_timestamp_depth":
float(epoch_timestamp),
"class":
class_string,
"sensor":
sensor_string,
"frame":
"inertial",
"category":
Category.DEPTH,
"data": [{
"depth": float(depth),
"depth_std": float(distance_std),
}],
}
data_list.append(data)
if ftype == "acfr":
data = (
"SSBL_FIX: " + str(float(epoch_timestamp)) +
" ship_x: " + str(float(northings_ship)) +
" ship_y: " + str(float(eastings_ship)) +
" target_x: " + str(float(northings_target)) +
" target_y: " + str(float(eastings_target)) +
" target_z: " + str(float(depth)) +
" target_hr: " + str(float(lateral_distance)) +
" target_sr: " + str(float(distance)) +
" target_bearing: " + str(float(bearing)) +
"\n")
data_list += data
else:
Console.warn("Badly formatted packet (GAPS TIME)")
Console.warn(line)
# print(hour,mins,secs)
# reset flag
flag_got_time = 0
Console.info(" ...done parsing GAPS data.")
return data_list
def parse_usbl_dump(mission, vehicle, category, ftype, outpath):
# parser meta data
class_string = "measurement"
sensor_string = "jamstec_usbl"
frame_string = "inertial"
# gaps std models
distance_std_factor = mission.usbl.std_factor
distance_std_offset = mission.usbl.std_offset
timezone = mission.usbl.timezone
timeoffset = mission.usbl.timeoffset
filepath = mission.usbl.filepath
filename = mission.usbl.filename
label = mission.usbl.label
filepath = get_raw_folder(outpath / ".." / filepath)
latitude_reference = mission.origin.latitude
longitude_reference = mission.origin.longitude
# read in timezone
timezone_offset = read_timezone(timezone)
# convert to seconds from utc
# timeoffset = -timezone_offset*60*60 + timeoffset
# extract data from files
Console.info("... parsing usbl dump")
data_list = []
if ftype == "acfr":
data_list = ""
usbl_file = filepath / filename
with usbl_file.open("r", encoding="utf-8", errors="ignore") as filein:
for line in filein.readlines():
line_split = line.strip().split(",")
if line_split[2] == label:
date = line_split[0].split("-")
# read in date
yyyy = int(date[0])
mm = int(date[1])
dd = int(date[2])
timestamp = line_split[1].split(":")
# read in time
hour = int(timestamp[0])
mins = int(timestamp[1])
secs = int(timestamp[2])
msec = 0
epoch_time = date_time_to_epoch(
yyyy, mm, dd, hour, mins, secs, timezone_offset
)
# dt_obj = datetime(yyyy,mm,dd,hour,mins,secs)
# time_tuple = dt_obj.timetuple()
# epoch_time = time.mktime(time_tuple)
epoch_timestamp = epoch_time + msec / 1000 + timeoffset
if line_split[6] != "":
# get position
latitude_full = line_split[6].split(" ")
latitude_list = latitude_full[0].split("-")
latitude_degrees = int(latitude_list[0])
latitude_minutes = float(latitude_list[1])
if latitude_full[1] != "N":
latitude_degrees = latitude_degrees * -1 # southern hemisphere
latitude = latitude_degrees + latitude_minutes / 60
longitude_full = line_split[7].split(" ")
longitude_list = longitude_full[0].split("-")
longitude_degrees = int(longitude_list[0])
longitude_minutes = float(longitude_list[1])
if longitude_full[1] != "E":
longitude_degrees = (
longitude_degrees * -1
) # southern hemisphere
longitude = longitude_degrees + longitude_minutes / 60
depth_full = line_split[8].split("=")
depth = float(depth_full[1])
distance_full = line_split[11].split("=")
distance = float(distance_full[1])
distance_std = distance_std_factor * distance + distance_std_offset
lateral_distance_full = line_split[9].split("=")
lateral_distance = float(lateral_distance_full[1])
bearing_full = line_split[10].split("=")
bearing = float(bearing_full[1])
# determine uncertainty in terms of latitude and longitude
latitude_offset, longitude_offset = metres_to_latlon(
latitude, longitude, distance_std, distance_std
)
latitude_std = latitude - latitude_offset
longitude_std = longitude - longitude_offset
# calculate in metres from reference
eastings_ship = 0
northings_ship = 0
latitude_ship = 0
longitude_ship = 0
heading_ship = 0
lateral_distance_target, bearing_target = latlon_to_metres(
latitude, longitude, latitude_reference, longitude_reference,
)
eastings_target = (
math.sin(bearing_target * math.pi / 180.0)
* lateral_distance_target
)
northings_target = (
math.cos(bearing_target * math.pi / 180.0)
* lateral_distance_target
)
if ftype == "oplab":
data = {
"epoch_timestamp": float(epoch_timestamp),
"class": class_string,
"sensor": sensor_string,
"frame": frame_string,
"category": category,
"data_ship": [
{
"latitude": float(latitude_ship),
"longitude": float(longitude_ship),
},
{
"northings": float(northings_ship),
"eastings": float(eastings_ship),
},
{"heading": float(heading_ship)},
],
"data_target": [
{
"latitude": float(latitude),
"latitude_std": float(latitude_std),
},
{
"longitude": float(longitude),
"longitude_std": float(longitude_std),
},
{
"northings": float(northings_target),
"northings_std": float(distance_std),
},
{
"eastings": float(eastings_target),
"eastings_std": float(distance_std),
},
{
"depth": float(depth),
"depth_std": float(distance_std),
},
{"distance_to_ship": float(distance)},
],
}
data_list.append(data)
if ftype == "acfr":
data = (
"SSBL_FIX: "
+ str(float(epoch_timestamp))
+ " ship_x: "
+ str(float(northings_ship))
+ " ship_y: "
+ str(float(eastings_ship))
+ " target_x: "
+ str(float(northings_target))
+ " target_y: "
+ str(float(eastings_target))
+ " target_z: "
+ str(float(depth))
+ " target_hr: "
+ str(float(lateral_distance))
+ " target_sr: "
+ str(float(distance))
+ " target_bearing: "
+ str(float(bearing))
+ "\n"
)
data_list += data
return data_list
def load_configuration(self, correct_config=None):
if correct_config is None: # nothing to do here, we expect an explicit call
Console.warn("No correct_config provided. Skipping load_configuration()")
return
self.correct_config = correct_config
"""Load general configuration parameters"""
self.correction_method = self.correct_config.method
if self.correction_method == "colour_correction":
self.distance_metric = self.correct_config.color_correction.distance_metric
self.distance_path = self.correct_config.color_correction.metric_path
self.altitude_max = self.correct_config.color_correction.altitude_max
self.altitude_min = self.correct_config.color_correction.altitude_min
self.smoothing = self.correct_config.color_correction.smoothing
self.window_size = self.correct_config.color_correction.window_size
self.outlier_rejection = self.correct_config.color_correction.outlier_reject
self.cameraconfigs = self.correct_config.configs.camera_configs
self.undistort = self.correct_config.output_settings.undistort_flag
self.output_format = self.correct_config.output_settings.compression_parameter
# Load camera parameters
cam_idx = self.get_camera_idx()
self.camera_found = False
if cam_idx is None:
Console.info(
"Camera not included in correct_images.yaml. No",
"processing will be done for this camera.",
)
return
else:
self.camera_found = True
self.user_specified_image_list_parse = self.cameraconfigs[
cam_idx
].imagefilelist_parse
self.user_specified_image_list_process = self.cameraconfigs[
cam_idx
].imagefilelist_process
if self.correction_method == "colour_correction":
# Brighness and contrast are percentages of 255
# e.g. brightness of 30 means 30% of 255 = 77
self.brightness = float(self.cameraconfigs[cam_idx].brightness)
self.contrast = float(self.cameraconfigs[cam_idx].contrast)
elif self.correction_method == "manual_balance":
self.subtractors_rgb = np.array(self.cameraconfigs[cam_idx].subtractors_rgb)
self.color_gain_matrix_rgb = np.array(
self.cameraconfigs[cam_idx].color_gain_matrix_rgb
)
# Create output directories and needed attributes
self.create_output_directories()
# Define basic filepaths
if self.correction_method == "colour_correction":
p = Path(self.attenuation_parameters_folder)
self.attenuation_params_filepath = p / "attenuation_parameters.npy"
self.correction_gains_filepath = p / "correction_gains.npy"
self.corrected_mean_filepath = p / "image_corrected_mean.npy"
self.corrected_std_filepath = p / "image_corrected_std.npy"
self.raw_mean_filepath = p / "image_raw_mean.npy"
self.raw_std_filepath = p / "image_raw_std.npy"
# Define image loader
# Use default loader
self.loader = loader.Loader()
self.loader.bit_depth = self.camera.bit_depth
if self.camera.extension == "raw":
self.loader.set_loader("xviii")
elif self.camera.extension == "bag":
self.loader.set_loader("rosbag")
tz_offset_s = (
read_timezone(self.mission.image.timezone) * 60
+ self.mission.image.timeoffset
)
self.loader.tz_offset_s = tz_offset_s
else:
self.loader.set_loader("default")
def parse_rosbag(mission, vehicle, category, output_format, outpath):
"""Parse rosbag files
Parameters
----------
mission : Mission
Mission object
vehicle : Vehicle
Vehicle object
category : str
Measurement category
output_format : str
Output format
outpath : str
Output path
Returns
-------
list
Measurement data list
"""
if not ROSBAG_IS_AVAILABLE:
Console.error("rosbag is not available")
Console.error("install it with:")
Console.error(
"pip install --extra-index-url",
"https://rospypi.github.io/simple/ rosbag",
)
Console.quit(
"rosbag is not available and required to parse ROS bagfiles.")
# Get your data from a file using mission paths, for example
depth_std_factor = mission.depth.std_factor
velocity_std_factor = mission.velocity.std_factor
velocity_std_offset = mission.velocity.std_offset
altitude_std_factor = mission.altitude.std_factor
usbl_std_factor = mission.usbl.std_factor
usbl_std_offset = mission.usbl.std_offset
# NED origin
origin_latitude = mission.origin.latitude
origin_longitude = mission.origin.longitude
ins_heading_offset = vehicle.ins.yaw
dvl_heading_offset = vehicle.dvl.yaw
body_velocity = BodyVelocity(
velocity_std_factor,
velocity_std_offset,
dvl_heading_offset,
)
orientation = Orientation(ins_heading_offset)
depth = Depth(depth_std_factor)
altitude = Altitude(altitude_std_factor)
usbl = Usbl(
usbl_std_factor,
usbl_std_offset,
latitude_reference=origin_latitude,
longitude_reference=origin_longitude,
)
camera = Camera()
camera.sensor_string = mission.image.cameras[0].name
body_velocity.sensor_string = "rosbag"
orientation.sensor_string = "rosbag"
depth.sensor_string = "rosbag"
altitude.sensor_string = "rosbag"
usbl.sensor_string = "rosbag"
# Adjust timezone offsets
body_velocity.tz_offset_s = (
read_timezone(mission.velocity.timezone) * 60 +
mission.velocity.timeoffset)
orientation.tz_offset_s = (
read_timezone(mission.orientation.timezone) * 60 +
mission.orientation.timeoffset)
depth.tz_offset_s = (read_timezone(mission.depth.timezone) * 60 +
mission.depth.timeoffset)
altitude.tz_offset_s = (read_timezone(mission.altitude.timezone) * 60 +
mission.altitude.timeoffset)
usbl.tz_offset_s = (read_timezone(mission.usbl.timezone) * 60 +
mission.usbl.timeoffset)
camera.tz_offset_s = (read_timezone(mission.image.timezone) * 60 +
mission.image.timeoffset)
data_list = []
bagfile = None
wanted_topic = None
data_object = None
filepath = None
if category == Category.ORIENTATION:
Console.info("... parsing orientation")
filepath = get_raw_folder(mission.orientation.filepath)
bagfile = mission.orientation.filename
wanted_topic = mission.orientation.topic
data_object = orientation
elif category == Category.VELOCITY:
Console.info("... parsing velocity")
filepath = get_raw_folder(mission.velocity.filepath)
bagfile = mission.velocity.filename
wanted_topic = mission.velocity.topic
data_object = body_velocity
elif category == Category.DEPTH:
Console.info("... parsing depth")
filepath = get_raw_folder(mission.depth.filepath)
bagfile = mission.depth.filename
wanted_topic = mission.depth.topic
data_object = depth
elif category == Category.ALTITUDE:
Console.info("... parsing altitude")
filepath = get_raw_folder(mission.altitude.filepath)
bagfile = mission.altitude.filename
wanted_topic = mission.altitude.topic
data_object = altitude
elif category == Category.USBL:
Console.info("... parsing position")
filepath = get_raw_folder(mission.usbl.filepath)
bagfile = mission.usbl.filename
wanted_topic = mission.usbl.topic
data_object = usbl
elif category == Category.IMAGES:
Console.info("... parsing images")
filepath = get_raw_folder(mission.image.cameras[0].path)
bagfile = "*.bag"
wanted_topic = mission.image.cameras[0].topic
data_object = camera
else:
Console.quit("Unknown category for ROS parser", category)
bagfile_list = list(filepath.glob(bagfile))
outpath = Path(outpath).parent
data_list = rosbag_topic_worker(bagfile_list, wanted_topic, data_object,
data_list, output_format, outpath)
Console.info("... parsed " + str(len(data_list)) + " " + category +
" entries")
return data_list