Source: util/measure/LengthMeasurer.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. /**
  29.  * @exports LengthMeasurer
  30.  */
  32. define([
  33.         '../../error/ArgumentError',
  34.         '../../geom/Location',
  35.         '../Logger',
  36.         './MeasurerUtils',
  37.         '../../geom/Position',
  38.         '../../geom/Vec3'
  39.     ],
  40.     function (ArgumentError,
  41.               Location,
  42.               Logger,
  43.               MeasurerUtils,
  44.               Position,
  45.               Vec3) {
  47.         /**
  48.          * Utility class to measure length along a path on a globe. <p/> <p>Segments which are longer then the current
  49.          * maxSegmentLength will be subdivided along lines following the current pathType - WorldWind.LINEAR,
  50.          * WorldWind.RHUMB_LINE or WorldWind.GREAT_CIRCLE.</p> <p/> <p>For follow terrain, the computed length will
  51.          * account for terrain deformations as if someone was walking along that path. Otherwise the length is the sum
  52.          * of the cartesian distance between the positions.</p>
  53.          * <p/>
  54.          * <p>When following terrain the measurer will sample terrain elevations at regular intervals along the path.
  55.          * The minimum number of samples used for the whole length can be set with lengthTerrainSamplingSteps.
  56.          * However, the minimum sampling interval is 30 meters.
  57.          * @alias LengthMeasurer
  58.          * @constructor
  59.          * @param {WorldWindow} wwd The WorldWindow associated with LengthMeasurer.
  60.          * @throws {ArgumentError} If the specified WorldWindow is null or undefined.
  61.          */
  62.         var LengthMeasurer = function (wwd) {
  64.             if (!wwd) {
  65.                 throw new ArgumentError(
  66.                     Logger.logMessage(Logger.LEVEL_SEVERE, "LengthMeasurer", "constructor", "missingWorldWindow"));
  67.             }
  69.             this.wwd = wwd;
  71.             // Private. The minimum length of a terrain following subdivision.
  72.             this.DEFAULT_MIN_SEGMENT_LENGTH = 30;
  74.             // Private. Documentation is with the defined property below.
  75.             this._maxSegmentLength = 100e3;
  77.             // Private. Documentation is with the defined property below.
  78.             this._lengthTerrainSamplingSteps = 128;
  80.             // Private. A list of positions with no segment longer then maxLength and elevations following terrain or not.
  81.             this.subdividedPositions = null;
  82.         };
  84.         Object.defineProperties(LengthMeasurer.prototype, {
  85.             /**
  86.              * The maximum length a segment can have before being subdivided along a line following the current pathType.
  87.              * @type {Number}
  88.              * @memberof LengthMeasurer.prototype
  89.              */
  90.             maxSegmentLength: {
  91.                 get: function () {
  92.                     return this._maxSegmentLength;
  93.                 },
  94.                 set: function (value) {
  95.                     this._maxSegmentLength = value;
  96.                 }
  97.             },
  99.             /**
  100.              * The number of terrain elevation samples used along the path to approximate it's terrain following length.
  101.              * @type {Number}
  102.              * @memberof LengthMeasurer.prototype
  103.              */
  104.             lengthTerrainSamplingSteps: {
  105.                 get: function () {
  106.                     return this._lengthTerrainSamplingSteps;
  107.                 },
  108.                 set: function (value) {
  109.                     this._lengthTerrainSamplingSteps = value;
  110.                 }
  111.             }
  112.         });
  114.         /**
  115.          * Get the path length in meter. <p/> <p>If followTerrain is true, the computed length will account
  116.          * for terrain deformations as if someone was walking along that path. Otherwise the length is the sum of the
  117.          * cartesian distance between each positions.</p>
  118.          *
  119.          * @param {Position[]} positions
  120.          * @param {Boolean} followTerrain
  121.          * @param {String} pathType One of WorldWind.LINEAR, WorldWind.RHUMB_LINE or WorldWind.GREAT_CIRCLE
  122.          *
  123.          * @return the current path length or -1 if the position list is too short.
  124.          */
  125.         LengthMeasurer.prototype.getLength = function (positions, followTerrain, pathType) {
  126.             pathType = pathType || WorldWind.GREAT_CIRCLE;
  127.             this.subdividedPositions = null;
  128.             return this.computeLength(positions, followTerrain, pathType);
  129.         };
  131.         /**
  132.          * Get the path length in meter of a Path. <p/> <p>If the path's followTerrain is true, the computed length
  133.          * will account for terrain deformations as if someone was walking along that path. Otherwise the length is the
  134.          * sum of the cartesian distance between each positions.</p>
  135.          *
  136.          * @param {Path} path
  137.          *
  138.          * @return the current path length or -1 if the position list is too short.
  139.          */
  140.         LengthMeasurer.prototype.getPathLength = function (path) {
  141.             this.subdividedPositions = null;
  142.             return this.computeLength(path.positions, path.followTerrain, path.pathType);
  143.         };
  145.         /**
  146.          * Get the great circle, rhumb or linear distance, in meter, of a Path or an array of Positions.
  147.          *
  148.          * @param {Path|Position[]} path A Path or an array of Positions
  149.          * @param {String} pathType Optional argument used when path is an array of Positions.
  150.          * Defaults to WorldWind.GREAT_CIRCLE.
  151.          * Recognized values are:
  152.          * <ul>
  153.          * <li>[WorldWind.GREAT_CIRCLE]{@link WorldWind#GREAT_CIRCLE}</li>
  154.          * <li>[WorldWind.RHUMB_LINE]{@link WorldWind#RHUMB_LINE}</li>
  155.          * <li>[WorldWind.LINEAR]{@link WorldWind#LINEAR}</li>
  156.          * </ul>
  157.          *
  158.          * @return {Number} the current path length or -1 if the position list is too short.
  159.          */
  160.         LengthMeasurer.prototype.getGeographicDistance = function (path, pathType) {
  161.             if (path instanceof WorldWind.Path) {
  162.                 var positions = path.positions;
  163.                 var _pathType = path.pathType;
  164.             }
  165.             else if (Array.isArray(path)) {
  166.                 positions = path;
  167.                 _pathType = pathType || WorldWind.GREAT_CIRCLE;
  168.             }
  170.             if (!positions || positions.length < 2) {
  171.                 return -1;
  172.             }
  174.             var fn = Location.greatCircleDistance;
  175.             if (_pathType === WorldWind.RHUMB_LINE) {
  176.                 fn = Location.rhumbDistance;
  177.             }
  178.             else if (_pathType === WorldWind.LINEAR) {
  179.                 fn = Location.linearDistance;
  180.             }
  182.             var distance = 0;
  183.             for (var i = 0, len = positions.length - 1; i < len; i++) {
  184.                 var pos1 = positions[i];
  185.                 var pos2 = positions[i + 1];
  186.                 distance += fn(pos1, pos2);
  187.             }
  189.             return distance * this.wwd.globe.equatorialRadius;
  190.         };
  192.         /**
  193.          * Computes the length.
  194.          * @param {Position[]} positions
  195.          * @param {Boolean} followTerrain
  196.          * @param {String} pathType One of WorldWind.LINEAR, WorldWind.RHUMB_LINE or WorldWind.GREAT_CIRCLE
  197.          */
  198.         LengthMeasurer.prototype.computeLength = function (positions, followTerrain, pathType) {
  199.             if (!positions || positions.length < 2) {
  200.                 return -1;
  201.             }
  203.             var globe = this.wwd.globe;
  205.             if (this.subdividedPositions == null) {
  206.                 // Subdivide path so as to have at least segments smaller then maxSegmentLength. If follow terrain,
  207.                 // subdivide so as to have at least lengthTerrainSamplingSteps segments, but no segments shorter then
  208.                 // DEFAULT_MIN_SEGMENT_LENGTH either.
  209.                 var maxLength = this._maxSegmentLength;
  210.                 if (followTerrain) {
  211.                     // Recurse to compute overall path length not following terrain
  212.                     var pathLength = this.computeLength(positions, false, pathType);
  213.                     // Determine segment length to have enough sampling points
  214.                     maxLength = pathLength / this._lengthTerrainSamplingSteps;
  215.                     maxLength = Math.min(Math.max(maxLength, this.DEFAULT_MIN_SEGMENT_LENGTH), this._maxSegmentLength);
  216.                 }
  217.                 this.subdividedPositions = MeasurerUtils.subdividePositions(globe, positions, followTerrain, pathType,
  218.                     maxLength);
  219.             }
  221.             var distance = 0;
  222.             var pos0 = this.subdividedPositions[0];
  223.             var p1 = new Vec3(0, 0, 0);
  224.             var p2 = new Vec3(0, 0, 0);
  225.             p1 = globe.computePointFromPosition(pos0.latitude, pos0.longitude, pos0.altitude, p1);
  226.             for (var i = 1, len = this.subdividedPositions.length; i < len; i++) {
  227.                 var pos = this.subdividedPositions[i];
  228.                 p2 = globe.computePointFromPosition(pos.latitude, pos.longitude, pos.altitude, p2);
  229.                 distance += p1.distanceTo(p2);
  230.                 p1.copy(p2);
  231.             }
  233.             return distance;
  234.         };
  236.         return LengthMeasurer;
  238.     });