@itwin/core-orbitgt 4.0.0-dev.44 → 4.0.0-dev.48

package/lib/cjs/spatial/ecrs/projection/LambertConical2SP.d.ts

@@ -1,121 +1,121 @@
-/** @packageDocumentation
- * @module OrbitGT
- */
-declare type int32 = number;
-declare type float64 = number;
-import { Coordinate } from "../../geom/Coordinate";
-import { CRS } from "../CRS";
-import { Ellipsoid } from "../Ellipsoid";
-import { Operation } from "../Operation";
-import { OperationMethod } from "../OperationMethod";
-import { ParameterValueList } from "../ParameterValueList";
-/**
- * Class LambertConical2SP defines a Lambert Conical Conformal map projection with 2 standard parallels.
- *
- * The 'source' CRS is the geographic CRS.
- * The 'target' CRS is the projected CRS.
- *
- * Based on the following document:
- *
- * Coordinate Conversions and Transformations including Formulas
- * Guidance Note Number 7, part 2
- * Revised May 2005
- * Available at: http://www.epsg.org/
- *
- * Formulas: see 1.4.1.1 -> 1.4.1.4
- *
- * @version 1.0 July 2005
- */
-/** @internal */
-export declare class LambertConical2SP extends OperationMethod {
-    /** The code of this method */
-    static readonly METHOD_CODE: int32;
-    /** The value of PI */
-    private static readonly PI;
-    /** The half value of PI */
-    private static readonly hPI;
-    /** Latitude of false origin */
-    private _latF;
-    /** Longitude of false origin (the central meridian) */
-    private _lonF;
-    /** Latitude of first standard parallel */
-    private _lat1;
-    /** Latitude of second standard parallel */
-    private _lat2;
-    /** Easting at false origin */
-    private _eF;
-    /** Northing at false origin */
-    private _nF;
-    private _e;
-    private _a;
-    private _m1;
-    private _m2;
-    private _t1;
-    private _t2;
-    private _tF;
-    private _n;
-    private _F;
-    private _rF;
-    /**
-       * Create a new projection.
-       * @param parameters the values of the parameters.
-       */
-    constructor(parameters: ParameterValueList);
-    /**
-       * Get the sign of a number.
-       */
-    private static sign;
-    /**
-       * Get the square of a number.
-       */
-    private static square;
-    /**
-       * Calculate M.
-       */
-    private static calcM;
-    /**
-       * Calculate T.
-       */
-    private static calcT;
-    /**
-       * Calculate R.
-       */
-    private static calcR;
-    /**
-       * Initialize the projection.
-       * @param ellipsoid the ellipsoid to use.
-       * @return this projection (for convenience).
-       */
-    initializeProjection(ellipsoid: Ellipsoid): LambertConical2SP;
-    /**
-       * Do the projection.
-       * @param lon the longitude (radians).
-       * @param lat the latitude (radians).
-       * @param projected the target projected coordinate (X and Y will be set).
-       */
-    toProjection(lon: float64, lat: float64, projected: Coordinate): void;
-    /**
-       * Do the inverse projection.
-       * @param x the easting.
-       * @param y the northing.
-       * @param geographic the target geographic coordinate (X/Lon and Y/Lat will be set) (radians).
-       */
-    toGeoGraphic(x: float64, y: float64, geographic: Coordinate): void;
-    /**
-       * OperationMethod method.
-       * @see OperationMethod#initialize
-       */
-    initialize(operation: Operation): void;
-    /**
-       * OperationMethod interface method.
-       * @see OperationMethod#forward
-       */
-    forward(sourceCRS: CRS, source: Coordinate, targetCRS: CRS, target: Coordinate): void;
-    /**
-       * OperationMethod interface method.
-       * @see OperationMethod#reverse
-       */
-    reverse(sourceCRS: CRS, source: Coordinate, targetCRS: CRS, target: Coordinate): void;
-}
-export {};
+/** @packageDocumentation
+ * @module OrbitGT
+ */
+declare type int32 = number;
+declare type float64 = number;
+import { Coordinate } from "../../geom/Coordinate";
+import { CRS } from "../CRS";
+import { Ellipsoid } from "../Ellipsoid";
+import { Operation } from "../Operation";
+import { OperationMethod } from "../OperationMethod";
+import { ParameterValueList } from "../ParameterValueList";
+/**
+ * Class LambertConical2SP defines a Lambert Conical Conformal map projection with 2 standard parallels.
+ *
+ * The 'source' CRS is the geographic CRS.
+ * The 'target' CRS is the projected CRS.
+ *
+ * Based on the following document:
+ *
+ * Coordinate Conversions and Transformations including Formulas
+ * Guidance Note Number 7, part 2
+ * Revised May 2005
+ * Available at: http://www.epsg.org/
+ *
+ * Formulas: see 1.4.1.1 -> 1.4.1.4
+ *
+ * @version 1.0 July 2005
+ */
+/** @internal */
+export declare class LambertConical2SP extends OperationMethod {
+    /** The code of this method */
+    static readonly METHOD_CODE: int32;
+    /** The value of PI */
+    private static readonly PI;
+    /** The half value of PI */
+    private static readonly hPI;
+    /** Latitude of false origin */
+    private _latF;
+    /** Longitude of false origin (the central meridian) */
+    private _lonF;
+    /** Latitude of first standard parallel */
+    private _lat1;
+    /** Latitude of second standard parallel */
+    private _lat2;
+    /** Easting at false origin */
+    private _eF;
+    /** Northing at false origin */
+    private _nF;
+    private _e;
+    private _a;
+    private _m1;
+    private _m2;
+    private _t1;
+    private _t2;
+    private _tF;
+    private _n;
+    private _F;
+    private _rF;
+    /**
+       * Create a new projection.
+       * @param parameters the values of the parameters.
+       */
+    constructor(parameters: ParameterValueList);
+    /**
+       * Get the sign of a number.
+       */
+    private static sign;
+    /**
+       * Get the square of a number.
+       */
+    private static square;
+    /**
+       * Calculate M.
+       */
+    private static calcM;
+    /**
+       * Calculate T.
+       */
+    private static calcT;
+    /**
+       * Calculate R.
+       */
+    private static calcR;
+    /**
+       * Initialize the projection.
+       * @param ellipsoid the ellipsoid to use.
+       * @return this projection (for convenience).
+       */
+    initializeProjection(ellipsoid: Ellipsoid): LambertConical2SP;
+    /**
+       * Do the projection.
+       * @param lon the longitude (radians).
+       * @param lat the latitude (radians).
+       * @param projected the target projected coordinate (X and Y will be set).
+       */
+    toProjection(lon: float64, lat: float64, projected: Coordinate): void;
+    /**
+       * Do the inverse projection.
+       * @param x the easting.
+       * @param y the northing.
+       * @param geographic the target geographic coordinate (X/Lon and Y/Lat will be set) (radians).
+       */
+    toGeoGraphic(x: float64, y: float64, geographic: Coordinate): void;
+    /**
+       * OperationMethod method.
+       * @see OperationMethod#initialize
+       */
+    initialize(operation: Operation): void;
+    /**
+       * OperationMethod interface method.
+       * @see OperationMethod#forward
+       */
+    forward(sourceCRS: CRS, source: Coordinate, targetCRS: CRS, target: Coordinate): void;
+    /**
+       * OperationMethod interface method.
+       * @see OperationMethod#reverse
+       */
+    reverse(sourceCRS: CRS, source: Coordinate, targetCRS: CRS, target: Coordinate): void;
+}
+export {};
 //# sourceMappingURL=LambertConical2SP.d.ts.map

