Perform spatial operations

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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
/*
 * Copyright 2020 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.performspatialoperations

import android.graphics.Color
import android.os.Bundle
import android.view.Menu
import android.view.MenuItem
import androidx.appcompat.app.AppCompatActivity
import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
import com.esri.arcgisruntime.geometry.Geometry
import com.esri.arcgisruntime.geometry.GeometryEngine
import com.esri.arcgisruntime.geometry.Part
import com.esri.arcgisruntime.geometry.PartCollection
import com.esri.arcgisruntime.geometry.Point
import com.esri.arcgisruntime.geometry.PointCollection
import com.esri.arcgisruntime.geometry.Polygon
import com.esri.arcgisruntime.geometry.SpatialReferences
import com.esri.arcgisruntime.mapping.ArcGISMap
import com.esri.arcgisruntime.mapping.BasemapStyle
import com.esri.arcgisruntime.mapping.view.Graphic
import com.esri.arcgisruntime.mapping.view.GraphicsOverlay
import com.esri.arcgisruntime.mapping.view.MapView
import com.esri.arcgisruntime.sample.performspatialoperations.databinding.ActivityMainBinding
import com.esri.arcgisruntime.symbology.SimpleFillSymbol
import com.esri.arcgisruntime.symbology.SimpleLineSymbol

class MainActivity : AppCompatActivity() {

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

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

    private val inputGeometryGraphicsOverlay: GraphicsOverlay by lazy { GraphicsOverlay() }
    private val resultGeometryGraphicsOverlay: GraphicsOverlay by lazy { GraphicsOverlay() }

    // simple black line symbol for outlines
    private val lineSymbol = SimpleLineSymbol(SimpleLineSymbol.Style.SOLID, Color.BLACK, 1f)
    private val resultFillSymbol = SimpleFillSymbol(
        SimpleFillSymbol.Style.SOLID, Color.RED, lineSymbol
    )
    private lateinit var inputPolygon1: Polygon
    private lateinit var inputPolygon2: Polygon

    // the spatial operation switching menu items.
    private var noOperationMenuItem: MenuItem? = null
    private var intersectionMenuItem: MenuItem? = null
    private var unionMenuItem: MenuItem? = null
    private var differenceMenuItem: MenuItem? = null
    private var symmetricDifferenceMenuItem: MenuItem? = null

    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)

        mapView.apply {
            // create an ArcGISMap with a light gray basemap
            map = ArcGISMap(BasemapStyle.ARCGIS_LIGHT_GRAY)

            // create graphics overlays to show the inputs and results of the spatial operation
            graphicsOverlays.add(inputGeometryGraphicsOverlay)
            graphicsOverlays.add(resultGeometryGraphicsOverlay)

        }

        // create input polygons and add graphics to display these polygons in an overlay
        createPolygons()

        // center the map view on the input geometries
        val envelope = GeometryEngine.union(inputPolygon1, inputPolygon2).extent
        mapView.setViewpointGeometryAsync(envelope, 20.0)
    }

    private fun showGeometry(resultGeometry: Geometry) {
        // add a graphic from the result geometry, showing result in red (0xFFE91F1F)
        val graphic = Graphic(resultGeometry, resultFillSymbol).also {
            // select the result to highlight it
            it.isSelected = true
        }

        resultGeometryGraphicsOverlay.graphics.add(graphic)
    }

    private fun createPolygons() {
        // create input polygon 1
        inputPolygon1 = Polygon(PointCollection(SpatialReferences.getWebMercator()).apply {
            add(Point(-13160.0, 6710100.0))
            add(Point(-13300.0, 6710500.0))
            add(Point(-13760.0, 6710730.0))
            add(Point(-14660.0, 6710000.0))
            add(Point(-13960.0, 6709400.0))

        })

        // create and add a blue graphic to show input polygon 1
        val blueFill = SimpleFillSymbol(SimpleFillSymbol.Style.SOLID, Color.BLUE, lineSymbol)
        inputGeometryGraphicsOverlay.graphics.add(Graphic(inputPolygon1, blueFill))

        // outer ring
        val outerRing = Part(PointCollection(SpatialReferences.getWebMercator()).apply {
            add(Point(-13060.0, 6711030.0))
            add(Point(-12160.0, 6710730.0))
            add(Point(-13160.0, 6709700.0))
            add(Point(-14560.0, 6710730.0))
            add(Point(-13060.0, 6711030.0))
        })

        // inner ring
        val innerRing = Part(PointCollection(SpatialReferences.getWebMercator()).apply {
            add(Point(-13060.0, 6710910.0))
            add(Point(-12450.0, 6710660.0))
            add(Point(-13160.0, 6709900.0))
            add(Point(-14160.0, 6710630.0))
            add(Point(-13060.0, 6710910.0))
        })

        // add both parts (rings) to a part collection and create a geometry from it
        PartCollection(outerRing).run {
            add(innerRing)
            inputPolygon2 = Polygon(this)
        }

        // create and add a green graphic to show input polygon 2
        val greenFill = SimpleFillSymbol(SimpleFillSymbol.Style.SOLID, Color.GREEN, lineSymbol)
        inputGeometryGraphicsOverlay.graphics.add(Graphic(inputPolygon2, greenFill))

    }

    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
        // inflate the menu; this adds items to the action bar if it is present.
        menuInflater.inflate(R.menu.menu_main, menu)

        // Get the menu items that perform spatial operations.
        noOperationMenuItem = menu?.getItem(0)
        intersectionMenuItem = menu?.getItem(1)
        unionMenuItem = menu?.getItem(2)
        differenceMenuItem = menu?.getItem(3)
        symmetricDifferenceMenuItem = menu?.getItem(4)

        // set the 'no-op' menu item checked by default
        noOperationMenuItem?.isChecked = true

        return true
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        // handle menu item selection
        val itemId = item.itemId

        // clear previous operation result
        resultGeometryGraphicsOverlay.graphics.clear()

        // perform spatial operations and add results as graphics, depending on the option selected
        when (itemId) {
            R.id.action_no_operation -> {
                // no spatial operation - graphics have been cleared previously
                noOperationMenuItem?.isChecked = true
                return true
            }
            R.id.action_intersection -> {
                intersectionMenuItem?.isChecked = true
                showGeometry(GeometryEngine.intersection(inputPolygon1, inputPolygon2))
                return true
            }
            R.id.action_union -> {
                unionMenuItem?.isChecked = true
                showGeometry(GeometryEngine.union(inputPolygon1, inputPolygon2))
                return true
            }
            R.id.action_difference -> {
                differenceMenuItem?.isChecked = true
                // note that the difference method gives different results depending on the order of input geometries
                showGeometry(GeometryEngine.difference(inputPolygon1, inputPolygon2))
                return true
            }
            R.id.action_symmetric_difference -> {
                symmetricDifferenceMenuItem?.isChecked = true
                showGeometry(GeometryEngine.symmetricDifference(inputPolygon1, inputPolygon2))
                return true
            }
            else -> {
                return super.onOptionsItemSelected(item)
            }
        }
    }

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

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

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