dc-sdk/libs/cesium/Source/Core/RectangleGeometryLibrary.js

import Cartesian3 from './Cartesian3.js';
import Cartographic from './Cartographic.js';
import defined from './defined.js';
import DeveloperError from './DeveloperError.js';
import GeographicProjection from './GeographicProjection.js';
import CesiumMath from './Math.js';
import Matrix2 from './Matrix2.js';
import Rectangle from './Rectangle.js';

    var cos = Math.cos;
    var sin = Math.sin;
    var sqrt = Math.sqrt;

    /**
     * @private
     */
    var RectangleGeometryLibrary = {};

    /**
     * @private
     */
    RectangleGeometryLibrary.computePosition = function(computedOptions, ellipsoid, computeST, row, col, position, st) {
        var radiiSquared = ellipsoid.radiiSquared;
        var nwCorner = computedOptions.nwCorner;
        var rectangle = computedOptions.boundingRectangle;

        var stLatitude = nwCorner.latitude - computedOptions.granYCos * row + col * computedOptions.granXSin;
        var cosLatitude = cos(stLatitude);
        var nZ = sin(stLatitude);
        var kZ = radiiSquared.z * nZ;

        var stLongitude = nwCorner.longitude + row * computedOptions.granYSin + col * computedOptions.granXCos;
        var nX = cosLatitude * cos(stLongitude);
        var nY = cosLatitude * sin(stLongitude);

        var kX = radiiSquared.x * nX;
        var kY = radiiSquared.y * nY;

        var gamma = sqrt((kX * nX) + (kY * nY) + (kZ * nZ));

        position.x = kX / gamma;
        position.y = kY / gamma;
        position.z = kZ / gamma;

        if (computeST) {
            var stNwCorner = computedOptions.stNwCorner;
            if (defined(stNwCorner)) {
                stLatitude = stNwCorner.latitude - computedOptions.stGranYCos * row + col * computedOptions.stGranXSin;
                stLongitude = stNwCorner.longitude + row * computedOptions.stGranYSin + col * computedOptions.stGranXCos;

                st.x = (stLongitude - computedOptions.stWest) * computedOptions.lonScalar;
                st.y = (stLatitude - computedOptions.stSouth) * computedOptions.latScalar;
            } else {
                st.x = (stLongitude - rectangle.west) * computedOptions.lonScalar;
                st.y = (stLatitude - rectangle.south) * computedOptions.latScalar;
            }
        }
    };

    var rotationMatrixScratch = new Matrix2();
    var nwCartesian = new Cartesian3();
    var centerScratch = new Cartographic();
    var centerCartesian = new Cartesian3();
    var proj = new GeographicProjection();

    function getRotationOptions(nwCorner, rotation, granularityX, granularityY, center, width, height) {
        var cosRotation = Math.cos(rotation);
        var granYCos = granularityY * cosRotation;
        var granXCos = granularityX * cosRotation;

        var sinRotation = Math.sin(rotation);
        var granYSin = granularityY * sinRotation;
        var granXSin = granularityX * sinRotation;

        nwCartesian = proj.project(nwCorner, nwCartesian);

        nwCartesian = Cartesian3.subtract(nwCartesian, centerCartesian, nwCartesian);
        var rotationMatrix = Matrix2.fromRotation(rotation, rotationMatrixScratch);
        nwCartesian = Matrix2.multiplyByVector(rotationMatrix, nwCartesian, nwCartesian);
        nwCartesian = Cartesian3.add(nwCartesian, centerCartesian, nwCartesian);
        nwCorner = proj.unproject(nwCartesian, nwCorner);

        width -= 1;
        height -= 1;

        var latitude = nwCorner.latitude;
        var latitude0 = latitude + width * granXSin;
        var latitude1 = latitude - granYCos * height;
        var latitude2 = latitude - granYCos * height + width * granXSin;

        var north = Math.max(latitude, latitude0, latitude1, latitude2);
        var south = Math.min(latitude, latitude0, latitude1, latitude2);

        var longitude = nwCorner.longitude;
        var longitude0 = longitude + width * granXCos;
        var longitude1 = longitude + height * granYSin;
        var longitude2 = longitude + height * granYSin + width * granXCos;

        var east = Math.max(longitude, longitude0, longitude1, longitude2);
        var west = Math.min(longitude, longitude0, longitude1, longitude2);

        return {
            north: north,
            south: south,
            east: east,
            west: west,
            granYCos : granYCos,
            granYSin : granYSin,
            granXCos : granXCos,
            granXSin : granXSin,
            nwCorner : nwCorner
        };
    }

    /**
     * @private
     */
    RectangleGeometryLibrary.computeOptions = function(rectangle, granularity, rotation, stRotation, boundingRectangleScratch, nwCornerResult, stNwCornerResult) {
        var east = rectangle.east;
        var west = rectangle.west;
        var north = rectangle.north;
        var south = rectangle.south;

        var northCap = false;
        var southCap = false;

        if (north === CesiumMath.PI_OVER_TWO) {
            northCap = true;
        }
        if (south === -CesiumMath.PI_OVER_TWO) {
            southCap = true;
        }

        var width;
        var height;
        var granularityX;
        var granularityY;
        var dx;
        var dy = north - south;
        if (west > east) {
            dx = (CesiumMath.TWO_PI - west + east);
        } else {
            dx = east - west;
        }

        width = Math.ceil(dx / granularity) + 1;
        height = Math.ceil(dy / granularity) + 1;
        granularityX = dx / (width - 1);
        granularityY = dy / (height - 1);

        var nwCorner = Rectangle.northwest(rectangle, nwCornerResult);
        var center = Rectangle.center(rectangle, centerScratch);
        if (rotation !== 0 || stRotation !== 0) {
            if (center.longitude < nwCorner.longitude) {
                center.longitude += CesiumMath.TWO_PI;
            }
            centerCartesian = proj.project(center, centerCartesian);
        }

        var granYCos = granularityY;
        var granXCos = granularityX;
        var granYSin = 0.0;
        var granXSin = 0.0;

        var boundingRectangle = Rectangle.clone(rectangle, boundingRectangleScratch);

        var computedOptions = {
            granYCos : granYCos,
            granYSin : granYSin,
            granXCos : granXCos,
            granXSin : granXSin,
            nwCorner : nwCorner,
            boundingRectangle : boundingRectangle,
            width: width,
            height: height,
            northCap: northCap,
            southCap: southCap
        };

        if (rotation !== 0) {
            var rotationOptions = getRotationOptions(nwCorner, rotation, granularityX, granularityY, center, width, height);
            north = rotationOptions.north;
            south = rotationOptions.south;
            east = rotationOptions.east;
            west = rotationOptions.west;

            //>>includeStart('debug', pragmas.debug);
            if (north < -CesiumMath.PI_OVER_TWO || north > CesiumMath.PI_OVER_TWO ||
                south < -CesiumMath.PI_OVER_TWO || south > CesiumMath.PI_OVER_TWO) {
                throw new DeveloperError('Rotated rectangle is invalid.  It crosses over either the north or south pole.');
            }
            //>>includeEnd('debug')

            computedOptions.granYCos = rotationOptions.granYCos;
            computedOptions.granYSin = rotationOptions.granYSin;
            computedOptions.granXCos = rotationOptions.granXCos;
            computedOptions.granXSin = rotationOptions.granXSin;

            boundingRectangle.north = north;
            boundingRectangle.south = south;
            boundingRectangle.east = east;
            boundingRectangle.west = west;
        }

        if (stRotation !== 0) {
            rotation = rotation - stRotation;
            var stNwCorner = Rectangle.northwest(boundingRectangle, stNwCornerResult);

            var stRotationOptions = getRotationOptions(stNwCorner, rotation, granularityX, granularityY, center, width, height);

            computedOptions.stGranYCos =  stRotationOptions.granYCos;
            computedOptions.stGranXCos = stRotationOptions.granXCos;
            computedOptions.stGranYSin = stRotationOptions.granYSin;
            computedOptions.stGranXSin = stRotationOptions.granXSin;
            computedOptions.stNwCorner = stNwCorner;
            computedOptions.stWest = stRotationOptions.west;
            computedOptions.stSouth = stRotationOptions.south;
        }

        return computedOptions;
    };
export default RectangleGeometryLibrary;