Source: Core/Rectangle.js

  1. /*global define*/
  2. define([
  3.         './Cartographic',
  4.         './defaultValue',
  5.         './defined',
  6.         './defineProperties',
  7.         './DeveloperError',
  8.         './Ellipsoid',
  9.         './freezeObject',
  10.         './Math'
  11.     ], function(
  12.         Cartographic,
  13.         defaultValue,
  14.         defined,
  15.         defineProperties,
  16.         DeveloperError,
  17.         Ellipsoid,
  18.         freezeObject,
  19.         CesiumMath) {
  20.     'use strict';
  22.     /**
  23.      * A two dimensional region specified as longitude and latitude coordinates.
  24.      *
  25.      * @alias Rectangle
  26.      * @constructor
  27.      *
  28.      * @param {Number} [west=0.0] The westernmost longitude, in radians, in the range [-Pi, Pi].
  29.      * @param {Number} [south=0.0] The southernmost latitude, in radians, in the range [-Pi/2, Pi/2].
  30.      * @param {Number} [east=0.0] The easternmost longitude, in radians, in the range [-Pi, Pi].
  31.      * @param {Number} [north=0.0] The northernmost latitude, in radians, in the range [-Pi/2, Pi/2].
  32.      *
  33.      * @see Packable
  34.      */
  35.     function Rectangle(west, south, east, north) {
  36.         /**
  37.          * The westernmost longitude in radians in the range [-Pi, Pi].
  38.          *
  39.          * @type {Number}
  40.          * @default 0.0
  41.          */
  42.         this.west = defaultValue(west, 0.0);
  44.         /**
  45.          * The southernmost latitude in radians in the range [-Pi/2, Pi/2].
  46.          *
  47.          * @type {Number}
  48.          * @default 0.0
  49.          */
  50.         this.south = defaultValue(south, 0.0);
  52.         /**
  53.          * The easternmost longitude in radians in the range [-Pi, Pi].
  54.          *
  55.          * @type {Number}
  56.          * @default 0.0
  57.          */
  58.         this.east = defaultValue(east, 0.0);
  60.         /**
  61.          * The northernmost latitude in radians in the range [-Pi/2, Pi/2].
  62.          *
  63.          * @type {Number}
  64.          * @default 0.0
  65.          */
  66.         this.north = defaultValue(north, 0.0);
  67.     }
  69.     defineProperties(Rectangle.prototype, {
  70.         /**
  71.          * Gets the width of the rectangle in radians.
  72.          * @memberof Rectangle.prototype
  73.          * @type {Number}
  74.          */
  75.         width : {
  76.             get : function() {
  77.                 return Rectangle.computeWidth(this);
  78.             }
  79.         },
  81.         /**
  82.          * Gets the height of the rectangle in radians.
  83.          * @memberof Rectangle.prototype
  84.          * @type {Number}
  85.          */
  86.         height : {
  87.             get : function() {
  88.                 return Rectangle.computeHeight(this);
  89.             }
  90.         }
  91.     });
  93.     /**
  94.      * The number of elements used to pack the object into an array.
  95.      * @type {Number}
  96.      */
  97.     Rectangle.packedLength = 4;
  99.     /**
  100.      * Stores the provided instance into the provided array.
  101.      *
  102.      * @param {Rectangle} value The value to pack.
  103.      * @param {Number[]} array The array to pack into.
  104.      * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
  105.      *
  106.      * @returns {Number[]} The array that was packed into
  107.      */
  108.     Rectangle.pack = function(value, array, startingIndex) {
  109.         //>>includeStart('debug', pragmas.debug);
  110.         if (!defined(value)) {
  111.             throw new DeveloperError('value is required');
  112.         }
  114.         if (!defined(array)) {
  115.             throw new DeveloperError('array is required');
  116.         }
  117.         //>>includeEnd('debug');
  119.         startingIndex = defaultValue(startingIndex, 0);
  121.         array[startingIndex++] = value.west;
  122.         array[startingIndex++] = value.south;
  123.         array[startingIndex++] = value.east;
  124.         array[startingIndex] = value.north;
  126.         return array;
  127.     };
  129.     /**
  130.      * Retrieves an instance from a packed array.
  131.      *
  132.      * @param {Number[]} array The packed array.
  133.      * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
  134.      * @param {Rectangle} [result] The object into which to store the result.
  135.      * @returns {Rectangle} The modified result parameter or a new Rectangle instance if one was not provided.
  136.      */
  137.     Rectangle.unpack = function(array, startingIndex, result) {
  138.         //>>includeStart('debug', pragmas.debug);
  139.         if (!defined(array)) {
  140.             throw new DeveloperError('array is required');
  141.         }
  142.         //>>includeEnd('debug');
  144.         startingIndex = defaultValue(startingIndex, 0);
  146.         if (!defined(result)) {
  147.             result = new Rectangle();
  148.         }
  150.         result.west = array[startingIndex++];
  151.         result.south = array[startingIndex++];
  152.         result.east = array[startingIndex++];
  153.         result.north = array[startingIndex];
  154.         return result;
  155.     };
  157.     /**
  158.      * Computes the width of a rectangle in radians.
  159.      * @param {Rectangle} rectangle The rectangle to compute the width of.
  160.      * @returns {Number} The width.
  161.      */
  162.     Rectangle.computeWidth = function(rectangle) {
  163.         //>>includeStart('debug', pragmas.debug);
  164.         if (!defined(rectangle)) {
  165.             throw new DeveloperError('rectangle is required.');
  166.         }
  167.         //>>includeEnd('debug');
  168.         var east = rectangle.east;
  169.         var west = rectangle.west;
  170.         if (east < west) {
  171.             east += CesiumMath.TWO_PI;
  172.         }
  173.         return east - west;
  174.     };
  176.     /**
  177.      * Computes the height of a rectangle in radians.
  178.      * @param {Rectangle} rectangle The rectangle to compute the height of.
  179.      * @returns {Number} The height.
  180.      */
  181.     Rectangle.computeHeight = function(rectangle) {
  182.         //>>includeStart('debug', pragmas.debug);
  183.         if (!defined(rectangle)) {
  184.             throw new DeveloperError('rectangle is required.');
  185.         }
  186.         //>>includeEnd('debug');
  187.         return rectangle.north - rectangle.south;
  188.     };
  190.     /**
  191.      * Creates an rectangle given the boundary longitude and latitude in degrees.
  192.      *
  193.      * @param {Number} [west=0.0] The westernmost longitude in degrees in the range [-180.0, 180.0].
  194.      * @param {Number} [south=0.0] The southernmost latitude in degrees in the range [-90.0, 90.0].
  195.      * @param {Number} [east=0.0] The easternmost longitude in degrees in the range [-180.0, 180.0].
  196.      * @param {Number} [north=0.0] The northernmost latitude in degrees in the range [-90.0, 90.0].
  197.      * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
  198.      * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
  199.      *
  200.      * @example
  201.      * var rectangle = Cesium.Rectangle.fromDegrees(0.0, 20.0, 10.0, 30.0);
  202.      */
  203.     Rectangle.fromDegrees = function(west, south, east, north, result) {
  204.         west = CesiumMath.toRadians(defaultValue(west, 0.0));
  205.         south = CesiumMath.toRadians(defaultValue(south, 0.0));
  206.         east = CesiumMath.toRadians(defaultValue(east, 0.0));
  207.         north = CesiumMath.toRadians(defaultValue(north, 0.0));
  209.         if (!defined(result)) {
  210.             return new Rectangle(west, south, east, north);
  211.         }
  213.         result.west = west;
  214.         result.south = south;
  215.         result.east = east;
  216.         result.north = north;
  218.         return result;
  219.     };
  221.     /**
  222.      * Creates the smallest possible Rectangle that encloses all positions in the provided array.
  223.      *
  224.      * @param {Cartographic[]} cartographics The list of Cartographic instances.
  225.      * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
  226.      * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
  227.      */
  228.     Rectangle.fromCartographicArray = function(cartographics, result) {
  229.         //>>includeStart('debug', pragmas.debug);
  230.         if (!defined(cartographics)) {
  231.             throw new DeveloperError('cartographics is required.');
  232.         }
  233.         //>>includeEnd('debug');
  235.         var west = Number.MAX_VALUE;
  236.         var east = -Number.MAX_VALUE;
  237.         var westOverIDL = Number.MAX_VALUE;
  238.         var eastOverIDL = -Number.MAX_VALUE;
  239.         var south = Number.MAX_VALUE;
  240.         var north = -Number.MAX_VALUE;
  242.         for ( var i = 0, len = cartographics.length; i < len; i++) {
  243.             var position = cartographics[i];
  244.             west = Math.min(west, position.longitude);
  245.             east = Math.max(east, position.longitude);
  246.             south = Math.min(south, position.latitude);
  247.             north = Math.max(north, position.latitude);
  249.             var lonAdjusted = position.longitude >= 0 ?  position.longitude : position.longitude +  CesiumMath.TWO_PI;
  250.             westOverIDL = Math.min(westOverIDL, lonAdjusted);
  251.             eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
  252.         }
  254.         if(east - west > eastOverIDL - westOverIDL) {
  255.             west = westOverIDL;
  256.             east = eastOverIDL;
  258.             if (east > CesiumMath.PI) {
  259.                 east = east - CesiumMath.TWO_PI;
  260.             }
  261.             if (west > CesiumMath.PI) {
  262.                 west = west - CesiumMath.TWO_PI;
  263.             }
  264.         }
  266.         if (!defined(result)) {
  267.             return new Rectangle(west, south, east, north);
  268.         }
  270.         result.west = west;
  271.         result.south = south;
  272.         result.east = east;
  273.         result.north = north;
  274.         return result;
  275.     };
  277.     /**
  278.      * Creates the smallest possible Rectangle that encloses all positions in the provided array.
  279.      *
  280.      * @param {Cartesian[]} cartesians The list of Cartesian instances.
  281.      * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid the cartesians are on.
  282.      * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
  283.      * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
  284.      */
  285.     Rectangle.fromCartesianArray = function(cartesians, ellipsoid, result) {
  286.         //>>includeStart('debug', pragmas.debug);
  287.         if (!defined(cartesians)) {
  288.             throw new DeveloperError('cartesians is required.');
  289.         }
  290.         //>>includeEnd('debug');
  292.         var west = Number.MAX_VALUE;
  293.         var east = -Number.MAX_VALUE;
  294.         var westOverIDL = Number.MAX_VALUE;
  295.         var eastOverIDL = -Number.MAX_VALUE;
  296.         var south = Number.MAX_VALUE;
  297.         var north = -Number.MAX_VALUE;
  299.         for ( var i = 0, len = cartesians.length; i < len; i++) {
  300.             var position = ellipsoid.cartesianToCartographic(cartesians[i]);
  301.             west = Math.min(west, position.longitude);
  302.             east = Math.max(east, position.longitude);
  303.             south = Math.min(south, position.latitude);
  304.             north = Math.max(north, position.latitude);
  306.             var lonAdjusted = position.longitude >= 0 ?  position.longitude : position.longitude +  CesiumMath.TWO_PI;
  307.             westOverIDL = Math.min(westOverIDL, lonAdjusted);
  308.             eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
  309.         }
  311.         if(east - west > eastOverIDL - westOverIDL) {
  312.             west = westOverIDL;
  313.             east = eastOverIDL;
  315.             if (east > CesiumMath.PI) {
  316.                 east = east - CesiumMath.TWO_PI;
  317.             }
  318.             if (west > CesiumMath.PI) {
  319.                 west = west - CesiumMath.TWO_PI;
  320.             }
  321.         }
  323.         if (!defined(result)) {
  324.             return new Rectangle(west, south, east, north);
  325.         }
  327.         result.west = west;
  328.         result.south = south;
  329.         result.east = east;
  330.         result.north = north;
  331.         return result;
  332.     };
  334.     /**
  335.      * Duplicates an Rectangle.
  336.      *
  337.      * @param {Rectangle} rectangle The rectangle to clone.
  338.      * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
  339.      * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided. (Returns undefined if rectangle is undefined)
  340.      */
  341.     Rectangle.clone = function(rectangle, result) {
  342.         if (!defined(rectangle)) {
  343.             return undefined;
  344.         }
  346.         if (!defined(result)) {
  347.             return new Rectangle(rectangle.west, rectangle.south, rectangle.east, rectangle.north);
  348.         }
  350.         result.west = rectangle.west;
  351.         result.south = rectangle.south;
  352.         result.east = rectangle.east;
  353.         result.north = rectangle.north;
  354.         return result;
  355.     };
  357.     /**
  358.      * Duplicates this Rectangle.
  359.      *
  360.      * @param {Rectangle} [result] The object onto which to store the result.
  361.      * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
  362.      */
  363.     Rectangle.prototype.clone = function(result) {
  364.         return Rectangle.clone(this, result);
  365.     };
  367.     /**
  368.      * Compares the provided Rectangle with this Rectangle componentwise and returns
  369.      * <code>true</code> if they are equal, <code>false</code> otherwise.
  370.      *
  371.      * @param {Rectangle} [other] The Rectangle to compare.
  372.      * @returns {Boolean} <code>true</code> if the Rectangles are equal, <code>false</code> otherwise.
  373.      */
  374.     Rectangle.prototype.equals = function(other) {
  375.         return Rectangle.equals(this, other);
  376.     };
  378.     /**
  379.      * Compares the provided rectangles and returns <code>true</code> if they are equal,
  380.      * <code>false</code> otherwise.
  381.      *
  382.      * @param {Rectangle} [left] The first Rectangle.
  383.      * @param {Rectangle} [right] The second Rectangle.
  384.      * @returns {Boolean} <code>true</code> if left and right are equal; otherwise <code>false</code>.
  385.      */
  386.     Rectangle.equals = function(left, right) {
  387.         return (left === right) ||
  388.                ((defined(left)) &&
  389.                 (defined(right)) &&
  390.                 (left.west === right.west) &&
  391.                 (left.south === right.south) &&
  392.                 (left.east === right.east) &&
  393.                 (left.north === right.north));
  394.     };
  396.     /**
  397.      * Compares the provided Rectangle with this Rectangle componentwise and returns
  398.      * <code>true</code> if they are within the provided epsilon,
  399.      * <code>false</code> otherwise.
  400.      *
  401.      * @param {Rectangle} [other] The Rectangle to compare.
  402.      * @param {Number} epsilon The epsilon to use for equality testing.
  403.      * @returns {Boolean} <code>true</code> if the Rectangles are within the provided epsilon, <code>false</code> otherwise.
  404.      */
  405.     Rectangle.prototype.equalsEpsilon = function(other, epsilon) {
  406.         //>>includeStart('debug', pragmas.debug);
  407.         if (typeof epsilon !== 'number') {
  408.             throw new DeveloperError('epsilon is required and must be a number.');
  409.         }
  410.         //>>includeEnd('debug');
  412.         return defined(other) &&
  413.                (Math.abs(this.west - other.west) <= epsilon) &&
  414.                (Math.abs(this.south - other.south) <= epsilon) &&
  415.                (Math.abs(this.east - other.east) <= epsilon) &&
  416.                (Math.abs(this.north - other.north) <= epsilon);
  417.     };
  419.     /**
  420.      * Checks an Rectangle's properties and throws if they are not in valid ranges.
  421.      *
  422.      * @param {Rectangle} rectangle The rectangle to validate
  423.      *
  424.      * @exception {DeveloperError} <code>north</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
  425.      * @exception {DeveloperError} <code>south</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
  426.      * @exception {DeveloperError} <code>east</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
  427.      * @exception {DeveloperError} <code>west</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
  428.      */
  429.     Rectangle.validate = function(rectangle) {
  430.         //>>includeStart('debug', pragmas.debug);
  431.         if (!defined(rectangle)) {
  432.             throw new DeveloperError('rectangle is required');
  433.         }
  435.         var north = rectangle.north;
  436.         if (typeof north !== 'number') {
  437.             throw new DeveloperError('north is required to be a number.');
  438.         }
  440.         if (north < -CesiumMath.PI_OVER_TWO || north > CesiumMath.PI_OVER_TWO) {
  441.             throw new DeveloperError('north must be in the interval [-Pi/2, Pi/2].');
  442.         }
  444.         var south = rectangle.south;
  445.         if (typeof south !== 'number') {
  446.             throw new DeveloperError('south is required to be a number.');
  447.         }
  449.         if (south < -CesiumMath.PI_OVER_TWO || south > CesiumMath.PI_OVER_TWO) {
  450.             throw new DeveloperError('south must be in the interval [-Pi/2, Pi/2].');
  451.         }
  453.         var west = rectangle.west;
  454.         if (typeof west !== 'number') {
  455.             throw new DeveloperError('west is required to be a number.');
  456.         }
  458.         if (west < -Math.PI || west > Math.PI) {
  459.             throw new DeveloperError('west must be in the interval [-Pi, Pi].');
  460.         }
  462.         var east = rectangle.east;
  463.         if (typeof east !== 'number') {
  464.             throw new DeveloperError('east is required to be a number.');
  465.         }
  467.         if (east < -Math.PI || east > Math.PI) {
  468.             throw new DeveloperError('east must be in the interval [-Pi, Pi].');
  469.         }
  470.         //>>includeEnd('debug');
  471.     };
  473.     /**
  474.      * Computes the southwest corner of an rectangle.
  475.      *
  476.      * @param {Rectangle} rectangle The rectangle for which to find the corner
  477.      * @param {Cartographic} [result] The object onto which to store the result.
  478.      * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
  479.      */
  480.     Rectangle.southwest = function(rectangle, result) {
  481.         //>>includeStart('debug', pragmas.debug);
  482.         if (!defined(rectangle)) {
  483.             throw new DeveloperError('rectangle is required');
  484.         }
  485.         //>>includeEnd('debug');
  487.         if (!defined(result)) {
  488.             return new Cartographic(rectangle.west, rectangle.south);
  489.         }
  490.         result.longitude = rectangle.west;
  491.         result.latitude = rectangle.south;
  492.         result.height = 0.0;
  493.         return result;
  494.     };
  496.     /**
  497.      * Computes the northwest corner of an rectangle.
  498.      *
  499.      * @param {Rectangle} rectangle The rectangle for which to find the corner
  500.      * @param {Cartographic} [result] The object onto which to store the result.
  501.      * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
  502.      */
  503.     Rectangle.northwest = function(rectangle, result) {
  504.         //>>includeStart('debug', pragmas.debug);
  505.         if (!defined(rectangle)) {
  506.             throw new DeveloperError('rectangle is required');
  507.         }
  508.         //>>includeEnd('debug');
  510.         if (!defined(result)) {
  511.             return new Cartographic(rectangle.west, rectangle.north);
  512.         }
  513.         result.longitude = rectangle.west;
  514.         result.latitude = rectangle.north;
  515.         result.height = 0.0;
  516.         return result;
  517.     };
  519.     /**
  520.      * Computes the northeast corner of an rectangle.
  521.      *
  522.      * @param {Rectangle} rectangle The rectangle for which to find the corner
  523.      * @param {Cartographic} [result] The object onto which to store the result.
  524.      * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
  525.      */
  526.     Rectangle.northeast = function(rectangle, result) {
  527.         //>>includeStart('debug', pragmas.debug);
  528.         if (!defined(rectangle)) {
  529.             throw new DeveloperError('rectangle is required');
  530.         }
  531.         //>>includeEnd('debug');
  533.         if (!defined(result)) {
  534.             return new Cartographic(rectangle.east, rectangle.north);
  535.         }
  536.         result.longitude = rectangle.east;
  537.         result.latitude = rectangle.north;
  538.         result.height = 0.0;
  539.         return result;
  540.     };
  542.     /**
  543.      * Computes the southeast corner of an rectangle.
  544.      *
  545.      * @param {Rectangle} rectangle The rectangle for which to find the corner
  546.      * @param {Cartographic} [result] The object onto which to store the result.
  547.      * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
  548.      */
  549.     Rectangle.southeast = function(rectangle, result) {
  550.         //>>includeStart('debug', pragmas.debug);
  551.         if (!defined(rectangle)) {
  552.             throw new DeveloperError('rectangle is required');
  553.         }
  554.         //>>includeEnd('debug');
  556.         if (!defined(result)) {
  557.             return new Cartographic(rectangle.east, rectangle.south);
  558.         }
  559.         result.longitude = rectangle.east;
  560.         result.latitude = rectangle.south;
  561.         result.height = 0.0;
  562.         return result;
  563.     };
  565.     /**
  566.      * Computes the center of an rectangle.
  567.      *
  568.      * @param {Rectangle} rectangle The rectangle for which to find the center
  569.      * @param {Cartographic} [result] The object onto which to store the result.
  570.      * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
  571.      */
  572.     Rectangle.center = function(rectangle, result) {
  573.         //>>includeStart('debug', pragmas.debug);
  574.         if (!defined(rectangle)) {
  575.             throw new DeveloperError('rectangle is required');
  576.         }
  577.         //>>includeEnd('debug');
  579.         var east = rectangle.east;
  580.         var west = rectangle.west;
  582.         if (east < west) {
  583.             east += CesiumMath.TWO_PI;
  584.         }
  586.         var longitude = CesiumMath.negativePiToPi((west + east) * 0.5);
  587.         var latitude = (rectangle.south + rectangle.north) * 0.5;
  589.         if (!defined(result)) {
  590.             return new Cartographic(longitude, latitude);
  591.         }
  593.         result.longitude = longitude;
  594.         result.latitude = latitude;
  595.         result.height = 0.0;
  596.         return result;
  597.     };
  599.     /**
  600.      * Computes the intersection of two rectangles.  This function assumes that the rectangle's coordinates are
  601.      * latitude and longitude in radians and produces a correct intersection, taking into account the fact that
  602.      * the same angle can be represented with multiple values as well as the wrapping of longitude at the
  603.      * anti-meridian.  For a simple intersection that ignores these factors and can be used with projected
  604.      * coordinates, see {@link Rectangle.simpleIntersection}.
  605.      *
  606.      * @param {Rectangle} rectangle On rectangle to find an intersection
  607.      * @param {Rectangle} otherRectangle Another rectangle to find an intersection
  608.      * @param {Rectangle} [result] The object onto which to store the result.
  609.      * @returns {Rectangle|undefined} The modified result parameter, a new Rectangle instance if none was provided or undefined if there is no intersection.
  610.      */
  611.     Rectangle.intersection = function(rectangle, otherRectangle, result) {
  612.         //>>includeStart('debug', pragmas.debug);
  613.         if (!defined(rectangle)) {
  614.             throw new DeveloperError('rectangle is required');
  615.         }
  616.         if (!defined(otherRectangle)) {
  617.             throw new DeveloperError('otherRectangle is required.');
  618.         }
  619.         //>>includeEnd('debug');
  621.         var rectangleEast = rectangle.east;
  622.         var rectangleWest = rectangle.west;
  624.         var otherRectangleEast = otherRectangle.east;
  625.         var otherRectangleWest = otherRectangle.west;
  627.         if (rectangleEast < rectangleWest && otherRectangleEast > 0.0) {
  628.             rectangleEast += CesiumMath.TWO_PI;
  629.         } else if (otherRectangleEast < otherRectangleWest && rectangleEast > 0.0) {
  630.             otherRectangleEast += CesiumMath.TWO_PI;
  631.         }
  633.         if (rectangleEast < rectangleWest && otherRectangleWest < 0.0) {
  634.             otherRectangleWest += CesiumMath.TWO_PI;
  635.         } else if (otherRectangleEast < otherRectangleWest && rectangleWest < 0.0) {
  636.             rectangleWest += CesiumMath.TWO_PI;
  637.         }
  639.         var west = CesiumMath.negativePiToPi(Math.max(rectangleWest, otherRectangleWest));
  640.         var east = CesiumMath.negativePiToPi(Math.min(rectangleEast, otherRectangleEast));
  642.         if ((rectangle.west < rectangle.east || otherRectangle.west < otherRectangle.east) && east <= west) {
  643.             return undefined;
  644.         }
  646.         var south = Math.max(rectangle.south, otherRectangle.south);
  647.         var north = Math.min(rectangle.north, otherRectangle.north);
  649.         if (south >= north) {
  650.             return undefined;
  651.         }
  653.         if (!defined(result)) {
  654.             return new Rectangle(west, south, east, north);
  655.         }
  656.         result.west = west;
  657.         result.south = south;
  658.         result.east = east;
  659.         result.north = north;
  660.         return result;
  661.     };
  663.     /**
  664.      * Computes a simple intersection of two rectangles.  Unlike {@link Rectangle.intersection}, this function
  665.      * does not attempt to put the angular coordinates into a consistent range or to account for crossing the
  666.      * anti-meridian.  As such, it can be used for rectangles where the coordinates are not simply latitude
  667.      * and longitude (i.e. projected coordinates).
  668.      *
  669.      * @param {Rectangle} rectangle On rectangle to find an intersection
  670.      * @param {Rectangle} otherRectangle Another rectangle to find an intersection
  671.      * @param {Rectangle} [result] The object onto which to store the result.
  672.      * @returns {Rectangle|undefined} The modified result parameter, a new Rectangle instance if none was provided or undefined if there is no intersection.
  673.      */
  674.     Rectangle.simpleIntersection = function(rectangle, otherRectangle, result) {
  675.         //>>includeStart('debug', pragmas.debug);
  676.         if (!defined(rectangle)) {
  677.             throw new DeveloperError('rectangle is required');
  678.         }
  679.         if (!defined(otherRectangle)) {
  680.             throw new DeveloperError('otherRectangle is required.');
  681.         }
  682.         //>>includeEnd('debug');
  684.         var west = Math.max(rectangle.west, otherRectangle.west);
  685.         var south = Math.max(rectangle.south, otherRectangle.south);
  686.         var east = Math.min(rectangle.east, otherRectangle.east);
  687.         var north = Math.min(rectangle.north, otherRectangle.north);
  689.         if (south >= north || west >= east) {
  690.             return undefined;
  691.         }
  693.         if (!defined(result)) {
  694.             return new Rectangle(west, south, east, north);
  695.         }
  697.         result.west = west;
  698.         result.south = south;
  699.         result.east = east;
  700.         result.north = north;
  701.         return result;
  702.     };
  704.     /**
  705.      * Computes a rectangle that is the union of two rectangles.
  706.      *
  707.      * @param {Rectangle} rectangle A rectangle to enclose in rectangle.
  708.      * @param {Rectangle} otherRectangle A rectangle to enclose in a rectangle.
  709.      * @param {Rectangle} [result] The object onto which to store the result.
  710.      * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
  711.      */
  712.     Rectangle.union = function(rectangle, otherRectangle, result) {
  713.         //>>includeStart('debug', pragmas.debug);
  714.         if (!defined(rectangle)) {
  715.             throw new DeveloperError('rectangle is required');
  716.         }
  717.         if (!defined(otherRectangle)) {
  718.             throw new DeveloperError('otherRectangle is required.');
  719.         }
  720.         //>>includeEnd('debug');
  722.         if (!defined(result)) {
  723.             result = new Rectangle();
  724.         }
  726.         result.west = Math.min(rectangle.west, otherRectangle.west);
  727.         result.south = Math.min(rectangle.south, otherRectangle.south);
  728.         result.east = Math.max(rectangle.east, otherRectangle.east);
  729.         result.north = Math.max(rectangle.north, otherRectangle.north);
  731.         return result;
  732.     };
  734.     /**
  735.      * Computes a rectangle by enlarging the provided rectangle until it contains the provided cartographic.
  736.      *
  737.      * @param {Rectangle} rectangle A rectangle to expand.
  738.      * @param {Cartographic} cartographic A cartographic to enclose in a rectangle.
  739.      * @param {Rectangle} [result] The object onto which to store the result.
  740.      * @returns {Rectangle} The modified result parameter or a new Rectangle instance if one was not provided.
  741.      */
  742.     Rectangle.expand = function(rectangle, cartographic, result) {
  743.         //>>includeStart('debug', pragmas.debug);
  744.         if (!defined(rectangle)) {
  745.             throw new DeveloperError('rectangle is required.');
  746.         }
  747.         if (!defined(cartographic)) {
  748.             throw new DeveloperError('cartographic is required.');
  749.         }
  750.         //>>includeEnd('debug');
  752.         if (!defined(result)) {
  753.             result = new Rectangle();
  754.         }
  756.         result.west = Math.min(rectangle.west, cartographic.longitude);
  757.         result.south = Math.min(rectangle.south, cartographic.latitude);
  758.         result.east = Math.max(rectangle.east, cartographic.longitude);
  759.         result.north = Math.max(rectangle.north, cartographic.latitude);
  761.         return result;
  762.     };
  764.     /**
  765.      * Returns true if the cartographic is on or inside the rectangle, false otherwise.
  766.      *
  767.      * @param {Rectangle} rectangle The rectangle
  768.      * @param {Cartographic} cartographic The cartographic to test.
  769.      * @returns {Boolean} true if the provided cartographic is inside the rectangle, false otherwise.
  770.      */
  771.     Rectangle.contains = function(rectangle, cartographic) {
  772.         //>>includeStart('debug', pragmas.debug);
  773.         if (!defined(rectangle)) {
  774.             throw new DeveloperError('rectangle is required');
  775.         }
  776.         if (!defined(cartographic)) {
  777.             throw new DeveloperError('cartographic is required.');
  778.         }
  779.         //>>includeEnd('debug');
  781.         var longitude = cartographic.longitude;
  782.         var latitude = cartographic.latitude;
  784.         var west = rectangle.west;
  785.         var east = rectangle.east;
  787.         if (east < west) {
  788.             east += CesiumMath.TWO_PI;
  789.             if (longitude < 0.0) {
  790.                 longitude += CesiumMath.TWO_PI;
  791.             }
  792.         }
  793.         return (longitude > west || CesiumMath.equalsEpsilon(longitude, west, CesiumMath.EPSILON14)) &&
  794.                (longitude < east || CesiumMath.equalsEpsilon(longitude, east, CesiumMath.EPSILON14)) &&
  795.                latitude >= rectangle.south &&
  796.                latitude <= rectangle.north;
  797.     };
  799.     var subsampleLlaScratch = new Cartographic();
  800.     /**
  801.      * Samples an rectangle so that it includes a list of Cartesian points suitable for passing to
  802.      * {@link BoundingSphere#fromPoints}.  Sampling is necessary to account
  803.      * for rectangles that cover the poles or cross the equator.
  804.      *
  805.      * @param {Rectangle} rectangle The rectangle to subsample.
  806.      * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid to use.
  807.      * @param {Number} [surfaceHeight=0.0] The height of the rectangle above the ellipsoid.
  808.      * @param {Cartesian3[]} [result] The array of Cartesians onto which to store the result.
  809.      * @returns {Cartesian3[]} The modified result parameter or a new Array of Cartesians instances if none was provided.
  810.      */
  811.     Rectangle.subsample = function(rectangle, ellipsoid, surfaceHeight, result) {
  812.         //>>includeStart('debug', pragmas.debug);
  813.         if (!defined(rectangle)) {
  814.             throw new DeveloperError('rectangle is required');
  815.         }
  816.         //>>includeEnd('debug');
  818.         ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
  819.         surfaceHeight = defaultValue(surfaceHeight, 0.0);
  821.         if (!defined(result)) {
  822.             result = [];
  823.         }
  824.         var length = 0;
  826.         var north = rectangle.north;
  827.         var south = rectangle.south;
  828.         var east = rectangle.east;
  829.         var west = rectangle.west;
  831.         var lla = subsampleLlaScratch;
  832.         lla.height = surfaceHeight;
  834.         lla.longitude = west;
  835.         lla.latitude = north;
  836.         result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
  837.         length++;
  839.         lla.longitude = east;
  840.         result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
  841.         length++;
  843.         lla.latitude = south;
  844.         result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
  845.         length++;
  847.         lla.longitude = west;
  848.         result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
  849.         length++;
  851.         if (north < 0.0) {
  852.             lla.latitude = north;
  853.         } else if (south > 0.0) {
  854.             lla.latitude = south;
  855.         } else {
  856.             lla.latitude = 0.0;
  857.         }
  859.         for ( var i = 1; i < 8; ++i) {
  860.             lla.longitude = -Math.PI + i * CesiumMath.PI_OVER_TWO;
  861.             if (Rectangle.contains(rectangle, lla)) {
  862.                 result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
  863.                 length++;
  864.             }
  865.         }
  867.         if (lla.latitude === 0.0) {
  868.             lla.longitude = west;
  869.             result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
  870.             length++;
  871.             lla.longitude = east;
  872.             result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
  873.             length++;
  874.         }
  875.         result.length = length;
  876.         return result;
  877.     };
  879.     /**
  880.      * The largest possible rectangle.
  881.      *
  882.      * @type {Rectangle}
  883.      * @constant
  884.     */
  885.     Rectangle.MAX_VALUE = freezeObject(new Rectangle(-Math.PI, -CesiumMath.PI_OVER_TWO, Math.PI, CesiumMath.PI_OVER_TWO));
  887.     return Rectangle;
  888. });