Source: formats/kml/KmlCamera.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.     './KmlElements',
  30.     './KmlAbstractView',
  31.     './util/KmlNodeTransformers'
  32. ], function (KmlElements,
  33.              KmlAbstractView,
  34.              NodeTransformers) {
  35.     "use strict";
  37.     /**
  38.      * Constructs an KmlCamera. Applications usually don't call this constructor. It is called by {@link KmlFile} as
  39.      * objects from Kml file are read. This object is already concrete implementation.
  40.      * @alias KmlCamera
  41.      * @classdesc Contains the data associated with Camera node.
  42.      * @param options {Object}
  43.      * @param options.objectNode {Node} Node representing camera in the document.
  44.      * @constructor
  45.      * @throws {ArgumentError} If the node is null or undefined.
  46.      * @see https://developers.google.com/kml/documentation/kmlreference#camera
  47.      * @augments KmlAbstractView
  48.      */
  49.     var KmlCamera = function (options) {
  50.         KmlAbstractView.call(this, options);
  51.     };
  53.     KmlCamera.prototype = Object.create(KmlAbstractView.prototype);
  55.     Object.defineProperties(KmlCamera.prototype, {
  56.         /**
  57.          * Longitude of the virtual camera (eye point). Angular distance in degrees, relative to the Prime Meridian.
  58.          * Values west of the Meridian range from +-180 to 0 degrees. Values east of the Meridian range from 0
  59.          * to 180 degrees.
  60.          * @memberof KmlCamera.prototype
  61.          * @readonly
  62.          * @type {String}
  63.          */
  64.         kmlLongitude: {
  65.             get: function () {
  66.                 return this._factory.specific(this, {name: 'longitude', transformer: NodeTransformers.string});
  67.             }
  68.         },
  70.         /**
  71.          * Latitude of the virtual camera. Degrees north or south of the Equator (0 degrees). Values range from -90
  72.          * degrees to 90 degrees.
  73.          * @memberof KmlCamera.prototype
  74.          * @readonly
  75.          * @type {String}
  76.          */
  77.         kmlLatitude: {
  78.             get: function () {
  79.                 return this._factory.specific(this, {name: 'latitude', transformer: NodeTransformers.string});
  80.             }
  81.         },
  83.         /**
  84.          * Distance of the camera from the earth's surface, in meters. Interpreted according to the Camera's
  85.          * <altitudeMode> or <gx:altitudeMode>.
  86.          * @memberof KmlCamera.prototype
  87.          * @readonly
  88.          * @type {String}
  89.          */
  90.         kmlAltitude: {
  91.             get: function () {
  92.                 return this._factory.specific(this, {name: 'altitude', transformer: NodeTransformers.string});
  93.             }
  94.         },
  96.         /**
  97.          * Direction (azimuth) of the camera, in degrees. Default=0 (true North). (See diagram.) Values range from
  98.          * 0 to 360 degrees.
  99.          * @memberof KmlCamera.prototype
  100.          * @readonly
  101.          * @type {String}
  102.          */
  103.         kmlHeading: {
  104.             get: function () {
  105.                 return this._factory.specific(this, {name: 'heading', transformer: NodeTransformers.string});
  106.             }
  107.         },
  109.         /**
  110.          * Rotation, in degrees, of the camera around the X axis. A value of 0 indicates that the view is aimed
  111.          * straight down toward the earth (the most common case). A value for 90 for <tilt> indicates that the
  112.          * view
  113.          * is aimed toward the horizon. Values greater than 90 indicate that the view is pointed up into the sky.
  114.          * Values for <tilt> are clamped at +180 degrees.
  115.          * @memberof KmlCamera.prototype
  116.          * @readonly
  117.          * @type {String}
  118.          */
  119.         kmlTilt: {
  120.             get: function () {
  121.                 return this._factory.specific(this, {name: 'tilt', transformer: NodeTransformers.string});
  122.             }
  123.         },
  125.         /**
  126.          * Rotation, in degrees, of the camera around the Z axis. Values range from -180 to +180 degrees.
  127.          * @memberof KmlCamera.prototype
  128.          * @readonly
  129.          * @type {String}
  130.          */
  131.         kmlRoll: {
  132.             get: function () {
  133.                 return this._factory.specific(this, {name: 'roll', transformer: NodeTransformers.string});
  134.             }
  135.         },
  137.         /**
  138.          * Specifies how the <altitude> specified for the Camera is interpreted. Possible values are as
  139.          * follows:
  140.          * relativeToGround - (default) Interprets the <altitude> as a value in meters above the ground. If the
  141.          * point is over water, the <altitude> will be interpreted as a value in meters above sea level. See
  142.          * <gx:altitudeMode> below to specify points relative to the sea floor. clampToGround - For a camera, this
  143.          * setting also places the camera relativeToGround, since putting the camera exactly at terrain height
  144.          * would
  145.          * mean that the eye would intersect the terrain (and the view would be blocked). absolute - Interprets the
  146.          * <altitude> as a value in meters above sea level.
  147.          * @memberof KmlCamera.prototype
  148.          * @readonly
  149.          * @type {String}
  150.          */
  151.         kmlAltitudeMode: {
  152.             get: function () {
  153.                 return this._factory.specific(this, {name: 'altitudeMode', transformer: NodeTransformers.string});
  154.             }
  155.         }
  156.     });
  158.     /**
  159.      * @inheritDoc
  160.      */
  161.     KmlCamera.prototype.getTagNames = function () {
  162.         return ['Camera'];
  163.     };
  165.     KmlElements.addKey(KmlCamera.prototype.getTagNames()[0], KmlCamera);
  167.     return KmlCamera;
  168. });