Find closest facility sample (#88)

shokhinaToj · jenmerritt · web-flow · commit 6bd65966d44b · 2024-07-25T16:35:01.000-07:00
* Refactored the README and added comments to the code

* Apply suggestions from code review

Co-authored-by: Jen Merritt &lt;jmerritt@esri.com&gt;

* Adopted optimization changes

* Adopted changes

---------

Co-authored-by: Jen Merritt &lt;jmerritt@esri.com&gt;
diff --git a/lib/samples/find_closest_facility_from_point/README.md b/lib/samples/find_closest_facility_from_point/README.md
@@ -0,0 +1,39 @@
+# Find closest facility from point
+
+Find routes from several locations to the respective closest facility.
+
+![Image of find closest facility from point](find_closest_facility_from_point.png)
+
+## Use case
+
+Quickly and accurately determining the most efficient route between a location and a facility is a frequently encountered task. For example, a city's fire department may need to know which firestations in the vicinity offer the quickest routes to multiple fires. Solving for the closest fire station to the fire's location using an impedance of "travel time" would provide this information.
+
+## How to use the sample
+
+Tap on the 'Solve Routes' button to solve and display the route from each incident (fire) to the nearest facility (fire station).
+
+## How it works
+
+1. Create a `ClosestFacilityTask` using a URL from an online service.
+2. Create a `FeatureTable` for each of the `Facilities` and `Incidents` services using `ServiceFeatureTable.withUri(uri)`.
+3. Get the default set of `ClosestFacilityParameters` from the task using `ClosestFacilityTask.createDefaultParameters()`.
+4. Add the facilities table to the task parameters, along with `QueryParameters` defined to query all features using `ClosestFacilityParameters.setFacilitiesWithFeatureTable(featureTable, queryParameters)`.
+5. Add the incidents table to the task parameters, along with `QueryParameters` defined to query all features using `ClosestFacilityParameters.setIncidentsWithFeatureTable(featureTable, queryParameters)`.
+6. Get the `ClosestFacilityResult` by solving the task with the provided parameters: `ClosestFacilityTask.solveClosestFacility(closestFacilityParameters)`.
+7. Find the closest facility for each incident by iterating over the list of `result.incidents`.
+8. Display the route as a `Graphic` using the `routeGraphicsOverlay.graphics.add(routeGraphic)`.
+
+## Relevant API
+
+* ClosestFacilityParameters
+* ClosestFacilityResult
+* ClosestFacilityRoute
+* ClosestFacilityTask
+* Facility
+* Graphic
+* GraphicsOverlay
+* Incident
+
+## Tags
+
+incident, network analysis, route, search
diff --git a/lib/samples/find_closest_facility_from_point/README.metadata.json b/lib/samples/find_closest_facility_from_point/README.metadata.json
@@ -2,10 +2,36 @@
     "category": "Routing and Logistics",
     "description": "Find routes from several locations to the respective closest facility.",
     "ignore": false,
-    "images": [],
-    "keywords": [],
+    "images": [
+        "find_closest_facility_from_point.png"
+    ],
+    "keywords": [
+        "incident",
+        "network analysis",
+        "route",
+        "search",
+        "ClosestFacilityParameters",
+        "ClosestFacilityResult",
+        "ClosestFacilityRoute",
+        "ClosestFacilityTask",
+        "Facility",
+        "Graphic",
+        "GraphicsOverlay",
+        "Incident"
+    ],
     "redirect_from": [],
-    "relevant_apis": [],
-    "snippets": [],
+    "relevant_apis": [
+        "ClosestFacilityParameters",
+        "ClosestFacilityResult",
+        "ClosestFacilityRoute",
+        "ClosestFacilityTask",
+        "Facility",
+        "Graphic",
+        "GraphicsOverlay",
+        "Incident"
+    ],
+    "snippets": [
+        "find_closest_facility_from_point_sample.dart"
+    ],
     "title": "Find closest facility from point"
 }
