Add raster data

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
    // create a raster from a path to a supported raster format
    val rasterFilePath = getExternalFilesDir(null)?.path.toString() + File.separator + rasterFileName
    val raster = Raster.createWithPath(rasterFilePath)

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
        // Create a raster from a path to a supported raster format.
        val geoPackagePath =
            getExternalFilesDir(null)?.path.toString() + File.separator + getString(R.string.app_name) + File.separator + localGeoPackageName
        // open the GeoPackage
        val geoPackage = GeoPackage(geoPackagePath)
        lifecycleScope.launch {
            geoPackage.load().onSuccess {
                val geoPackageRasters = geoPackage.geoPackageRasters
                if (geoPackageRasters.isNotEmpty()) {
                    // Read raster images and get the first one.
                    val geoPackageRaster = geoPackageRasters[0]
                    // Create a layer to display the raster.
                    val rasterLayer = RasterLayer(geoPackageRaster)

                    // Add the raster layer to the mutable map's operational layers used by the MapView composable.
                    map.operationalLayers.add(rasterLayer)
                }
            }.onFailure { Log.e(localClassName, "Geopackage failed to load.") }

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
    // Get mosaic dataset names in the SQLite database.
    val sqliteDbPath = getExternalFilesDir(null)?.path.toString() + File.separator + sqliteDbName

    val rasterNames = MosaicDatasetRaster.getNames(sqliteDbPath)
    // check that the rasterNames list is not empty
    if (rasterNames.isNotEmpty()) {
        // Get the first raster name in the list rasterNames.
        val rasterName = rasterNames[0]
        // Create a raster from a mosaic dataset.
        val raster = MosaicDatasetRaster(sqliteDbPath, rasterName)

        // Create a raster layer using the raster.
        val rasterLayer = RasterLayer(raster)
        // Load the raster layer
        lifecycleScope.launch {
            rasterLayer.load().onSuccess {
                val extent = rasterLayer.fullExtent ?: return@launch showError("Error retrieving extent of the raster layer.")
                // use MapViewProxy operation to set the viewpoint
                mapViewProxy.setViewpoint(Viewpoint(extent))
            }.onFailure { showError("Raster layer failed to load.") }
        }
        // add the raster layer to the mutable map's operational layers
        map.operationalLayers.add(rasterLayer)
    }

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
        // create a raster from a path to a supported raster format
        val mosaicSqlitePath = getExternalFilesDir(null)?.path.toString() + File.separator + getString(R.string.app_name) + File.separator + "mosaic.sqlite"
        val mosaicDatasetRaster = MosaicDatasetRaster.create(mosaicSqlitePath, "Shashta", SpatialReference.webMercator())
        val pathToIncomingDataRasters = getExternalFilesDir(null)?.path.toString() + File.separator + getString(R.string.app_name) + File.separator + "raster-file"

        // Load the mosaic dataset raster
        lifecycleScope.launch {
            mosaicDatasetRaster.load().onSuccess {
                Log.i(localClassName, "Mobile mosaic dataset loaded successfully")
                val addRastersParameters = AddRastersParameters.create().apply {
                    inputDirectory = pathToIncomingDataRasters
                }
                mosaicDatasetRaster.addRasters(addRastersParameters).onSuccess {
                    // Create a raster layer with the mosaic dataset raster
                    val mosaicDatasetRasterLayer = RasterLayer(mosaicDatasetRaster)
                    mosaicDatasetRasterLayer.load().onSuccess {
                        // add the raster layer to the mutable map's operational layers
                        map.operationalLayers.add(mosaicDatasetRasterLayer)
                        // use MapViewProxy operation to set the viewpoint
                        mapViewProxy.setViewpoint(Viewpoint(40.750306470878606, -122.1600, 72000.0))

                    }.onFailure { Log.e(localClassName, "Mosaic dataset raster layer failed to load.") }
                }
            }.onFailure { Log.e(localClassName, "Mobile mosaic dataset failed to load.") }
        }

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
    // Create an image service raster from a URI
    val imageServiceURL = "https://sampleserver7.arcgisonline.com/server/rest/services/amberg_germany/ImageServer"
    val imageServiceRaster = ImageServiceRaster(imageServiceURL)

    // When the image service raster loads, the service info and rendering rule info will be available
    lifecycleScope.launch {
        // Load the service raster so you can get its list of rendering rule infos
        imageServiceRaster.load().onSuccess {

            // Get service info.
            val serviceInfo = imageServiceRaster.serviceInfo
            showError("imageServiceRaster.serviceInfo is: ${imageServiceRaster.serviceInfo}")

            // If using rendering rules: Access the list of available rendering rule info instances.
            serviceInfo?.renderingRuleInfos?.forEachIndexed { index, renderingRuleInfo ->
                var message ="renderingRuleInfos[$index].name is ${renderingRuleInfo.name}, and its "
                message += "description is: ${renderingRuleInfo.description}"
                showMessage(message)
            }
            // If using rendering rules: After you load an image service raster, you can access the list of
            // available rendering rules, but you cannot assign a rule to the loaded raster. To assign
            // one of the available rendering rules, create a new ImageServiceRaster instance and assign
            // the rule to the renderingRule property of the instance. Then create a raster layer from
            // that new image service raster.

            // Load the image service raster you just created
            val rasterLayer = RasterLayer(imageServiceRaster)

            // To add the raster layer to the map, call operationalLayers() on the
            // mutable map property used by the MapView composable.
            map.operationalLayers.add(rasterLayer)
            val viewpoint = Viewpoint(49.443589, 11.859372, 30000.0)
            // use MapViewProxy operation to set the viewpoint
            mapViewProxy.setViewpoint(viewpoint)
            }.onFailure { showError("serviceRaster failed to load.") } }

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
    // Create raster function from json string.
    // If RasterFunction.fromJson() returns null, then return from current function, showing error message.
    val hillsideRasterFunctionFromJson = RasterFunction.fromJsonOrNull(getString(R.string.hillshade_simplified))
        ?: return showError("Error creating raster function from Json file.")
    // Get parameter name value pairs used by hillside.
    val hillsideRasterFunctionArguments = hillsideRasterFunctionFromJson.arguments
    // Get a list of raster names associated with the raster function.
    val rasterNames = hillsideRasterFunctionArguments?.rasterNames
    // Set an existing raster as an argument to the raster function. This is the raster that will be
    // modified by the function.
    hillsideRasterFunctionArguments?.setRaster(rasterNames?.get(0).toString(), raster)

    // Create a Raster object for the modified raster returned by the raster function.
    // Then create a raster layer from it.
    val modifiedRaster = Raster.createWithRasterFunction(hillsideRasterFunctionFromJson)
    val hillshadeRasterLayer = RasterLayer(modifiedRaster)
    // add the layer to the mutable map's operational layers
    map.operationalLayers.add(hillshadeRasterLayer)

1
2
3
4
5
6
7
8
9
10
11
{
  "raster_function":{"type":"<Raster Function Name>"},
  "raster_function_arguments":
  {
    "argument1":"<JSON Value Object>",
    "argument2":"<JSON Value Object>",
    "argumentN":"<JSON Value Object>",
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
  "raster_function":{"type":"Clip_function"},
  "raster_function_arguments":
  {
    "minx":{"double":value,"type":"Raster_function_variable"},
    "miny":{"double":value,"type":"Raster_function_variable"},
    "maxx":{"double":value,"type":"Raster_function_variable"},
    "maxy":{"double":value,"type":"Raster_function_variable"},
    "dx":{"double":cell_size_x,"type":"Raster_function_variable"},
    "dy":{"double":cell_size_y,"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
{
  "raster_function":{"type":"Colormap_function"},
  "raster_function_arguments":
  {
    "raster_colormap":{"colors":[color1,color2,...,colorN],"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
{
  "raster_function":{"type":"Colormap_to_RGB_function"},
  "raster_function_arguments":
  {
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

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
{
  "raster_function":{"type":"Color_ramp_function"},
  "raster_function_arguments":
  {
    "resizable":{"bool":false,"type":"Raster_function_variable"},
    "color_ramp":
    {
      "color_ramp":
      {
        "ramps":
        [
         {"to_color":[0,255,0],"from_color":[0,191,191],"num_colors":3932,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"},
         {"to_color":[255,255,0],"from_color":[0,255,0],"num_colors":3932,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"},
         {"to_color":[255,127,0],"from_color":[255,255,0],"num_colors":3932,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"},
         {"to_color":[191,127,63],"from_color":[255,127,0],"num_colors":3932,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"},
         {"to_color":[20,20,20],"from_color":[191,127,63],"num_colors":3935,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"}
        ],
        "type":"Multipart_color_ramp"
      },
      "type":"Raster_function_variable"
    },
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
{
  "raster_function":{"type":"Composite_band_function"},
  "raster_function_arguments":
  {
    "raster_names":{"name":"raster_names","string_array":["r1","r2","r3","r4"],"type":"Raster_function_variable"},
    "r1":{"name":"r1","is_raster":true,"type":"Raster_function_variable"},
    "r2":{"name":"r2","is_raster":true,"type":"Raster_function_variable"},
    "r3":{"name":"r3","is_raster":true,"type":"Raster_function_variable"},
    "r4":{"name":"r4","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
11
{
  "raster_function":{"type":"Extract_band_function"},
  "raster_function_arguments":
  {
    "exact_match":{"bool":false,"type":"Raster_function_variable"},
    "band_indexes":{"int_array":[2,1,0],"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
11
12
{
  "raster_function":{"type":"Geometric_function"},
  "raster_function_arguments":
  {
    "raster_transform":{"raster_transform":"Raster Transform JSON object","type":"Raster_function_variable"},
    "z_offset":{"double":0,"type":"Raster_function_variable"},
    "z_factor":{"double":1,"type":"Raster_function_variable"},
    "raster":{"is_raster":true,"name":"raster","type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "raster_function":{"type":"Hillshade_function"},
  "raster_function_arguments":
  {
    "z_factor":{"double":0.0002,"type":"Raster_function_variable"},
    "slope_type":{"raster_slope_type":"none","type":"Raster_function_variable"},
    "azimuth":{"double":315,"type":"Raster_function_variable"},
    "altitude":{"double":45,"type":"Raster_function_variable"},
    "nbits":{"int":8,"type":"Raster_function_variable"}, // Number of bits per pixel for output raster
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
11
{
  "raster_function":{"type":"Mask_function"},
  "raster_function_arguments":
  {
    "nodata_values":{"double_array":[value1, value2, ..., valueN],"type":"Raster_function_variable"},
    "nodata_interpretation":{"nodata_interpretation":"all","type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
11
12
{
  "raster_function":{"type":"Pansharpen_function"},
  "raster_function_arguments":
  {
    "weights":{"double_array":[0.10000000000000001,0.5,0.40000000000000002,0.29999999999999999],"type":"Raster_function_variable"},
    "pansharpen_type":{"pansharpen_type":"gram_schmidt","type":"Raster_function_variable"},
    "pan_raster":{"name":"pan_raster","is_raster":true,"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
{
  "raster_function":{"type":"Raster_calculator_function"},
  "raster_function_arguments":
  {
    "expression":{"string":"r1 + r2","name":"expression","type":"Raster_function_variable"},
    "raster_names":{"name":"raster_names","type":"Raster_function_variable"},
    "raster_names":{"name":"raster_names","string_array":["r1","r2"],"type":"Raster_function_variable"},
    "r1":{"name":"r1","is_raster":true,"type":"Raster_function_variable"},
    "r2":{"name":"r2","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
{
  "raster_function":{"type":"Stretch_function"},
  "raster_function_arguments":
  {
    "stretch_type":{"raster_stretch_type":"minimum_maximum","type":"Raster_function_variable"},
    "min_values":{"double_array":[-10977],"type":"Raster_function_variable"},
    "max_values":{"double_array":[8685],"type":"Raster_function_variable"},
    "estimate_stats":{"bool":false,"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

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
    // create a raster layer using the raster
    val rasterLayer = RasterLayer(raster)
    lifecycleScope.launch {
        rasterLayer.load().onSuccess {
            // Create a basemap with the raster layer, and create a new map with that basemap.
            // Display the map by assigning it to the mutable map property used by the Composable MapView.
            map = ArcGISMap(Basemap(rasterLayer))

            // Alternatively, you could add the raster layer as an operational layer.
            // map.operationalLayers.add(rasterLayer)

        }.onFailure { Log.e(localClassName, "Raster layer failed to load.") }
    }