Display electronic navigational charts

Electronic navigational chart (ENC) datasets are georeferenced vector datasets for the visualization and analysis of hydrographic and maritime information. This SDK supports ENC datasets conforming to the International Hydrographic Organization (IHO) standard S-57 (Transfer Standard for Digital Hydrographic Data).

Use ENCs in your apps to:

• Visualize S-57 data in compliance with S-52 standards and specifications for chart content display.

• Use S-57 data as an additional data source for situational awareness and decision making.

• Combine S-57 datasets with other sources of information for geospatial analysis.

Get started

Before ENC data can be displayed in an application, you must add code to:

• Set the path to the resource directory that contains the styles required to render the ENC data. The directory contents is available on the downloads page.
• Set a location for the SENC data. The first time that ENC data is displayed it is processed and placed into the SENC directory. Subsequent displays of the ENC data will be faster because the data is already processed and is read directly from the SENC directory.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
    EncEnvironmentSettings.apply {

        // set the path to the folder containing hydrography resources
        resourcePath = getExternalFilesDir(null)?.path + File.separator + getString(R.string.hydrography_directory)
        // use the app's cache to store processed System Electronic Navigational Chart (SENC) data
        sencDataPath = externalCacheDir?.path

    }

Understand electronic navigational charts (ENCs)

An ENC cell represents a navigational chart of a rectangular geographic area at a particular scale. Cells are bounded by meridians and parallels, though the actual area of coverage contained in the cell may be any shape. All the data in a single cell corresponds to a single navigational use, such as: overview, general, or coastal (a navigational use corresponds to a scale range suitable for a particular use).

Cells are stored in a single base dataset file and zero or more update dataset files. Each dataset file has a unique name. A base dataset file plus its update files (if any) when loaded together comprise the updated geographic data of one cell.

ENC data is distributed in exchange sets, which can contain many cells. On the file system, each exchange set resides in its own folder named ENC_ROOT. Each ENC_ROOT folder contains a collection of dataset files (*.000), update files (.001-.999), a catalog file containing metadata about the exchange set (CATALOG.031), and other optional files with data referenced by the exchange set, such as text and image files.

See S-57 Appendix B for additional details about S-57 ENC exchange sets and their content.

Display an electronic navigational chart

Access an exchange set on the file system using an EncExchangeSet object. An exchange set can be loaded using the path to the exchange set CATALOG.031 file, and optionally the paths to CATALOG.031 files for other exchange sets (in other directories) that contain additional update dataset files. If one of the datasets specified is an exchange set that contains only updates, then the exchange set with the corresponding base dataset files must be loaded in the same API call. See the Work with updates section for more information.

EncDataset objects represent datasets. Each EncDataset contains the base data for a cell and any updates that were also loaded when the exchange set was loaded, and provides access to metadata about the cell. Retrieve a collection of EncDataset objects contained in an EncExchangeSet using the datasets property.

ENC cells (individual charts) are represented by EncCell objects. You can construct these objects in two ways:

• From a dataset represented by an EncDataset object. This approach will include the base dataset file and all corresponding update dataset files. This is the preferred approach.
• From a base dataset file. This approach will only include the base dataset file, and not any corresponding update dataset files. This is not a typical use case.

Display an ENC cell by constructing an EncLayer object from an EncCell object. EncLayer is derived from Layer, so you add an EncLayer to a map like you do other layers.

You can add all the charts in the exchange set by iterating through the exchange set's datasets, creating an EncCell for each, creating an EncLayer for each EncCell, and adding each EncLayer to the map.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
    // create the Exchange Set
    val encExchangeSet = EncExchangeSet(listOf(encPath))
    // load the exchange set
    lifecycleScope.launch {
        encExchangeSet.load()
            .onFailure { error -> showError("Error loading ENC exchange set: ${error.message}", error) }
            .onSuccess {

                //loop through the datasets and add to the map
                encExchangeSet.datasets.forEach { encDataset ->
                    // create an ENC layer with an ENC cell using the dataset
                    val encLayer = EncLayer(EncCell(encDataset))
                    encLayer.load()
                        .onFailure { error -> showError("Error loading ENC layer: ${error.message}") }
                        .onSuccess {
                            // add ENC layer to the map's operational layers
                            mapView.map?.operationalLayers?.add(encLayer)

                        }

                }

            }
    }

