Indoor positioning

ArcGIS IPS is an indoor positioning system that allows you to locate yourself and others inside a building in real time. Similar to GPS, it puts a blue dot on indoor maps and uses location services to help you navigate to any point of interest or destination.

ArcGIS IPS supports:

• Real-time indoor wayfinding
• Real-time indoors location tracking and sharing
• Real-time indoor location data collection
• Indoor analytics

Your app can work with ArcGIS IPS to show device location using an indoor location data source.

How ArcGIS IPS works

ArcGIS IPS provides geoprocessing tools for setting up and authoring your IPS environment in ArcGIS Pro. It also includes ArcGIS Setup, a mobile app to collect radio signals from Bluetooth Low Energy (BLE) Beacons inside your building(s) to enable the indoor positioning system. It can make use of an existing or new beacon infrastructure and is beacon vendor agnostic.

See Get started with ArcGIS IPS in the ArcGIS Pro documentation for detailed instructions for setting up an indoor positioning system.

Floor-aware maps

ArcGIS Setup supports two types of floor-aware maps:

• ArcGIS Indoors floor-aware maps created according to the ArcGIS IPS Information Model.
• ArcGIS IPS floor-aware maps created using the guidelines described in the ArcGIS Pro Create floor plan data topic. Creating this type of floor-aware map does not require an ArcGIS Indoors license.

The ArcGIS Setup app automatically displays a floor picker when one of the two supported floor-aware maps is used. The floor picker is a custom component that you might want to implement in your own app. For an ArcGIS Indoors map, you can use the FloorManager class to expose available sites, facilities, and levels in your floor picker. For an ArcGIS IPS map, you'll need to also implement a custom floor manager component to manage those datasets in a floor picker.

IPS positioning table

An IPS positioning feature table is stored with an IPS-enabled map. Each row in the table contains an indoor positioning file. The positioning file is created when setting up the IPS environment using the Generate positioning file geoprocessing tool. The tool processes one or more indoor surveys and creates a new row in the IPS positioning table with the positioning file (as an attachment) along with the date and time it was created. When working with an indoor location source in your app, the most recent positioning file is used unless you specify a different one, as described in the following section.

Indoor location data source

Your app can work with indoor positioning by using a location data source and the geoview's location display. The basics are the same as working with any other LocationDataSource. The IndoorsLocationDataSource wraps the logic to find location using an indoor positioning file, Bluetooth signals, and information from device sensors. The IndoorsLocationDataSource provides the geographic location along with other metadata, such as the floor.

To work with ArcGIS IPS, the constructor for the IndoorsLocationDataSource requires an IPS positioning table. Optionally, you can provide the following.

• Row ID: A globally unique ID that identifies a row in the IPS positioning table. The positioning file associated with this row will be used to find indoor locations. If not specified in the constructor, the positioning file from the most recent survey is used.

• Pathways table: An ArcGISFeatureTable with line features that represent paths through the indoor space. Locations provided by the IndoorsLocationDataSource are snapped to the lines in this feature class.

  In the image below, the red + represents raw locations determined by the IPS. These locations are snapped to the nearest line feature in the pathways feature table before being displayed. This provides a more consistent display of the blue dot as it moves across the map.

  

You can handle a status changed event for the IndoorsLocationDataSource to be notified when the location data source starts, stops, or fails to start.

Caching the positioning file

Upon creation, an IndoorsLocationDataSource caches its positioning file on the device. The next time an indoors location data source is created for the same positioning table, the cached version of the file will be used under any of these circumstances:

• The cached positioning file is requested in the constructor (by row ID).
• A row ID isn't provided in the constructor and the cached positioning file is determined to be the most recent one available.
• No internet connection is available.

Handle location change

You can handle the location changed event for the IndoorsLocationDataSource to read information about the current Location.

An IPS location populates additional properties with the current floor and the transmitter (beacon) count. When the floor changes, you can update the map to filter the display of features for the current floor. The floor value returned with the location is an integer that represents the vertical offset, where 0 is the ground floor. This value increases by one for each floor above the ground floor and decreases by one for each floor below.

