def get_boundingbox(metadata, z_offset):
with open(metadata) as f:
meta = json.load(f)['lemnatec_measurement_metadata']
loc_gantry_x = float(
meta['sensor_fixed_metadata']['location in camera box x [m]'])
loc_gantry_y = float(
meta['sensor_fixed_metadata']['location in camera box y [m]'])
loc_gantry_z = float(
meta['sensor_fixed_metadata']['location in camera box z [m]'])
gantry_x = float(meta['gantry_system_variable_metadata']
['position x [m]']) + loc_gantry_x
gantry_y = float(meta['gantry_system_variable_metadata']
['position y [m]']) + loc_gantry_y
gantry_z = float(meta['gantry_system_variable_metadata']['position z [m]']
) + z_offset + loc_gantry_z #offset in m
fov_2m = meta['sensor_fixed_metadata'][
'field of view at 2m in X- Y- direction [m]']
fov_x, fov_y = fov_2m.strip('[ ]').split(' ')
img_height = int(
meta['sensor_variable_metadata']['height left image [pixel]'])
img_width = int(
meta['sensor_variable_metadata']['width left image [pixel]'])
B = gantry_z
A_x = np.arctan((0.5 * float(fov_x)) / 2)
A_y = np.arctan((0.5 * float(fov_y)) / 2)
L_x = 2 * B * np.tan(A_x)
L_y = 2 * B * np.tan(A_y)
x_n = gantry_x + (L_x / 2)
x_s = gantry_x - (L_x / 2)
y_w = gantry_y + (L_y / 2)
y_e = gantry_y - (L_y / 2)
bbox_nw_latlon = scanalyzer_to_latlon(x_n, y_w)
bbox_se_latlon = scanalyzer_to_latlon(x_s, y_e)
# TERRA-REF
lon_shift = 0.000020308287
# Drone
lat_shift = 0.000018292 #0.000015258894
b_box = (bbox_se_latlon[0] - lat_shift, bbox_nw_latlon[0] - lat_shift,
bbox_nw_latlon[1] + lon_shift, bbox_se_latlon[1] + lon_shift)
return b_box, img_height, img_width
def get_meta_info(meta_path):
with open(meta_path) as f:
meta = json.load(f)['lemnatec_measurement_metadata']
scan_dir = int(meta['sensor_variable_metadata']['current setting Scan direction (automatically set at runtime)'])
east_x = float(meta['sensor_fixed_metadata']['scanner east location in camera box x [m]'])
east_y = float(meta['sensor_fixed_metadata']['scanner east location in camera box y [m]'])
west_x = float(meta['sensor_fixed_metadata']['scanner west location in camera box x [m]'])
west_y = float(meta['sensor_fixed_metadata']['scanner west location in camera box y [m]'])
y_diff = abs(east_y - west_y)/2
x_diff = east_x
x = float(meta['gantry_system_variable_metadata']['position x [m]']) #+ x_diff
y = float(meta['gantry_system_variable_metadata']['position y [m]']) #+ y_diff if scan_dir==1 else float(meta['gantry_system_variable_metadata']['position y [m]']) - y_diff
z = float(meta['gantry_system_variable_metadata']['position z [m]'])
lat, lon = scanalyzer_to_latlon(x, y)
return lat, lon, scan_dir, z
def get_bounding_box(meta, sensor):
args = get_args()
scan_direction = int(
meta['sensor_variable_metadata']
['current setting Scan direction (automatically set at runtime)'])
scan_distance = float(
meta['sensor_variable_metadata']
['current setting Scan distance (automatically set at runtime) [mm]']
) / 1000
#scan_distance = float(meta['gantry_system_fixed_metadata']['system scan area e-w [m]']) #+ abs(west_loc_gantry_y - east_loc_gantry_y)
fov_y = meta['sensor_fixed_metadata']['field of view y [m]']
fov_x = scan_distance
theta = np.radians(90)
rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],
[np.sin(theta),
np.cos(theta), 0], [0, 0, 1]])
#print(scan_direction)
if sensor == 'east':
# East
east_loc_gantry_x = float(
meta['sensor_fixed_metadata']
['scanner east location in camera box x [m]'])
east_loc_gantry_y = float(
meta['sensor_fixed_metadata']
['scanner east location in camera box y [m]'])
east_loc_gantry_z = float(
meta['sensor_fixed_metadata']
['scanner east location in camera box z [m]'])
gantry_x = float(meta['gantry_system_variable_metadata']
['position x [m]']) #+ east_loc_gantry_x
gantry_y = float(meta['gantry_system_variable_metadata']
['position y [m]']) #+ east_loc_gantry_y
gantry_z = float(
meta['gantry_system_variable_metadata']['position z [m]']
) + args.z_offset + east_loc_gantry_z #offset in m
if scan_direction == 0:
gantry_y = gantry_y - scan_distance / 2 + east_loc_gantry_y
elif scan_direction == 1:
gantry_y = gantry_y + scan_distance / 2 + east_loc_gantry_y
bbox_center = scanalyzer_to_latlon(gantry_x, gantry_y)
elif sensor == 'west':
# West
west_loc_gantry_x = float(
meta['sensor_fixed_metadata']
['scanner west location in camera box x [m]'])
west_loc_gantry_y = float(
meta['sensor_fixed_metadata']
['scanner west location in camera box y [m]'])
west_loc_gantry_z = float(
meta['sensor_fixed_metadata']
['scanner west location in camera box z [m]'])
gantry_x = float(meta['gantry_system_variable_metadata']
['position x [m]']) #+ west_loc_gantry_x
gantry_y = float(meta['gantry_system_variable_metadata']
['position y [m]']) #+ west_loc_gantry_y
gantry_z = float(
meta['gantry_system_variable_metadata']['position z [m]']
) + args.z_offset + west_loc_gantry_z #offset in m
if scan_direction == 0:
gantry_y = gantry_y - scan_distance / 2 + west_loc_gantry_y
elif scan_direction == 1:
gantry_y = gantry_y + scan_distance / 2 + west_loc_gantry_y
bbox_center = scanalyzer_to_latlon(gantry_x, gantry_y)
B = gantry_z
A_x = np.arctan((0.5 * float(fov_x)) / 3.5)
A_y = np.arctan((0.5 * float(fov_y)) / 3.5)
L_x = 2 * B * np.tan(A_x)
L_y = 2 * B * np.tan(A_y)
x_n = gantry_y + (L_x / 2)
x_s = gantry_y - (L_x / 2)
y_w = gantry_x + (L_y / 2)
y_e = gantry_x - (L_y / 2)
bbox_nw_latlon = scanalyzer_to_latlon(y_w, x_n)
bbox_se_latlon = scanalyzer_to_latlon(y_e, x_s)
lon_shift = 0.000020308287
lat_shift = 0.000018292 #0.000015258894
b_box = (bbox_se_latlon[0] - lat_shift, bbox_nw_latlon[0] - lat_shift,
bbox_nw_latlon[1] + lon_shift, bbox_se_latlon[1] + lon_shift)
return b_box, bbox_center, rotation_matrix, gantry_z
def md_shp():
args = get_args()
# Load required files as well as files to process
pathlist = glob.glob(f'{args.dir}/*/*.json')
print(pathlist)
shp = gpd.read_file(f'{args.geojson}')
print(shp)
# print(pathlist)
JSON_path_list = []
for path in pathlist:
path_str = str(path)
JSON_path_list.append(path_str)
# Create dictionary and populates it
JSON_dict = {}
cnt = 0
# JSON_dict[time, filename, gantry_x, gantry_y, gantry_z] = "Date, Time, Gantry_x, Gantry_y, Gantry_z"
for i in JSON_path_list:
with open(i) as f:
cnt += 1
meta = json.load(f)['lemnatec_measurement_metadata']
time = (meta['gantry_system_variable_metadata']['time'])
filename = i.split('/')[-1]
# Gantry loc metadata
gantry_x = float(
meta['gantry_system_variable_metadata']['position x [m]'])
gantry_y = float(
meta['gantry_system_variable_metadata']['position y [m]'])
gantry_z = float(
meta['gantry_system_variable_metadata']['position z [m]'])
# Sensor loc metadata
sens_x = float(
meta['sensor_fixed_metadata']['location in camera box x [m]'])
sens_y = float(
meta['sensor_fixed_metadata']['location in camera box y [m]'])
sens_z = float(
meta['sensor_fixed_metadata']['location in camera box z [m]'])
# gantry_x_pos =
z_offset = 0.76
sens_loc_x = gantry_x + sens_x
sens_loc_y = gantry_y + sens_y
sens_loc_z = gantry_z + z_offset + sens_z #offset in m
fov_x, fov_y = float(
meta['sensor_fixed_metadata']['field of view x [m]']), float(
meta['sensor_fixed_metadata']['field of view y [m]'])
B = sens_loc_z
A_x = np.arctan((0.5 * float(fov_x)) / 2)
A_y = np.arctan((0.5 * float(fov_y)) / 2)
L_x = 2 * B * np.tan(A_x)
L_y = 2 * B * np.tan(A_y)
x_n = sens_loc_x + (L_x / 2)
x_s = sens_loc_x - (L_x / 2)
y_w = sens_loc_y + (L_y / 2)
y_e = sens_loc_y - (L_y / 2)
bbox_nw_latlon = scanalyzer_to_latlon(x_n, y_w)
bbox_se_latlon = scanalyzer_to_latlon(x_s, y_e)
# TERRA-REF
lon_shift = 0.000020308287
# Drone
lat_shift = 0.000018292 #0.000015258894
b_box = (bbox_se_latlon[0] - lat_shift,
bbox_nw_latlon[0] - lat_shift,
bbox_nw_latlon[1] + lon_shift,
bbox_se_latlon[1] + lon_shift)
JSON_dict[cnt] = {
"time": time,
"filename": filename,
# "gantry_x": gantry_x,
# "gantry_y": gantry_y,
# "gantry_z": gantry_z,
# "sens_x": sens_loc_x,
# "sens_y": sens_loc_y,
# "sens_z": sens_loc_z,
"gantry_x": sens_loc_x,
"gantry_y": sens_loc_y,
"gantry_z": sens_loc_z,
"b_box": b_box
}
# filename = os.path.basename(metadata)
# JSON_df = pd.DataFrame.from_dict(JSON_dict, orient='index', columns=['time','filename','gantry_x','gantry_y','gantry_z', 'sens_x', 'sens_y', 'sens_z', 'b_box'])
JSON_df = pd.DataFrame.from_dict(JSON_dict,
orient='index',
columns=[
'time', 'filename', 'gantry_x',
'gantry_y', 'gantry_z', 'b_box'
])
# Converts gantry/scanners location to lat lon
GPS_latlon = scanalyzer_to_latlon(JSON_df['gantry_x'], JSON_df['gantry_y'])
GPS_latlon_df = pd.DataFrame(GPS_latlon).transpose()
GPS_latlon_df.columns = ['GPS_lat', 'GPS_lon']
# Creates polygons for plots
polygon_list = []
for i, row in JSON_df.iterrows():
bbox = JSON_df['b_box'].loc[i]
polygon = Polygon([[bbox[2], bbox[1]], [bbox[3], bbox[1]],
[bbox[3], bbox[0]], [bbox[2], bbox[0]]])
polygon_list.append(polygon)
JSON_df['bbox_geometry'] = polygon_list
JSON_df['time'] = pd.to_datetime(JSON_df.time)
JSON_df = JSON_df.sort_values(by='time')
# Function in function! There's gotta be a better way...
# Intersects polygons with shapefile
def intersection(bbox_polygon):
intersects = bbox_polygon.intersects
plot = None
intersection_list = []
for i, row in shp.iterrows():
plot_polygon = row['geometry']
intersection = intersects(plot_polygon)
if intersection == True:
plot = [row['ID']]
intersection_list.append(plot)
return intersection_list
JSON_df["plot"] = None
for i, row in JSON_df.iterrows():
bbox_polygon = row['bbox_geometry']
print(bbox_polygon)
plot = intersection(bbox_polygon)
JSON_df.at[i, 'plot'] = plot
print(JSON_df)
# JSON_df.to_csv("JSONdf.csv")
return JSON_df