Display a viewshed

Learn how to perform and display a viewshed analysis in a 3D scene.

display a viewshed

Viewshed analysis determines the visibility of terrain, buildings, and other 3D objects from an observer's location within a scene (using a specified field of view). The result indicates which areas are visible and which are obstructed when viewed from the observer's perspective.

In this tutorial, you will perform and display a viewshed analysis in a web scene. Your viewshed analysis will show visibility (visible or obstructed) and can be used to determine which hotspots in the Yosemite Valley are visible from a specified observer's perspective.

Prerequisites

The following are required for this tutorial:

  1. An ArcGIS account to access your API keys. If you don't have an account, sign up for free.
  2. Your system meets the system requirements.
  3. The ArcGIS Runtime API for iOS is installed.

Steps

Open an Xcode project

This tutorial uses the completed Display a web scene tutorial as a starting point. You can first complete that tutorial or download and unzip the completed solution.

  1. To start this tutorial, first complete the Display a web scene tutorial or download and unzip the solution.
  2. Open the .xcodeproj file in Xcode.

Set the API Key

An API Key enables access to services, web maps, and web scenes hosted in ArcGIS Online.

  1. Go to your developer dashboard to get your API key. For these tutorials, use your default API key. It is scoped to include all of the services demonstrated in the tutorials.

  2. In Xcode, in the Project Navigator, click AppDelegate.swift.

  3. In the editor, set the apiKey property on the AGSArcGISRuntimeEnvironment with your API key.


    AppDelegate.swift
    Change line
                                       
    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
    // Copyright 2021 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
    //
    //   https://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.
    
    
    import UIKit
    
    import ArcGIS
    
    
    @UIApplicationMain
    class AppDelegate: UIResponder, UIApplicationDelegate {
        var window: UIWindow?
    
        func application(_ application: UIApplication,
                         didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
            // Note: it is not best practice to store API keys in source code.
            // The API key is referenced here for the convenience of this tutorial.
    
            AGSArcGISRuntimeEnvironment.apiKey = "YOUR_API_KEY"
    
            return true
        }
    
    }
    

Get the web scene item ID

You can use ArcGIS tools to create and view web scenes. Use the Scene Viewer to identify the web scene item ID. This item ID will be used later in the tutorial.

  1. Go to the Yosemite Valley Hotspots web scene in the Scene Viewer in ArcGIS Online. This web scene displays terrain and hotspots in the Yosemite Valley.
  2. Make a note of the item ID at the end of the browser's URL.

    The item ID should be 7558ee942b2547019f66885c44d4f0b1

Update the scene

  1. In Xcode, in the Project Navigator, click ViewController.swift.

  2. In the editor, modify the setupScene() method to create an AGSScene for the web scene. To do this, create a portal item providing the web scene's item ID and an AGSPortal referencing ArcGIS Online.

    ViewController.swift
    Change line
    31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 30 29 28 27 27 27 27 27 28 29 30 31 32 33 34 35 36 37 36 35 36 36 36 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 7 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -20 -21 -22 -23 -24 -24 -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
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    

Add a UI to control the viewshed analysis

To control the viewshed analysis, some UI elements are required.

  1. Create a private UISlider named slider. The slider changes the viewshed's maximum distance by expanding or contracting the size of the observer's field of view. The maximumValue and minimumValue properties define the range of values the user can select to calculate the viewshed.

    You set an action on the slider using a selector for a method that will be added in a later step.

    ViewController.swift
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.
    47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 46 45 44 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 42 41 41 41 41 41 42 43 44 45 46 47 48 49 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 49 49 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 18 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  2. Define a private method named setupUI() and assign the slider as well as a "Clear" button to the navigation bar. The clear button removes the viewshed from the scene

    You set an action on the clear button using a selector for a method that will be added in a later step.

    ViewController.swift
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.
    47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 46 45 44 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 42 41 41 41 41 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 59 58 57 56 55 54 53 52 51 50 49 49 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 18 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  3. Define a method named sliderValueDidChange(_:) and assign it the @objc keyword. This method updates the viewshed's maxDistance to a value specified by the slider.

    The @objc method keyword exposes the method to Objective-C, a necessary step for using the UISlider API.

    ViewController.swift
    Add line.Add line.Add line.Add line.
    56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 55 54 53 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 51 50 50 50 50 50 50 50 50 50 50 50 50 50 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 64 63 62 61 60 59 59 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 28 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  4. Define a method named clearScene(_:) and assign it the @objc keyword. This method hides the viewshed from the scene view.

    The @objc method keyword exposes the method to Objective-C, a necessary step for using the UIBarButtonItem API.

    ViewController.swift
    Add line.Add line.Add line.Add line.
    66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 65 64 63 62 62 62 62 62 62 62 62 62 62 62 62 62 62 62 61 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 61 62 63 64 65 66 67 68 69 69 69 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 38 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  5. In viewDidLoad(), call the method setupUI().

    ViewController.swift
    Add line.
    19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 20 21 22 23 24 25 25 25 26 26 26 26 26 26 26 26 26 26 26 26 26 26 25 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -7 -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
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  6. In Xcode, in the Project Navigator, click Main.storyboard.

  7. In the editor, select ViewController. In the menu bar, click Editor > Embed In > Navigation Controller.

    Embedding ViewController within a Navigation Controller places a navigation bar at the top of ViewController. The navigation bar contains the UI elements.

  8. To verify that your UI is set up properly, press <Command+R> to run the app. You should see a slider and a "Clear" button contained by the navigation bar and the app should load the Yosemite Valley Hotspots web scene.

Create a viewshed analysis