Use code like the following to read additional properties for the location when it changes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
        let additionalSourceProperties = location.additionalSourceProperties
        let floor = additionalSourceProperties[.floor] as? Int
        let positionSource = additionalSourceProperties[.positionSource]
        let satelliteCount = additionalSourceProperties[.satelliteCount]

In addition to getting the floor, you can get the position source, which will be BLE (Bluetooth Low Energy) when using IPS and GNSS (Global Navigation Satellite Systems) when using GPS. You can also get the count of transmitters (beacons) or satellites used to determine the location.

You can use a definition expression to filter layers in the map to only show features for the current floor. For efficiency, you should only filter features when the floor changes rather than with each location update. Depending on the schema for your floor-aware data, you may need to map the vertical offset value to a level ID in order to filter features by floor (level).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
        guard let featureLayers = map.operationalLayers.filter({ $0 is FeatureLayer }) as? [FeatureLayer] else { return }
        featureLayers.forEach { featureLayer in
            featureLayer.definitionExpression = "VERTICAL_ORDER = \(currentFloor)"
        }

Examples

1
2
3
4
<key>NSBluetoothAlwaysUsageDescription</key>
<string>Bluetooth access is required for indoor positioning</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>Location services are required for GNSS positioning</string>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
    let pathwaysTableName = "ips_positioning"
    let positioningTable = ServiceFeatureTable(url: URL(string: "Your-feature-table")!)

    // Queries the ID that identifies a row in the positioning table. IndoorsLocationDataSource can be initialized without a row ID.
    func queryGlobalID(positioningTable: ServiceFeatureTable) async throws -> UUID? {
        let queryParameters = QueryParameters()
        let result = try await positioningTable.queryFeatures(using: queryParameters)
        let feature = result.features().makeIterator().next()
        return feature?.attributes[positioningTable.globalIDField] as? UUID
    }

    func fetchPathwayTable(map: Map) -> ArcGISFeatureTable? {
        let featureLayers = map.operationalLayers
        let pathwayLayer = featureLayers.first { $0.name == pathwaysTableName } as? FeatureLayer
        return pathwayLayer?.featureTable as? ArcGISFeatureTable
    }

    // Makes an indoor location display.
    func makeLocationDisplay(positioningTable: FeatureTable, pathwaysTable: ArcGISFeatureTable, globalID: UUID) -> LocationDisplay {
        // Setting up IndoorsLocationDataSource with positioning, pathways tables and positioning ID.
        // positioningTable - the "ips_positioning" feature table from IPS-enabled map.
        // pathwaysTable - An ArcGISFeatureTable that contains pathways as per the ArcGIS Indoors Information Model.
        // Setting this property enables path snapping of locations provided by the IndoorsLocationDataSource.
        // positioningID - an ID which identifies a specific row in the positioningTable that should be used for setting up IPS.
        let indoorLocationDataSource = IndoorsLocationDataSource(positioningTable: positioningTable, pathwaysTable: pathwaysTable, positioningID: globalID)
        let locationDisplay = LocationDisplay(dataSource: indoorLocationDataSource)
        locationDisplay.autoPanMode = .compassNavigation
        return locationDisplay
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
    // A web map of the Esri campus with indoor positioning data.
    @State private var map: Map = {
        let item = PortalItem(
            portal: .arcGISOnline(connection: .anonymous),
            id: Item.ID("5e32d088d01c4fbcb359fef5504da0ec")!
        )
        let map = Map(item: item)
        return map
    }()

    /// A location display using the system location data source.
    @State private var indoorLocationDisplay = LocationDisplay(dataSource: SystemLocationDataSource())
    var body: some View {
        MapView(map: map)
            .locationDisplay(indoorLocationDisplay)
            .task {
                do {
                    if let pathwaysTable = fetchPathwayTable(map: map),
                       let globalID = try await queryGlobalID(positioningTable: positioningTable) {
                        indoorLocationDisplay = makeLocationDisplay(positioningTable: positioningTable, pathwaysTable: pathwaysTable, globalID: globalID)
                        // Start the map view's location display.
                        try await indoorLocationDisplay.dataSource.start()
                    }
                } catch {
                    print("Error starting location display.")
                }
            }
    }