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
    // 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
    // create a raster from a path to a supported raster format
    val geoPackagePath = getExternalFilesDir(null)?.path.toString() + 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 ane get the first one
                val geoPackageRaster = geoPackageRasters[0]
                // create a layer to display the raster
                val rasterLayer = RasterLayer(geoPackageRaster)
                mapView.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
    // 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.")
                mapView.setViewpoint(Viewpoint(extent))
            }.onFailure { showError("Raster layer failed to load.") }
        }
        // Add the raster layer to the 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
    // create a raster from a path to a supported raster format
    val mosaicSqlitePath = getExternalFilesDir(null)?.path.toString() + File.separator + "mosaic.sqlite"
    val mosaicDatasetRaster = MosaicDatasetRaster.create(mosaicSqlitePath, "Shashta", SpatialReference.webMercator())
    val pathToIncomingDataRasters = getExternalFilesDir(null)?.path.toString() + 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 map's operational layers and set a viewpoint
                    mapView.map?.operationalLayers?.add(mosaicDatasetRasterLayer)
                    mapView.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
    // 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)

            mapView.map?.operationalLayers?.add(rasterLayer)
            val viewpoint = Viewpoint(49.443589, 11.859372, 30000.0)
            mapView.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
    // 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)
    mapView.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
    // create a raster layer using the raster
    val rasterLayer = RasterLayer(raster)
    lifecycleScope.launch {
        rasterLayer.load().onSuccess {
            // Create a basemap using the raster layer. Then pass the basemap to the ArcIGSMap constructor.
            val 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.") }
    }