Work with updates

ENC charts are often distributed as base cells (.000 files) with one or more update cells (.001, .002, etc. files). An exchange set can consist exclusively of update cells; in order to load an update exchange set, the path to the base exchange set must be provided along with the path to the update exchange set.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
    val encExchangeSetUpdate = EncExchangeSet(listOf("path/to/update", "path/to/original"))

When loading an ENC cell, it is important to use the dataset-based constructor. If updates for a cell are part of an exchange set, they will be found only when the dataset-based constructor is used. Loading the cell from a path will not load any associated updates.

Set ENC environment settings

ENC layers are displayed in accordance with the IHO standard S-52 (Specifications for Chart Content and Display Aspects of ECDIS). You can define the display properties of your ENC layers by using the static EncEnvironmentSettings class. These settings apply to all ENC layers in all maps. Settings fall under three categories: mariner settings, text group visibility settings, and viewing group settings. Text group settings control the display of labels for features, mariner settings control the symbolization and presentation of ENC features, and viewing group settings allow for quickly applying settings to logical groups of feature types.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
    displaySettings.textGroupVisibilitySettings.includeNatureOfSeabed = true

ENC content is accessed via compiled SENC (System Electronic Navigational Chart) files. After an ENC cell has been loaded, all future loads of that cell will reference the underlying SENC file directly. You can use the environment settings to find or set the location where SENC files are stored.

Identify and select ENC features

ENC layers support identify through the common geoview feature identification mechanism, which takes a screen point and tolerance in pixels. Identify will return a collection of result objects, one per matching layer. For ENC layers, the results will have a geoElements property, which provides a collection of EncFeature objects.

Once a feature has been identified, you can call selectFeature() on the layer that contains the feature to select it.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
    private suspend fun identifyEncFeatures(screenCoordinate: ScreenCoordinate) {
        // perform an identify operation on the map
        val identifyLayerResults = mapView.identifyLayers(screenCoordinate, 25.0, false)
        // get the identify results
        identifyLayerResults
            .onFailure { showError("Error identifying ENC layers: ${it.message}") }
            .onSuccess { identifyLayerResults ->
                identifyLayerResults.forEach { identifyLayerResult ->
                    // get the enc features
                    val encFeatures = identifyLayerResult.geoElements.filterIsInstance<EncFeature>()
                    encFeatures.forEach { encFeature ->
                        // select the enc feature
                        val encLayer = identifyLayerResult.layerContent as EncLayer
                        encLayer.selectFeature(encFeature)
                    }
                }
            }
    }

Performance considerations

ENC content is accesed via internal SENC files. When an ENC cell is loaded, an SENC representation is generated. Subsequent loads only read the generated SENC files. When developing apps for working with ENC content, understand that:

• The SENC data path must be set before attempting to read ENC content.

• SENC files are device and version specific. These files should not be exposed to users, backed up, or shared between devices. The SENC format is internal and may change between versions of ArcGIS Maps SDK for Kotlin. Therefore, SENC files created by an app built with one version of the SDK are not guaranteed to work with apps built with another version of the SDK, even on the same device.

  • See the Android Developers topic for more information about excluding directories from backup on Android.

• SENC files take time to generate, this will delay the loading of new ENC cells. It may take a long time to load large ENC exchange sets consisting of many cells (potentially hours). Never block the UI when loading these files.

• Because the initial load of an ENC cell (before the SENC files have been generated) can take some time to complete, consider pre-loading them to ensure availability before depending on them for navigation.

• Do not attempt to read or manipulate SENC files. Changes to generated SENC files invalidate them. This requires the files to be re-generated the next time the corresponding cells are loaded.