diff --git a/lib/samples/find_closest_facility_from_point/find_closest_facility_from_point.png b/lib/samples/find_closest_facility_from_point/find_closest_facility_from_point.png
diff --git a/lib/samples/find_closest_facility_from_point/find_closest_facility_from_point_sample.dart b/lib/samples/find_closest_facility_from_point/find_closest_facility_from_point_sample.dart
@@ -29,6 +29,7 @@ class FindClosestFacilityFromPointSample extends StatefulWidget {
 
 class _FindClosestFacilityFromPointSampleState
     extends State<FindClosestFacilityFromPointSample> with SampleStateSupport {
+  // Create the URIs for the fire station and fire images, as well as the URIs for the facilities and incidents layers.
   static final _fireStationImageUri = Uri.parse(
       'https://static.arcgis.com/images/Symbols/SafetyHealth/FireStation.png');
   static final _fireImageUri = Uri.parse(
@@ -37,46 +38,63 @@ class _FindClosestFacilityFromPointSampleState
       'https://services2.arcgis.com/ZQgQTuoyBrtmoGdP/ArcGIS/rest/services/San_Diego_Facilities/FeatureServer/0');
   static final _incidentsLayerUri = Uri.parse(
       'https://services2.arcgis.com/ZQgQTuoyBrtmoGdP/ArcGIS/rest/services/San_Diego_Incidents/FeatureServer/0');
+  // Create a task for the closest facility service.
   final _closestFacilityTask = ClosestFacilityTask.withUrl(Uri.parse(
       'https://sampleserver6.arcgisonline.com/arcgis/rest/services/NetworkAnalysis/SanDiego/NAServer/ClosestFacility'));
-
+  // Create a controller for the map view.
   final _mapViewController = ArcGISMapView.createController();
+  // Create a graphics overlay for the route.
   final _routeGraphicsOverlay = GraphicsOverlay();
-  bool _isRouteSolved = false;
-  bool _isInitialized = false;
+  // Create a flag to track whether the route has been solved.
+  var _routeSolved = false;
+  // A flag for when the map view is ready and controls can be used.
+  var _ready = false;
+  // Create parameters for the closest facility task.
   late final ClosestFacilityParameters _closestFacilityParameters;
+  // Create a symbol for the route line.
   final _routeLineSymbol = SimpleLineSymbol(
       style: SimpleLineSymbolStyle.solid, color: Colors.blue, width: 5.0);
 
   @override
   Widget build(BuildContext context) {
     return Scaffold(
       body: SafeArea(
-        child: Column(
+        top: false,
+        child: Stack(
           children: [
-            Expanded(
-              child: ArcGISMapView(
-                controllerProvider: () => _mapViewController,
-                onMapViewReady: onMapViewReady,
-              ),
-            ),
-            SizedBox(
-              height: 60,
-              child: Row(
-                crossAxisAlignment: CrossAxisAlignment.center,
-                mainAxisAlignment: MainAxisAlignment.spaceEvenly,
-                children: [
-                  ElevatedButton(
-                    onPressed: !_isRouteSolved && _isInitialized
-                        ? () => solveRoutes()
-                        : null,
-                    child: const Text('Solve Routes'),
+            Column(
+              children: [
+                Expanded(
+                  // Add a map view to the widget tree and set a controller.
+                  child: ArcGISMapView(
+                    controllerProvider: () => _mapViewController,
+                    onMapViewReady: onMapViewReady,
                   ),
-                  ElevatedButton(
-                    onPressed: _isRouteSolved ? () => resetRoutes() : null,
-                    child: const Text('Reset'),
-                  ),
-                ],
+                ),
+                Row(
+                  mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+                  children: [
+                    // Create buttons to solve the routes and reset the graphics.
+                    ElevatedButton(
+                      onPressed: !_routeSolved ? solveRoutes : null,
+                      child: const Text('Solve Routes'),
+                    ),
+                    ElevatedButton(
+                      onPressed: _routeSolved ? resetRoutes : null,
+                      child: const Text('Reset'),
+                    ),
+                  ],
+                ),
+              ],
+            ),
+            // Display a progress indicator and prevent interaction until state is ready.
+            Visibility(
+              visible: !_ready,
+              child: SizedBox.expand(
+                child: Container(
+                  color: Colors.white30,
+                  child: const Center(child: CircularProgressIndicator()),
+                ),
               ),
             ),
           ],
@@ -85,16 +103,41 @@ class _FindClosestFacilityFromPointSampleState
     );
   }
 
-  Future<void> onMapViewReady() async {
+  void onMapViewReady() async {
+    // Create a map with the ArcGIS Streets basemap style.
     final map = ArcGISMap.withBasemapStyle(BasemapStyle.arcGISStreets);
 
+    // Create feature table for the facilities layer.
+    final facilitiesFeatureTable =
+        ServiceFeatureTable.withUri(_facilitiesLayerUri);
+    // Create a marker symbol for the facilities.
+    final facilitiesMarkerSymbol =
+        PictureMarkerSymbol.withUrl(_fireStationImageUri)
+          ..width = 30
+          ..height = 30;
+    // Create a feature layer for the facilities.
     final facilitiesLayer =
-        buildFeatureLayer(_facilitiesLayerUri, _fireStationImageUri);
-    final incidentsLayer = buildFeatureLayer(_incidentsLayerUri, _fireImageUri);
+        FeatureLayer.withFeatureTable(facilitiesFeatureTable)
+          ..renderer = SimpleRenderer(symbol: facilitiesMarkerSymbol);
+
+    // Create feature table for the incidents layer.
+    final incidentsFeatureTable =
+        ServiceFeatureTable.withUri(_incidentsLayerUri);
+    // Create a marker symbol for the incidents.
+    final incidentsMarkerSymbol = PictureMarkerSymbol.withUrl(_fireImageUri)
+      ..width = 30
+      ..height = 30;
+    // Create a feature layer for the incidents.
+    final incidentsLayer = FeatureLayer.withFeatureTable(incidentsFeatureTable)
+      ..renderer = SimpleRenderer(symbol: incidentsMarkerSymbol);
+
+    // Add the layers to the map.
     map.operationalLayers.addAll([facilitiesLayer, incidentsLayer]);
 
+    // Set the map on the map view controller.
     _mapViewController.arcGISMap = map;
 
+    // Add the route graphics overlay to the map view controller.
     _routeGraphicsOverlay.opacity = 0.75;
     _mapViewController.graphicsOverlays.add(_routeGraphicsOverlay);
 
@@ -104,80 +147,92 @@ class _FindClosestFacilityFromPointSampleState
       incidentsLayer.load(),
     ]);
 
-    // Get the extent from the layers and use the combination as the viewpoint geometry
+    // Get the extent from the layers and use the combination as the viewpoint geometry.
     final mapExtent = GeometryEngine.combineExtents(
       geometry1: facilitiesLayer.fullExtent!,
       geometry2: incidentsLayer.fullExtent!,
     );
 
+    // Set the viewpoint geometry on the map view controller.
     _mapViewController.setViewpointGeometry(mapExtent, paddingInDiPs: 30);
 
+    // Generate the closest facility parameters.
     _closestFacilityParameters = await generateClosestFacilityParameters(
-        facilitiesLayer, incidentsLayer);
+        facilitiesFeatureTable, incidentsFeatureTable);
 
-    setState(() => _isInitialized = true);
+    // Set the initialized flag to true.
+    setState(() => _ready = true);
   }
 
   FeatureLayer buildFeatureLayer(Uri tableUri, Uri imageUri) {
+    // Create a feature table and feature layer for the facilities or incidents.
     final featureTable = ServiceFeatureTable.withUri(tableUri);
-    final featureLayer = FeatureLayer.withFeatureTable(featureTable);
-    final markerSymbol = PictureMarkerSymbol.withUrl(imageUri);
-    markerSymbol.width = 30;
-    markerSymbol.height = 30;
-    featureLayer.renderer = SimpleRenderer(symbol: markerSymbol);
+    final markerSymbol = PictureMarkerSymbol.withUrl(imageUri)
+      ..width = 30
+      ..height = 30;
+    final featureLayer = FeatureLayer.withFeatureTable(featureTable)
+      ..renderer = SimpleRenderer(symbol: markerSymbol);
 
     return featureLayer;
   }
 
   Future<ClosestFacilityParameters> generateClosestFacilityParameters(
-      FeatureLayer facilitiesLayer, FeatureLayer incidentsLayer) async {
+      FeatureTable facilitiesFeatureTable,
+      FeatureTable incidentsFeatureTable) async {
+    // Create query parameters to get all features.
     final featureQueryParams = QueryParameters()..whereClause = '1=1';
-
-    final parameters = await _closestFacilityTask.createDefaultParameters();
-    parameters.setFacilitiesWithFeatureTable(
-      featureTable: facilitiesLayer.featureTable! as ArcGISFeatureTable,
-      queryParameters: featureQueryParams,
-    );
-    parameters.setIncidentsWithFeatureTable(
-      featureTable: incidentsLayer.featureTable! as ArcGISFeatureTable,
-      queryParameters: featureQueryParams,
-    );
+    // Create default parameters for the closest facility task.
+    final parameters = await _closestFacilityTask.createDefaultParameters()
+      ..setFacilitiesWithFeatureTable(
+        featureTable: facilitiesFeatureTable as ArcGISFeatureTable,
+        queryParameters: featureQueryParams,
+      )
+      ..setIncidentsWithFeatureTable(
+        featureTable: incidentsFeatureTable as ArcGISFeatureTable,
+        queryParameters: featureQueryParams,
+      );
 
     return parameters;
   }
 
-  Future<void> solveRoutes() async {
-    final results = await _closestFacilityTask.solveClosestFacility(
-      closestFacilityParameters: _closestFacilityParameters,
-    );
-
+  void solveRoutes() async {
+    setState(() => _ready = false);
+    // Solve the closest facility task with the parameters.
+    final result = await _closestFacilityTask.solveClosestFacility(
+        closestFacilityParameters: _closestFacilityParameters);
     for (var incidentIdx = 0;
-        incidentIdx < results.incidents.length;
+        incidentIdx < result.incidents.length;
         ++incidentIdx) {
       final rankedFacilities =
-          results.getRankedFacilityIndexes(incidentIndex: incidentIdx);
+          result.getRankedFacilityIndexes(incidentIndex: incidentIdx);
       if (rankedFacilities.isEmpty) {
         continue;
       }
 
+      // Get the route to the closest facility.
       final closestFacilityIdx = rankedFacilities.first;
-      final routeToFacility = results.getRoute(
+      final routeToFacility = result.getRoute(
         facilityIndex: closestFacilityIdx,
         incidentIndex: incidentIdx,
       );
+      // Add the route to the graphics overlay.
       if (routeToFacility != null) {
         final routeGraphic = Graphic(
-          geometry: routeToFacility.routeGeometry,
-          symbol: _routeLineSymbol,
-        );
+            geometry: routeToFacility.routeGeometry, symbol: _routeLineSymbol);
         _routeGraphicsOverlay.graphics.add(routeGraphic);
       }
     }
-    setState(() => _isRouteSolved = true);
+
+    // Set the route solved flag to true.
+    setState(() {
+      _ready = true;
+      _routeSolved = true;
+    });
   }
 
   void resetRoutes() {
+    // Clear the graphics overlay and set the route solved flag to false.
     _routeGraphicsOverlay.graphics.clear();
-    setState(() => _isRouteSolved = false);
+    setState(() => _routeSolved = false);
   }
 }