package/lib/cjs/spatial/ecrs/projection/LambertConical2SP.js

@@ -1,180 +1,180 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module OrbitGT
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LambertConical2SP = void 0;
-const OperationMethod_1 = require("../OperationMethod");
-/**
- * Class LambertConical2SP defines a Lambert Conical Conformal map projection with 2 standard parallels.
- *
- * The 'source' CRS is the geographic CRS.
- * The 'target' CRS is the projected CRS.
- *
- * Based on the following document:
- *
- * Coordinate Conversions and Transformations including Formulas
- * Guidance Note Number 7, part 2
- * Revised May 2005
- * Available at: http://www.epsg.org/
- *
- * Formulas: see 1.4.1.1 -> 1.4.1.4
- *
- * @version 1.0 July 2005
- */
-/** @internal */
-class LambertConical2SP extends OperationMethod_1.OperationMethod {
-    /**
-       * Create a new projection.
-       * @param parameters the values of the parameters.
-       */
-    constructor(parameters) {
-        super(LambertConical2SP.METHOD_CODE, "Lambert Conic Conformal (2SP)", parameters);
-        /* Store the parameters */
-        this._latF = parameters.getValue(8821);
-        this._lonF = parameters.getValue(8822);
-        this._lat1 = parameters.getValue(8823);
-        this._lat2 = parameters.getValue(8824);
-        this._eF = parameters.getValue(8826);
-        this._nF = parameters.getValue(8827);
-    }
-    /**
-       * Get the sign of a number.
-       */
-    static sign(v) {
-        return (v < 0.0) ? (-1.0) : (1.0);
-    }
-    /**
-       * Get the square of a number.
-       */
-    static square(v) {
-        return (v * v);
-    }
-    /**
-       * Calculate M.
-       */
-    static calcM(e, lat) {
-        return Math.cos(lat) / Math.sqrt(1.0 - LambertConical2SP.square(e * Math.sin(lat)));
-    }
-    /**
-       * Calculate T.
-       */
-    static calcT(e, lat) {
-        return Math.tan(Math.PI * 0.25 - lat * 0.5) / Math.pow((1.0 - e * Math.sin(lat)) / (1.0 + e * Math.sin(lat)), e * 0.5);
-    }
-    /**
-       * Calculate R.
-       */
-    static calcR(a, F, t, n) {
-        if (Math.abs(t) < 1.0e-6)
-            return 0.0;
-        return a * F * Math.pow(t, n);
-    }
-    /**
-       * Initialize the projection.
-       * @param ellipsoid the ellipsoid to use.
-       * @return this projection (for convenience).
-       */
-    initializeProjection(ellipsoid) {
-        /* Get the ellipsoid parameters */
-        this._e = ellipsoid.getE();
-        this._a = ellipsoid.getA();
-        /* Make the calculation */
-        this._m1 = LambertConical2SP.calcM(this._e, this._lat1);
-        this._m2 = LambertConical2SP.calcM(this._e, this._lat2);
-        this._t1 = LambertConical2SP.calcT(this._e, this._lat1);
-        this._t2 = LambertConical2SP.calcT(this._e, this._lat2);
-        this._tF = LambertConical2SP.calcT(this._e, this._latF);
-        this._n = (Math.log(this._m1) - Math.log(this._m2)) / (Math.log(this._t1) - Math.log(this._t2));
-        this._F = this._m1 / (this._n * Math.pow(this._t1, this._n));
-        this._rF = LambertConical2SP.calcR(this._a, this._F, this._tF, this._n);
-        /* Return the projection */
-        return this;
-    }
-    /**
-       * Do the projection.
-       * @param lon the longitude (radians).
-       * @param lat the latitude (radians).
-       * @param projected the target projected coordinate (X and Y will be set).
-       */
-    toProjection(lon, lat, projected) {
-        /* Make the calculation */
-        const t = LambertConical2SP.calcT(this._e, lat);
-        const r = LambertConical2SP.calcR(this._a, this._F, t, this._n);
-        const theta = this._n * (lon - this._lonF);
-        const E = this._eF + r * Math.sin(theta);
-        const N = this._nF + this._rF - r * Math.cos(theta);
-        /* Save the position */
-        projected.setX(E);
-        projected.setY(N);
-    }
-    /**
-       * Do the inverse projection.
-       * @param x the easting.
-       * @param y the northing.
-       * @param geographic the target geographic coordinate (X/Lon and Y/Lat will be set) (radians).
-       */
-    toGeoGraphic(x, y, geographic) {
-        /* Get the parameters */
-        const E = x;
-        const N = y;
-        /* Make the calculation */
-        const r_ = LambertConical2SP.sign(this._n) * Math.sqrt(LambertConical2SP.square(E - this._eF) + LambertConical2SP.square(this._rF - (N - this._nF)));
-        const t_ = Math.pow(r_ / (this._a * this._F), 1.0 / this._n);
-        const theta_ = Math.atan((E - this._eF) / (this._rF - (N - this._nF)));
-        let lat = LambertConical2SP.PI * 0.5 - 2.0 * Math.atan(t_);
-        const he = 0.5 * this._e;
-        for (let i = 0; i < 7; i++) // double-checked iteration count. LER, 24/11/2011
-         {
-            const eSin = this._e * Math.sin(lat);
-            lat = LambertConical2SP.hPI - 2.0 * Math.atan(t_ * Math.pow((1.0 - eSin) / (1.0 + eSin), he)); // recursive formula
-        }
-        const lon = (theta_) / this._n + this._lonF;
-        /* Save the position */
-        geographic.setX(lon);
-        geographic.setY(lat);
-    }
-    /**
-       * OperationMethod method.
-       * @see OperationMethod#initialize
-       */
-    initialize(operation) {
-        this.initializeProjection(operation.getSourceCRS().getEllipsoid());
-    }
-    /**
-       * OperationMethod interface method.
-       * @see OperationMethod#forward
-       */
-    forward(sourceCRS, source, targetCRS, target) {
-        /* Get the parameters */
-        const lon = source.getX();
-        const lat = source.getY();
-        /* Do the projection */
-        this.toProjection(lon, lat, target);
-        target.setZ(source.getZ()); // Keep the Z value
-    }
-    /**
-       * OperationMethod interface method.
-       * @see OperationMethod#reverse
-       */
-    reverse(sourceCRS, source, targetCRS, target) {
-        /* Get the parameters */
-        const E = target.getX();
-        const N = target.getY();
-        /* Do the inverse projection */
-        this.toGeoGraphic(E, N, source);
-        source.setZ(target.getZ()); // Keep the Z value
-    }
-}
-exports.LambertConical2SP = LambertConical2SP;
-/** The code of this method */
-LambertConical2SP.METHOD_CODE = 9802;
-/** The value of PI */
-LambertConical2SP.PI = Math.PI;
-/** The half value of PI */
-LambertConical2SP.hPI = 0.5 * Math.PI;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module OrbitGT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambertConical2SP = void 0;
+const OperationMethod_1 = require("../OperationMethod");
+/**
+ * Class LambertConical2SP defines a Lambert Conical Conformal map projection with 2 standard parallels.
+ *
+ * The 'source' CRS is the geographic CRS.
+ * The 'target' CRS is the projected CRS.
+ *
+ * Based on the following document:
+ *
+ * Coordinate Conversions and Transformations including Formulas
+ * Guidance Note Number 7, part 2
+ * Revised May 2005
+ * Available at: http://www.epsg.org/
+ *
+ * Formulas: see 1.4.1.1 -> 1.4.1.4
+ *
+ * @version 1.0 July 2005
+ */
+/** @internal */
+class LambertConical2SP extends OperationMethod_1.OperationMethod {
+    /**
+       * Create a new projection.
+       * @param parameters the values of the parameters.
+       */
+    constructor(parameters) {
+        super(LambertConical2SP.METHOD_CODE, "Lambert Conic Conformal (2SP)", parameters);
+        /* Store the parameters */
+        this._latF = parameters.getValue(8821);
+        this._lonF = parameters.getValue(8822);
+        this._lat1 = parameters.getValue(8823);
+        this._lat2 = parameters.getValue(8824);
+        this._eF = parameters.getValue(8826);
+        this._nF = parameters.getValue(8827);
+    }
+    /**
+       * Get the sign of a number.
+       */
+    static sign(v) {
+        return (v < 0.0) ? (-1.0) : (1.0);
+    }
+    /**
+       * Get the square of a number.
+       */
+    static square(v) {
+        return (v * v);
+    }
+    /**
+       * Calculate M.
+       */
+    static calcM(e, lat) {
+        return Math.cos(lat) / Math.sqrt(1.0 - LambertConical2SP.square(e * Math.sin(lat)));
+    }
+    /**
+       * Calculate T.
+       */
+    static calcT(e, lat) {
+        return Math.tan(Math.PI * 0.25 - lat * 0.5) / Math.pow((1.0 - e * Math.sin(lat)) / (1.0 + e * Math.sin(lat)), e * 0.5);
+    }
+    /**
+       * Calculate R.
+       */
+    static calcR(a, F, t, n) {
+        if (Math.abs(t) < 1.0e-6)
+            return 0.0;
+        return a * F * Math.pow(t, n);
+    }
+    /**
+       * Initialize the projection.
+       * @param ellipsoid the ellipsoid to use.
+       * @return this projection (for convenience).
+       */
+    initializeProjection(ellipsoid) {
+        /* Get the ellipsoid parameters */
+        this._e = ellipsoid.getE();
+        this._a = ellipsoid.getA();
+        /* Make the calculation */
+        this._m1 = LambertConical2SP.calcM(this._e, this._lat1);
+        this._m2 = LambertConical2SP.calcM(this._e, this._lat2);
+        this._t1 = LambertConical2SP.calcT(this._e, this._lat1);
+        this._t2 = LambertConical2SP.calcT(this._e, this._lat2);
+        this._tF = LambertConical2SP.calcT(this._e, this._latF);
+        this._n = (Math.log(this._m1) - Math.log(this._m2)) / (Math.log(this._t1) - Math.log(this._t2));
+        this._F = this._m1 / (this._n * Math.pow(this._t1, this._n));
+        this._rF = LambertConical2SP.calcR(this._a, this._F, this._tF, this._n);
+        /* Return the projection */
+        return this;
+    }
+    /**
+       * Do the projection.
+       * @param lon the longitude (radians).
+       * @param lat the latitude (radians).
+       * @param projected the target projected coordinate (X and Y will be set).
+       */
+    toProjection(lon, lat, projected) {
+        /* Make the calculation */
+        const t = LambertConical2SP.calcT(this._e, lat);
+        const r = LambertConical2SP.calcR(this._a, this._F, t, this._n);
+        const theta = this._n * (lon - this._lonF);
+        const E = this._eF + r * Math.sin(theta);
+        const N = this._nF + this._rF - r * Math.cos(theta);
+        /* Save the position */
+        projected.setX(E);
+        projected.setY(N);
+    }
+    /**
+       * Do the inverse projection.
+       * @param x the easting.
+       * @param y the northing.
+       * @param geographic the target geographic coordinate (X/Lon and Y/Lat will be set) (radians).
+       */
+    toGeoGraphic(x, y, geographic) {
+        /* Get the parameters */
+        const E = x;
+        const N = y;
+        /* Make the calculation */
+        const r_ = LambertConical2SP.sign(this._n) * Math.sqrt(LambertConical2SP.square(E - this._eF) + LambertConical2SP.square(this._rF - (N - this._nF)));
+        const t_ = Math.pow(r_ / (this._a * this._F), 1.0 / this._n);
+        const theta_ = Math.atan((E - this._eF) / (this._rF - (N - this._nF)));
+        let lat = LambertConical2SP.PI * 0.5 - 2.0 * Math.atan(t_);
+        const he = 0.5 * this._e;
+        for (let i = 0; i < 7; i++) // double-checked iteration count. LER, 24/11/2011
+         {
+            const eSin = this._e * Math.sin(lat);
+            lat = LambertConical2SP.hPI - 2.0 * Math.atan(t_ * Math.pow((1.0 - eSin) / (1.0 + eSin), he)); // recursive formula
+        }
+        const lon = (theta_) / this._n + this._lonF;
+        /* Save the position */
+        geographic.setX(lon);
+        geographic.setY(lat);
+    }
+    /**
+       * OperationMethod method.
+       * @see OperationMethod#initialize
+       */
+    initialize(operation) {
+        this.initializeProjection(operation.getSourceCRS().getEllipsoid());
+    }
+    /**
+       * OperationMethod interface method.
+       * @see OperationMethod#forward
+       */
+    forward(sourceCRS, source, targetCRS, target) {
+        /* Get the parameters */
+        const lon = source.getX();
+        const lat = source.getY();
+        /* Do the projection */
+        this.toProjection(lon, lat, target);
+        target.setZ(source.getZ()); // Keep the Z value
+    }
+    /**
+       * OperationMethod interface method.
+       * @see OperationMethod#reverse
+       */
+    reverse(sourceCRS, source, targetCRS, target) {
+        /* Get the parameters */
+        const E = target.getX();
+        const N = target.getY();
+        /* Do the inverse projection */
+        this.toGeoGraphic(E, N, source);
+        source.setZ(target.getZ()); // Keep the Z value
+    }
+}
+exports.LambertConical2SP = LambertConical2SP;
+/** The code of this method */
+LambertConical2SP.METHOD_CODE = 9802;
+/** The value of PI */
+LambertConical2SP.PI = Math.PI;
+/** The half value of PI */
+LambertConical2SP.hPI = 0.5 * Math.PI;
 //# sourceMappingURL=LambertConical2SP.js.map