LineOfSightViewModel | References | ArcGIS Maps SDK for JavaScript

import LineOfSightViewModel from "@arcgis/core/widgets/LineOfSight/LineOfSightViewModel.js";

Inheritance:: LineOfSightViewModel→Accessor

Since: ArcGIS Maps SDK for JavaScript 4.14

Provides the logic for the LineOfSight widget and component. Use it to create your own widget or to get access to the observer, targets and intersections.

Using the LineOfSightViewModel you can programmatically set the observer and targets for a line of sight analysis.

// instantiate a new view model
const losViewModel = new LineOfSightViewModel({
 view: view
});

// set an observer
losViewModel.observer = new Point({
  latitude: 42.3521,
  longitude: -71.0559,
  z: 147.139
});

// set a target by passing in a LineOfSightTarget to the targets collection
losViewModel.targets = [new LineOfSightTarget({
   location: new Point({
     latitude: 42.352,
     longitude: -71.051,
     z: 0
   })
})];

// when using JavaScript LineOfSightTarget can be autocast
losViewModel.targets = [{
   location: {
     latitude: 42.352,
     longitude: -71.051,
     z: 0
   }
}];

The view model can also be used to control the different states of the analysis: start() enters the creation state where the user can add the observer and targets. stop() enters the created state where the user can't add new targets but they can still move the observer and existing target.

viewModel.start();

The LineOfSightViewModel also allows you to watch for changes (for example when the user moves the observer or the targets) and gives you access to the intersected graphic and the location where the intersection occurred. The observer is just a Point, so you can simply watch the observer property on the view model to know when an observer gets added or moved.

reactiveUtils.watch(
  () => losViewModel.observer,
  (value) => {
    // do something with the value
  }
);

const highlightHandles = [];

reactiveUtils.watch(
  () => {
    // Watch the whole expression. The callback will be called if any target is added or removed
    // and also if any of the target's `intersectedGraphic` property changes.
    viewModel.targets
      .map((target) => target.intersectedGraphic)
      .map((graphic) => !!graphic)
      .toArray()
  },
  (intersectedGraphics) => {
    // Remove the previous highlights
    highlightHandles.forEach((handle) => handle.remove());

    // Highlight all the intersected graphics
    highlightHandles = intersectedGraphics.map((graphic) => {
      return layerView.highlight(graphic);
    });
  }
);

A target contains information about the location of the target, whether it's visible or not, which graphic it intersects and the location where it intersects that graphic, an integrated mesh or the ground. The LineOfSightTarget class is used to represent a target.

See also

LineOfSight widget - Deprecated since 4.33. Use the Line Of Sight component instead.
LineOfSightTarget
Sample - Line of sight widget
Programming patterns: Widget viewModel pattern

Constructors

Constructor

Parameters

Parameter	Type	Description	Required
properties	`LineOfSightViewModelProperties`

See the properties table for a list of all the properties that may be passed into the constructor.

Properties

Any properties can be set, retrieved or listened to. See the Watch for changes topic.

Property	Type	Class
`analysis`	`LineOfSightAnalysis`
`declaredClass` readonly inherited	`string`	Accessor
`observer`	`Point \| null \| undefined`
`state` readonly	`"disabled" \| "ready" \| "creating" \| "created"`
`targets`	`Collection<LineOfSightTarget>`
`view`	`SceneView \| null \| undefined`

analysis

autocast Property

Type: LineOfSightAnalysis

Since: ArcGIS Maps SDK for JavaScript 4.23

The line of sight analysis object being created or modified by the view model.

If no analysis is provided, the view model automatically creates its own analysis and adds it to the view. In this case, the analysis will also be automatically removed from the view when the view model is destroyed.

Example

// Construct a line of sight analysis object outside of the view model
const analysis = new LineOfSightAnalysis({
  observer: {
    type: "point", // autocasts as new Point()
    x: 7.67,
    y: 45.981,
    z: 3435.765
  },
  targets: [{
    location: {
      type: "point",
      x: 7.659,
      y: 45.976,
      z: 4437
    }
  }]
});

// Ensure that the analysis is added to the view
view.analyses.add(analysis);

// Frame the analysis in the view
view.goTo(analysis.extent);

// Pass the analysis object as a constructor parameter to modify it using the view model
const viewModel = new LineOfSightViewModel({
  analysis: analysis,
  view: view
});

declaredClass

readonlyinherited Property

Type: string

Inherited from: Accessor

The name of the class. The declared class name is formatted as esri.folder.className.

observer

autocast Property

Type: Point | null | undefined

The observer's viewpoint from which lines of sight will be drawn towards the targets. The Z value of the point is an absolute value.

state

readonly Property

Type: "disabled" | "ready" | "creating" | "created"

The view model's state.

Value	Description
disabled	not ready yet
ready	ready for analysis
creating	observer/target points are being placed
created	finished analysis

Default value: "disabled"

targets

autocast Property

Type: Collection<LineOfSightTarget>

A collection of LineOfSightTarget containing the target location and the analysis results.

view

Property

Type: SceneView | null | undefined

The view from which the widget will operate.

Methods

Method	Signature	Class
`clear`	`clear(): void`
`continue`	`continue(): void`
`start`	`start(): Promise<void>`
`stop`	`stop(): void`

clear

Method

Signature: clear (): void

Clears the current analysis results. After calling this method, the user can set a new observer and targets.

Returns: void

continue

Method

Signature: continue (): void

If stopped, this method continues the line of sight analysis and the user can add more targets.

Returns: void

start

Method

Signature: start (): Promise<void>

Starts a new line of sight analysis.

Returns: Promise<void>

stop

Method

Signature: stop (): void

Stops the current line of sight analysis, keeping the results in the view. Users can still interact with existing targets and the observer but they can't place new target points.

Returns: void