Raster rendering rule

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
/* Copyright 2017 Esri
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package com.esri.arcgisruntime.sample.rasterrenderingrule

import android.os.Bundle
import android.util.Log
import android.view.View
import android.widget.AdapterView
import android.widget.ArrayAdapter
import android.widget.Spinner
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
import com.esri.arcgisruntime.layers.RasterLayer
import com.esri.arcgisruntime.loadable.LoadStatus
import com.esri.arcgisruntime.mapping.ArcGISMap
import com.esri.arcgisruntime.mapping.BasemapStyle
import com.esri.arcgisruntime.mapping.view.MapView
import com.esri.arcgisruntime.raster.ImageServiceRaster
import com.esri.arcgisruntime.raster.RenderingRule
import com.esri.arcgisruntime.sample.rasterrenderingrule.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {

    private val TAG = this::class.java.simpleName

    private val activityMainBinding by lazy {
        ActivityMainBinding.inflate(layoutInflater)
    }

    private val mapView: MapView by lazy {
        activityMainBinding.mapView
    }

    private val spinner: Spinner by lazy {
        activityMainBinding.spinner
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(activityMainBinding.root)

        // authentication with an API key or named user is required to access basemaps and other
        // location services
        ArcGISRuntimeEnvironment.setApiKey(BuildConfig.API_KEY)

        // create image service raster as raster layer and add to map
        val imageServiceRaster = ImageServiceRaster(getString(R.string.image_service_url))
        val imageRasterLayer = RasterLayer(imageServiceRaster)

        // create a Streets BaseMap
        val map = ArcGISMap(BasemapStyle.ARCGIS_STREETS).apply {
            operationalLayers.add(imageRasterLayer)
        }

        // set the map to be displayed in this view
        mapView.map = map

        val renderRulesList = mutableListOf<String>()
        val spinnerAdapter =
            ArrayAdapter(this, android.R.layout.simple_list_item_1, renderRulesList)
        spinner.adapter = spinnerAdapter
        // zoom to the extent of the raster service
        imageRasterLayer.addDoneLoadingListener {
            if (imageRasterLayer.loadStatus == LoadStatus.LOADED) {
                // zoom to extent of raster
                mapView.setViewpointGeometryAsync(imageServiceRaster.serviceInfo.fullExtent)
                // get the predefined rendering rules and add to spinner
                val renderingRuleInfos = imageServiceRaster.serviceInfo.renderingRuleInfos
                for (renderRuleInfo in renderingRuleInfos) {
                    val renderingRuleName = renderRuleInfo.name
                    renderRulesList.add(renderingRuleName)
                    // update array adapter with list update
                    spinnerAdapter.notifyDataSetChanged()
                }
            } else {
                val error = "Error loading raster: " + imageRasterLayer.loadError.message
                Log.e(TAG, error)
                Toast.makeText(this, error, Toast.LENGTH_LONG).show()
            }
        }

        // listen to the spinner
        spinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
            override fun onNothingSelected(parent: AdapterView<*>?) {}

            override fun onItemSelected(
                parent: AdapterView<*>?,
                view: View?,
                position: Int,
                id: Long
            ) =
                applyRenderingRule(imageServiceRaster, position)
        }
    }

    /**
     * Apply a rendering rule on a Raster and add it to the map
     *
     * @param imageServiceRaster image service raster to apply rendering on
     * @param index spinner selected position representing the rule to apply
     */
    fun applyRenderingRule(imageServiceRaster: ImageServiceRaster, index: Int) {

        // get the rendering rule info at the selected index
        val renderRuleInfo = imageServiceRaster.serviceInfo.renderingRuleInfos[index]
        // create a rendering rule object using the rendering rule info
        val renderingRule = RenderingRule(renderRuleInfo)
        // create a new image service raster
        val appliedImageServiceRaster = ImageServiceRaster(getString(R.string.image_service_url))
        // apply the rendering rule
        appliedImageServiceRaster.renderingRule = renderingRule
        // create a raster layer using the image service raster
        val rasterLayer = RasterLayer(appliedImageServiceRaster)

        mapView.map.operationalLayers.let {
            // clear all rasters
            it.clear()
            // add the raster layer to the map
            it.add(rasterLayer)
        }
    }

    override fun onPause() {
        mapView.pause()
        super.onPause()
    }

    override fun onResume() {
        super.onResume()
        mapView.resume()
    }

    override fun onDestroy() {
        mapView.dispose()
        super.onDestroy()
    }
}