def test_geodata_conversion(self): from fire_rs.geodata.environment import World world = World() gd = world.get_elevation([[475060.0, 485060], [6200074.0, 6210074]]) raster = gd.as_cpp_raster() print(raster) gd2 = GeoData.from_cpp_raster(raster, "elevation_cpp") print(gd2[10, 10][0]) self.assertAlmostEqual(gd[10, 10][0], gd2[10, 10][0]) self.assertAlmostEqual(gd.x_offset, gd2.x_offset) self.assertAlmostEqual(gd.y_offset, gd2.y_offset) self.assertEqual(gd.data.shape, gd2.data.shape) print(gd2)
def plot_plan_with_background(plan: Plan, geodatadisplay: gdd, time_range, output_options_plot): """Plot a plan trajectories with background geographic information in a geodata display.""" # Draw background layers for layer in output_options_plot['background']: if layer == 'elevation_shade': geodatadisplay.draw_elevation_shade( with_colorbar=output_options_plot.get('colorbar', True), layer='elevation') if layer == 'elevation_planning_shade': geodatadisplay.draw_elevation_shade( with_colorbar=output_options_plot.get('colorbar', True), layer='elevation_planning') elif layer == 'ignition_shade': geodatadisplay.draw_ignition_shade( with_colorbar=output_options_plot.get('colorbar', True)) elif layer == 'observedcells': raise NotImplementedError() # geodatadisplay.TrajectoryDisplayExtension.draw_observation_map( # planner.expected_observed_map(layer_name="expected_observed"), # layer='expected_observed', color='green', alpha=0.9) # geodatadisplay.TrajectoryDisplayExtension.draw_observation_map( # planner.expected_ignited_map(layer_name="expected_ignited"), # layer='expected_ignited', color='red', alpha=0.9) elif layer == 'ignition_contour': try: geodatadisplay.draw_ignition_contour(with_labels=True) except ValueError as e: logger.exception("ValueError while drawing ignition contour") elif layer == 'wind_quiver': geodatadisplay.draw_wind_quiver() elif layer == 'utilitymap': geodatadisplay.TrajectoryDisplayExtension.draw_utility_shade( geodata=GeoData.from_cpp_raster( plan.utility_map(), 'utility', projection=geodatadisplay.geodata.projection), layer='utility', vmin=0., vmax=1.) plot_plan_trajectories(plan, geodatadisplay, layers=output_options_plot["foreground"], time_range=time_range)
def plot_sr_with_background(sr: 'planning.up.SearchResult', geodatadisplay, time_range, output_options_plot, plan: 'Union[str, int]' = 'final'): """Plot a plan trajectories with background geographic information in a geodata display.""" # Draw background layers for layer in output_options_plot['background']: if layer == 'elevation_shade': geodatadisplay.draw_elevation_shade( with_colorbar=output_options_plot.get('colorbar', True), layer='elevation') if layer == 'elevation_planning_shade': geodatadisplay.draw_elevation_shade( with_colorbar=output_options_plot.get('colorbar', True), layer='elevation_planning') elif layer == 'ignition_shade': geodatadisplay.draw_ignition_shade( with_colorbar=output_options_plot.get('colorbar', True)) # elif layer == 'observedcells': # geodatadisplay.TrajectoryDisplayExtension.draw_observation_map( # planner.expected_observed_map(layer_name="expected_observed"), # layer='expected_observed', color='green', alpha=0.9) # geodatadisplay.TrajectoryDisplayExtension.draw_observation_map( # planner.expected_ignited_map(layer_name="expected_ignited"), # layer='expected_ignited', color='red', alpha=0.9) elif layer == 'ignition_contour': try: geodatadisplay.draw_ignition_contour(with_labels=True) except ValueError as e: logger.exception("ValueError while drawing ignition contour") elif layer == 'wind_quiver': geodatadisplay.draw_wind_quiver() elif layer == 'utilitymap': geodatadisplay.TrajectoryDisplayExtension.draw_utility_shade( geodata=GeoData.from_cpp_raster(sr.final_plan().utility_map(), 'utility'), layer='utility', vmin=0., vmax=1.) plot_plan_trajectories(sr.plan(plan), geodatadisplay, layers=output_options_plot["foreground"], time_range=time_range)
def observed(self) -> GeoData: return GeoData.from_cpp_raster(self._gfmapper.observed, self.observed_fire_layer)
def pr(cpp_raster, blocking=False): # plots a cpp raster return GeoData.from_cpp_raster(cpp_raster, "xx").plot(blocking=blocking)
def observed(self) -> 'GeoData': return GeoData.from_cpp_raster(self._gfmapper.observed, self.output_fire_layer)
def firemap(self) -> 'GeoData': return GeoData.from_cpp_raster(self._gfmapper.firemap, self.output_fire_layer)
def utility_map(self, layer_name='utility') -> 'GeoData': return GeoData.from_cpp_raster( self._searchresult.final_plan().utility_map(), layer_name)
def run_benchmark(scenario: Scenario, save_directory: str, instance_name: str, output_options_plot: ty.Mapping[str, ty.Any], output_options_planning: ty.Mapping[str, ty.Any], snapshots: bool, vns_name: str, output_options_data: ty.Mapping[str, ty.Any]): _logger.info("Starting benchmark instance %s", instance_name) # Fetch scenario environment data with additional elevation mode for planning env = PlanningEnvironment( scenario.area, wind_speed=scenario.wind_speed, wind_dir=scenario.wind_direction, planning_elevation_mode=output_options_planning['elevation_mode'], discrete_elevation_interval=DISCRETE_ELEVATION_INTERVAL, world=fire_rs.geodata.environment.World( landcover_to_fuel_remap=fire_rs.geodata.environment. EVERYTHING_FUELMODEL_REMAP)) # Propagate fires in the environment propagation_end_time = scenario.time_window_end + 60 * 10 _logger.debug("Propagating fire ignitions %s until %s", str(scenario.ignitions), str(propagation_end_time)) prop = propagation.propagate_from_points(env, scenario.ignitions, until=propagation_end_time) ignitions = prop.ignitions() # Transform altitude of UAV bases from agl (above ground level) to absolute for f in scenario.flights: base_h = 0. # If flat, start at the default segment insertion h if output_options_planning['elevation_mode'] != 'flat': base_h = base_h + env.raster["elevation"][env.raster.array_index( (f.base_waypoint.x, f.base_waypoint.y))] # The new WP is (old_x, old_y, old_z + elevation[old_x, old_y], old_dir) f.base_waypoint = Waypoint(f.base_waypoint.x, f.base_waypoint.y, base_h, f.base_waypoint.dir) conf = { 'min_time': scenario.time_window_start, 'max_time': scenario.time_window_end, 'save_every': 0, 'save_improvements': snapshots, 'vns': vns_configurations[vns_name] } conf['vns']['configuration_name'] = vns_name # Define the flight window flight_window = TimeWindow(scenario.time_window_start, scenario.time_window_end) # Create utility map utility = make_utility_map(ignitions, flight_window, layer='ignition', output_layer='utility') utility_cpp = utility.as_cpp_raster('utility') # Make a FireData object fire_data = make_fire_data(ignitions, env.raster, elevation_map_layer='elevation_planning') # Create an initial plan initial_plan = Plan(instance_name, [f.as_cpp() for f in scenario.flights], fire_data, flight_window, utility_cpp) # Set up a Planner object from the initial Plan pl = Planner(initial_plan, vns_configurations[vns_name]) pl.save_improvements = snapshots pl.save_every = 0 search_result = pl.compute_plan() final_plan = search_result.final_plan() # Propagation was running more time than desired in order to reduce edge effect. # Now we need to filter out-of-range ignition times. Crop range is rounded up to the next # 10-minute mark (minus 1). This makes color bar ranges and fire front contour plots nicer ignitions['ignition'][ignitions['ignition'] > \ int(scenario.time_window_end / 60. + 5) * 60. - 60] = _DBL_MAX # Representation of unburned cells using max double is not suitable for display, # so those values must be converted to NaN ignitions_nan = ignitions['ignition'].copy() ignitions_nan[ignitions_nan == _DBL_MAX] = np.nan first_ignition = np.nanmin(ignitions_nan) last_ignition = np.nanmax(ignitions_nan) # Create the geodatadisplay object & extensions that are going to be used geodatadisplay = GeoDataDisplay.pyplot_figure( env.raster.combine(ignitions), frame=(0, 0)) geodatadisplay.add_extension(TrajectoryDisplayExtension, (None, ), {}) plot_plan_with_background(final_plan, geodatadisplay, (first_ignition, last_ignition), output_options_plot) # Save the picture filepath = os.path.join( save_directory, instance_name + "." + str(output_options_plot.get('format', 'png'))) _logger.info("Saving as figure as: %s", str(filepath)) geodatadisplay.axes.get_figure().set_size_inches( *output_options_plot.get('size', (15, 10))) geodatadisplay.axes.get_figure().savefig(filepath, dpi=output_options_plot.get( 'dpi', 150), bbox_inches='tight') # Save rasters if output_options_data['save_rasters']: raster_data_dir = os.path.join(save_directory, instance_name + "_data") if not os.path.exists(raster_data_dir): os.makedirs(raster_data_dir) env.raster.write_to_file( os.path.join( raster_data_dir, ".".join(("_".join( (instance_name, "elevation_planning")), 'tif'))), 'elevation_planning') env.raster.write_to_file( os.path.join( raster_data_dir, ".".join(("_".join( (instance_name, "wind_velocity")), 'tif'))), 'wind_velocity') env.raster.write_to_file( os.path.join( raster_data_dir, ".".join(("_".join( (instance_name, "wind_angle")), 'tif'))), 'wind_angle') prop.ignitions().write_to_file(os.path.join( raster_data_dir, ".".join(("_".join( (instance_name, "ignition")), 'tif'))), 'ignition', nodata=np.inf) u_initial_map = GeoData.from_cpp_raster(initial_plan.utility_map(), "utility", projection=utility.projection) u_initial_map.write_to_file( os.path.join( raster_data_dir, ".".join(("_".join( (instance_name, "utility_initial")), 'tif'))), 'utility') u_final_map = GeoData.from_cpp_raster(final_plan.utility_map(), "utility", projection=utility.projection) u_final_map.write_to_file( os.path.join( raster_data_dir, ".".join(("_".join( (instance_name, "utility_final")), 'tif'))), 'utility') # print([o.as_tuple() for o in final_plan.observations()]) # Log planned trajectories metadata for i, t in enumerate(final_plan.trajectories()): _logger.debug("traj #{} duration: {} / {}".format( i, t.duration(), t.conf.max_flight_time)) # save metadata to file with open(os.path.join(save_directory, instance_name + ".json"), "w") as metadata_file: import json parsed = json.loads(search_result.metadata()) parsed["benchmark_id"] = instance_name parsed["date"] = datetime.datetime.now().isoformat() metadata_file.write(json.dumps(parsed, indent=4)) matplotlib.pyplot.close(geodatadisplay.axes.get_figure()) # If intermediate plans are available, save them for i, plan in enumerate(search_result.intermediate_plans): geodatadisplay = GeoDataDisplay.pyplot_figure( env.raster.combine(ignitions)) geodatadisplay.add_extension(TrajectoryDisplayExtension, (None, ), {}) plot_plan_with_background(plan, geodatadisplay, (first_ignition, last_ignition), output_options_plot) i_plan_dir = os.path.join(save_directory, instance_name) if not os.path.exists(i_plan_dir): os.makedirs(i_plan_dir) filepath = os.path.join( i_plan_dir, str(i) + "." + str(output_options_plot.get('format', 'png'))) _logger.info("Saving intermediate plan as: %s", str(filepath)) geodatadisplay.axes.get_figure().set_size_inches( *output_options_plot.get('size', (15, 10))) geodatadisplay.axes.get_figure().savefig(filepath, dpi=output_options_plot.get( 'dpi', 150), bbox_inches='tight') matplotlib.pyplot.close(geodatadisplay.axes.get_figure()) del search_result
# Obtain Obs fire using a firemapper over a fake ground truth. # In normal conditions, Obs fire should be provided by neptus elevation_draster = pl_env.raster.as_cpp_raster('elevation') ignition_draster = ignitions.as_cpp_raster() gfmapper = fmapping.GhostFireMapper( op.FireData(ignition_draster, elevation_draster)) # Suposing we follow exactly the planned path # executed_path is a tuple with a list of waypoints and a list of the corresponding time executed_path = search_result.final_plan().trajectories( )[0].sampled_with_time(step_size=10) executed_path_wp = executed_path[0] executed_path_t = executed_path[1] # type: 'op.DRaster' obs_fire_raster = gfmapper.observed_firemap(executed_path_wp, executed_path_t, flight_confs_cpp[0].uav) obs_fire = GeoData.from_cpp_raster(obs_fire_raster, 'ignition') gdd = GeoDataDisplay.pyplot_figure(obs_fire) gdd.add_extension(TrajectoryDisplayExtension, (None, )) gdd.draw_ignition_contour(geodata=ignitions, cmap=mcm.Greens) gdd.draw_ignition_shade() plot_plan_trajectories(search_result.final_plan(), gdd) print("fin") # TODO: Reconstruct fire perimeter from Obs fire # search_result = observation_planner.replan_after_time(later)