Visual analyses are used to help you make sense of complex 3D data contained by a scene. Use a AGSLocationViewshed to perform and display a viewshed analysis using a 3D point to define the observer's location.

  1. In Xcode, in the Project Navigator, click ViewController.swift.

  2. In the editor, create a private lazy AGSLocationViewshed named viewshed. Upon launch, the viewshed should not be visible.

    ViewController.swift
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.
    78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 77 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 75 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 87 87 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  3. Define a private method named setupAnalysisOverlay() to add the viewshed to the scene.

    The viewshed analysis is added to a scene view using an analysis overlay. An analysis overlay is a container for analyses. It can be used to display visual analyses in a scene view. You can add more than one analysis overlay and they are displayed on top of all other layers.

    ViewController.swift
    Add line.Add line.Add line.Add line.Add line.
    78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 77 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 75 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 93 92 91 90 89 88 87 86 85 84 83 82 82 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  4. Define a private method named setViewshedLocation(point:) that receives a point as a parameter. This method is used to set the location of the viewshed and make it visible, if it is not visible already.

    ViewController.swift
    Add line.Add line.Add line.Add line.Add line.Add line.
    92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 91 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 89 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 88 89 90 91 92 93 94 95 96 97 98 99 100 100 99 98 97 96 96 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  5. Define a private method named clearViewshed(). This method is used to hide the viewshed.

    ViewController.swift
    Add line.Add line.Add line.
    98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 98 97 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 95 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 95 96 97 98 99 100 101 102 103 104 104 104 104 103 102 101 100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  6. In viewDidLoad(), call setupAnalysisOverlay().

    ViewController.swift
    Add line.
    19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 20 21 22 23 24 25 26 27 28 28 28 28 28 28 28 28 28 28 28 28 28 28 27 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 -1
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    

Display the viewshed analysis with touch events

Touch events determine where to place the observer for the viewshed analysis. A user will long-press and drag to reveal and move the observer's location.

  1. Extend ViewController to conform to the AGSGeoViewTouchDelegate protocol and include the four long-press geoview touch delegate methods.

    ViewController.swift
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.
    111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 110 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 109 110 111 112 113 113 113 114 115 116 117 117 117 118 119 120 121 121 121 122 123 124 125 125 125 126 127 128
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue = 12_000
            slider.minimumValue = 1_000
            slider.value = 3_000
            slider.addTarget(self, action: #selector(sliderValueDidChange), for: .allTouchEvents)
            return slider
        }()
    
        private func setupUI() {
            navigationItem.titleView = slider
            navigationItem.rightBarButtonItem = UIBarButtonItem(
                title: "Clear",
                style: .plain,
                target: self,
                action: #selector(clearScene)
            )
        }
    
        @objc
        func sliderValueDidChange(_ sender: UISlider) {
            viewshed.maxDistance = Double(sender.value)
        }
    
        @objc
        func clearScene(_ sender: UIBarButtonItem) {
            clearViewshed()
        }
    
        // MARK: Viewshed Analysis
    
        private lazy var viewshed: AGSLocationViewshed = {
            let viewshed = AGSLocationViewshed(
                location: AGSPointMake3D(0, 0, 0, 0, .wgs84()),
                heading: 0,
                pitch: 90,
                horizontalAngle: 360,
                verticalAngle: 180,
                minDistance: 10,
                maxDistance: Double(slider.value)
            )
            viewshed.isVisible = false
            return viewshed
        }()
    
        private func setupAnalysisOverlay() {
            let analysisOverlay = AGSAnalysisOverlay()
            sceneView.analysisOverlays.add(analysisOverlay)
            analysisOverlay.analyses.add(viewshed)
        }
    
        private func setViewshedLocation(point: AGSPoint) {
            viewshed.location = point
            if !viewshed.isVisible {
                viewshed.isVisible = true
            }
        }
    
        private func clearViewshed() {
            viewshed.isVisible = false
        }
    
    }
    
    extension ViewController: AGSGeoViewTouchDelegate {
    
        func geoView(_ geoView: AGSGeoView, didLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didMoveLongPressToScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoView(_ geoView: AGSGeoView, didEndLongPressAtScreenPoint screenPoint: CGPoint, mapPoint: AGSPoint) {
    
            setViewshedLocation(point: mapPoint)
    
        }
    
        func geoViewDidCancelLongPress(_ geoView: AGSGeoView) {
    
            clearViewshed()
    
        }
    
    }
    
  2. When the user begins, moves, and ends a long-press touch event, call setViewshedLocation(point:). Using all three touch delegate methods together allows the user to reveal the observer location with a long-press touch event and move the observer by dragging their finger around the screen.

    ViewController.swift
    Add line.Add line.Add line.
    111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 133 133 134 135 136
    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
    // Copyright 2021 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.
    
    import ArcGIS
    
    class ViewController: UIViewController {
        @IBOutlet weak var sceneView: AGSSceneView!
    
        override func viewDidLoad() {
            super.viewDidLoad()
            setupScene()
    
            setupUI()
    
            setupAnalysisOverlay()
    
        }
    
        // MARK: Scene
    
        private func setupScene() {
            let scene: AGSScene = {
                let portal = AGSPortal.arcGISOnline(withLoginRequired: false)
    
                let item = AGSPortalItem(portal: portal, itemID: "7558ee942b2547019f66885c44d4f0b1")
    
                return AGSScene(item: item)
            }()
            sceneView.scene = scene
    
            sceneView.touchDelegate = self
    
        }
    
        // MARK: UI
    
        private lazy var slider: UISlider = {
            let slider = UISlider()
            slider.maximumValue =