@arcgis/map-components
Version:
ArcGIS Map Components
150 lines (148 loc) • 8.17 kB
TypeScript
/// <reference types="@arcgis/core/interfaces.d.ts" />
/// <reference types="../../index.d.ts" />
import { Use } from '@arcgis/lumina/controllers';
import { PublicLitElement as LitElement, JsxNode, TargetedEvent } from '@arcgis/lumina';
import { ArcgisReferenceElement } from '../../utils/component-utils';
import { default as LineOfSightViewModel } from './LineOfSightViewModel';
declare const useViewModel: (component: LitElement & Pick<LineOfSightViewModel, never> & import('../../controllers/useViewModel').ViewModelControllerUses<LineOfSightViewModel>) => LineOfSightViewModel;
/**
* The Line Of Sight component is a 3D analysis tool that allows you to perform
* [line of sight visibility analysis](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-LineOfSightAnalysis.html)
* in a [Scene](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/). Visibility between a given observer and multiple target points is calculated against the currently
* displayed content in the view, including the ground, integrated meshes, and 3D objects such as buildings or trees.
*
* 
*
* The analysis results are displayed as colored lines, where areas visible to the observer are
* shown green and occluded parts are marked in red. Also, the color of the target points indicates their visibility.
* When the line of sight cannot be calculated, it will be displayed with a gray color. This may happen if either
* the target or the observer is not in the view.
*
* When creating a new line of sight analysis, the first click in the Scene creates the
* [observer](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-LineOfSightAnalysisObserver.html)
* and subsequent clicks place the [targets](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-LineOfSightAnalysisTarget.html).
* Both the observer and target points can be moved by dragging. Additionally, the target points can be removed with a right click.
*
* **Known limitation**
*
* Line Of Sight is only supported in a 3D [Scene](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/) component.
*
* **See also**
*
* - [LineOfSightAnalysis](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-LineOfSightAnalysis.html)
* - [Sample - Line of sight component](https://developers.arcgis.com/javascript/latest/sample-code/line-of-sight/)
* - [Sample - Analysis objects](https://developers.arcgis.com/javascript/latest/sample-code/analysis-objects/)
*
* [Read more...](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-line-of-sight/)
*/
export declare class ArcgisLineOfSight extends LitElement {
/**
* The [LineOfSightAnalysis](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-LineOfSightAnalysis.html)
* created or modified by the component.
*
* When connecting the Line Of Sight component to the [Scene](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/)
* component, it automatically creates an empty analysis and adds it to the Scene's
* [analyses](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/#analyses) collection.
* Whenever the component is destroyed, the analysis is automatically removed from the collection.
*
* Alternatively, a programmatically created analysis can be provided to the component.
* Then, the application itself needs to add it to and later remove it from the Scene's analyses collection.
*
* ```js
* //Create the analysis.
* const lineOfSightAnalysis = new LineOfSightAnalysis({
* observer: new LineOfSightAnalysisObserver({
* position: new Point({
* spatialReference: { latestWkid: 3857, wkid: 102100 },
* x: -13624828.3377593,
* y: 4550305.319405007,
* z: 105.55410975124687
* }),
* }),
* targets: [ new LineOfSightAnalysisTarget({
* position: new Point({
* spatialReference: { latestWkid: 3857, wkid: 102100 },
* x: -13624944.17687458,
* y: 4550420.577689567,
* z: 0
* }),
* })
* ]
* });
* // Get the Scene and Line Of Sight component and wait until they are ready.
* const viewElement = document.querySelector("arcgis-scene");
* await viewElement.viewOnReady();
* const lineOfSight = document.querySelector("arcgis-line-of-sight");
* await lineOfSight.componentOnReady();
* // Add the analysis to the Scene component.
* viewElement.analyses.add(lineOfSightAnalysis);
* // Connect the analysis to the component:
* lineOfSight.analysis = lineOfSightAnalysis;
* ```
*/
analysis: __esri.LineOfSightAnalysis;
/**
* If true, the component will not be destroyed automatically when it is
* disconnected from the document. This is useful when you want to move the
* component to a different place on the page, or temporarily hide it. If this
* is set, make sure to call the [destroy](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-line-of-sight/#destroy) method when you are done to
* prevent memory leaks.
*
* @default false
*/
autoDestroyDisabled: boolean;
/**
* Icon which represents the component.
* Typically used when the component is controlled by another component (e.g. by the Expand component).
*
* @see [Calcite Icons](https://developers.arcgis.com/calcite-design-system/icons/)
* @default "line-of-sight"
*/
icon?: HTMLCalciteIconElement["icon"];
/** The component's default label. */
label?: string;
/**
* Replace localized message strings with your own strings.
*
* _**Note**: Individual message keys may change between releases._
*/
messageOverrides?: typeof this._messages._overrides;
/** @default "bottom-left" */
position: __esri.UIPosition;
/**
* By assigning the `id` attribute of the Map or Scene component to this property, you can position a child component anywhere in the DOM while still maintaining a connection to the Map or Scene.
*
* @see [Associate components with a Map or Scene component](https://developers.arcgis.com/javascript/latest/programming-patterns/#associate-components-with-a-map-or-scene-component)
*/
referenceElement?: ArcgisReferenceElement | string;
/**
* The component's state. The values mean the following:
*
* * `disabled` - not ready yet
* * `ready` - ready for analysis
* * `creating` - observer/target points are being placed
* * `created` - finished analysis
*/
get state(): "created" | "creating" | "disabled" | "ready";
/** Clear the current analysis results. After calling this method, the user can set a new observer and targets. */
clear(): Promise<void>;
/** After [stop()](#stop) was called, this method allows to continue the line of sight analysis and add more targets. */
continue(): Promise<void>;
/** Permanently destroy the component. */
destroy(): Promise<void>;
/** Start a new line of sight analysis. */
start(): Promise<void>;
/**
* Stop the current placing of line of sight analysis. Any lines added this far are kept in the view.
* Users can still interact with existing targets and the observer, but they cannot place new target points.
*/
stop(): Promise<void>;
/** Emitted when the value of a property is changed. Use this to listen to changes to properties. */
readonly arcgisPropertyChange: TargetedEvent<this, {
name: "state" | "analysis";
}>;
/** Emitted when the component associated with a map or scene view is is ready to be interacted with. */
readonly arcgisReady: TargetedEvent<this, void>;
private _messages;
}
export {};