Source: formats/kml/KmlLookAt.js

  1. /*
  2.  * Copyright 2003-2006, 2009, 2017, 2020 United States Government, as represented
  3.  * by the Administrator of the National Aeronautics and Space Administration.
  4.  * All rights reserved.
  5.  *
  6.  * The NASAWorldWind/WebWorldWind platform is licensed under the Apache License,
  7.  * Version 2.0 (the "License"); you may not use this file except in compliance
  8.  * with the License. You may obtain a copy of the License
  9.  * at http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software distributed
  12.  * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
  13.  * CONDITIONS OF ANY KIND, either express or implied. See the License for the
  14.  * specific language governing permissions and limitations under the License.
  15.  *
  16.  * NASAWorldWind/WebWorldWind also contains the following 3rd party Open Source
  17.  * software:
  18.  *
  19.  *    ES6-Promise – under MIT License
  20.  *    libtess.js – SGI Free Software License B
  21.  *    Proj4 – under MIT License
  22.  *    JSZip – under MIT License
  23.  *
  24.  * A complete listing of 3rd Party software notices and licenses included in
  25.  * WebWorldWind can be found in the WebWorldWind 3rd-party notices and licenses
  26.  * PDF found in code  directory.
  27.  */
  28. define([
  29.     './KmlAbstractView',
  30.     './KmlElements',
  31.     './util/KmlNodeTransformers',
  32.     '../../geom/Position'
  33. ], function (KmlAbstractView,
  34.              KmlElements,
  35.              NodeTransformers,
  36.              Position
  37. ) {
  38.     "use strict";
  40.     /**
  41.      * Constructs an KmlLookAt. Applications usually don't call this constructor. It is called by {@link KmlFile} as
  42.      * objects from Kml file are read. This object is already concrete implementation.
  43.      * @alias KmlLookAt
  44.      * @classdesc Contains the data associated with LookAt node.
  45.      * @param options {Object}
  46.      * @param options.objectNode {Node} Node representing looking at something in the document.
  47.      * @constructor
  48.      * @throws {ArgumentError} If the node is null or undefined.
  49.      * @see https://developers.google.com/kml/documentation/kmlreference#lookat
  50.      * @augments KmlAbstractView
  51.      */
  52.     var KmlLookAt = function (options) {
  53.         KmlAbstractView.call(this, options);
  54.     };
  56.     KmlLookAt.prototype = Object.create(KmlAbstractView.prototype);
  58.     Object.defineProperties(KmlLookAt.prototype, {
  59.         /**
  60.          * Longitude of the point the camera is looking at. Angular distance in degrees, relative to the Prime
  61.          * Meridian. Values west of the Meridian range from -180 to 0 degrees. Values east of the Meridian range
  62.          * from 0 to 180 degrees.
  63.          * @memberof KmlLookAt.prototype
  64.          * @readonly
  65.          * @type {Number}
  66.          */
  67.         kmlLongitude: {
  68.             get: function () {
  69.                 return this._factory.specific(this, {name: 'longitude', transformer: NodeTransformers.number});
  70.             }
  71.         },
  73.         /**
  74.          * Latitude of the point the camera is looking at. Degrees north or south of the Equator (0 degrees). Values
  75.          * range from -90 degrees to 90 degrees.
  76.          * @memberof KmlLookAt.prototype
  77.          * @readonly
  78.          * @type {Number}
  79.          */
  80.         kmlLatitude: {
  81.             get: function () {
  82.                 return this._factory.specific(this, {name: 'latitude', transformer: NodeTransformers.number});
  83.             }
  84.         },
  86.         /**
  87.          * Distance from the earth's surface, in meters. Interpreted according to the LookAt's altitude mode.
  88.          * @memberof KmlLookAt.prototype
  89.          * @readonly
  90.          * @type {Number}
  91.          */
  92.         kmlAltitude: {
  93.             get: function () {
  94.                 return this._factory.specific(this, {name: 'altitude', transformer: NodeTransformers.number});
  95.             }
  96.         },
  98.         /**
  99.          * Direction (that is, North, South, East, West), in degrees. Default=0 (North). (See diagram below.) Values
  100.          * range from 0 to 360 degrees.
  101.          * @memberof KmlLookAt.prototype
  102.          * @readonly
  103.          * @type {Number}
  104.          */
  105.         kmlHeading: {
  106.             get: function () {
  107.                 return this._factory.specific(this, {name: 'heading', transformer: NodeTransformers.number});
  108.             }
  109.         },
  111.         /**
  112.          * Angle between the direction of the LookAt position and the normal to the surface of the earth. (See
  113.          * diagram below.) Values range from 0 to 90 degrees. Values for <tilt> cannot be negative. A <tilt> value
  114.          * of 0 degrees indicates viewing from directly above. A <tilt> value of 90 degrees indicates viewing along
  115.          * the horizon.
  116.          * @memberof KmlLookAt.prototype
  117.          * @readonly
  118.          * @type {Number}
  119.          */
  120.         kmlTilt: {
  121.             get: function () {
  122.                 return this._factory.specific(this, {name: 'tilt', transformer: NodeTransformers.number});
  123.             }
  124.         },
  126.         /**
  127.          * Distance in meters from the point specified by <longitude>, <latitude>, and <altitude> to the LookAt
  128.          * position. (See diagram below.)
  129.          * @memberof KmlLookAt.prototype
  130.          * @readonly
  131.          * @type {Number}
  132.          */
  133.         kmlRange: {
  134.             get: function () {
  135.                 return this._factory.specific(this, {name: 'range', transformer: NodeTransformers.number});
  136.             }
  137.         },
  139.         /**
  140.          * Specifies how the <altitude> specified for the LookAt point is interpreted. Possible values are as
  141.          * follows: clampToGround - (default) Indicates to ignore the <altitude> specification and place the LookAt
  142.          * position on the ground. relativeToGround - Interprets the <altitude> as a value in meters above the
  143.          * ground. absolute - Interprets the <altitude> as a value in meters above sea level.
  144.          * @memberof KmlLookAt.prototype
  145.          * @readonly
  146.          * @type {String}
  147.          */
  148.         kmlAltitudeMode: {
  149.             get: function () {
  150.                 return this._factory.specific(this, {name: 'altitudeMode', transformer: NodeTransformers.string});
  151.             }
  152.         }
  153.     });
  155.     /**
  156.      * Go to the look at location.
  157.      */
  158.     KmlLookAt.prototype.update = function(options) {
  159.         if(options.wwd) {
  160.             var altitude = this.kmlAltitude || 4000;
  161.             // TODO: Respect altitude mode.
  162.             options.wwd.goTo(new Position(this.kmlLatitude, this.kmlLongitude, altitude));
  163.         }
  164.     };
  166.     /**
  167.      * @inheritDoc
  168.      */
  169.     KmlLookAt.prototype.getTagNames = function () {
  170.         return ['LookAt'];
  171.     };
  173.     KmlElements.addKey(KmlLookAt.prototype.getTagNames()[0], KmlLookAt);
  175.     return KmlLookAt;
  176. });