Display a viewshed

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

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

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

   Show more lines

   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
       }
   
   }
   

   Show more lines

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

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

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

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

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

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

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

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

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

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

5. In viewDidLoad(), call the method setupUI().

   ViewController.swift

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

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.

   More info

   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

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

3. Define a private method named setupAnalysisOverlay() to add the viewshed to the scene.

   More info

   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

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

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

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

5. Define a private method named clearViewshed(). This method is used to hide the viewshed.

   ViewController.swift

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines

6. In viewDidLoad(), call setupAnalysisOverlay().

   ViewController.swift

   Show more lines

   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()
   
       }
   
   }
   

   Show more lines