/** * Constructor for a geodesic line staring at latitude <i>lat1</i>, longitude * <i>lon1</i>, and azimuth <i>azi1</i> (all in degrees) with a subset of the * capabilities included. * <p> * @param g A {@link Geodesic} object used to compute the necessary * information about the GeodesicLine. * @param lat1 latitude of point 1 (degrees). * @param lon1 longitude of point 1 (degrees). * @param azi1 azimuth at point 1 (degrees). * @param caps bitor'ed combination of {@link GeodesicMask} values * specifying the capabilities the GeodesicLine object should possess, * i.e., which quantities can be returned in calls to {@link #Position * Position}. * <p> * The {@link GeodesicMask} values are * <ul> * <li> * <i>caps</i> |= {@link GeodesicMask#LATITUDE} for the latitude * <i>lat2</i>; this is added automatically; * <li> * <i>caps</i> |= {@link GeodesicMask#LONGITUDE} for the latitude * <i>lon2</i>; * <li> * <i>caps</i> |= {@link GeodesicMask#AZIMUTH} for the latitude * <i>azi2</i>; this is added automatically; * <li> * <i>caps</i> |= {@link GeodesicMask#DISTANCE} for the distance * <i>s12</i>; * <li> * <i>caps</i> |= {@link GeodesicMask#REDUCEDLENGTH} for the reduced length * <i>m12</i>; * <li> * <i>caps</i> |= {@link GeodesicMask#GEODESICSCALE} for the geodesic * scales <i>M12</i> and <i>M21</i>; * <li> * <i>caps</i> |= {@link GeodesicMask#AREA} for the area <i>S12</i>; * <li> * <i>caps</i> |= {@link GeodesicMask#DISTANCE_IN} permits the length of * the geodesic to be given in terms of <i>s12</i>; without this capability * the length can only be specified in terms of arc length; * <li> * <i>caps</i> |= {@link GeodesicMask#ALL} for all of the above. * </ul> **********************************************************************/ public GeodesicLine(Geodesic g, double lat1, double lon1, double azi1, int caps) { azi1 = GeoMath.AngNormalize(azi1); double salp1, calp1; // Guard against underflow in salp0 { Pair p = GeoMath.SinCosD(GeoMath.AngRound(azi1)); salp1 = p.First; calp1 = p.Second; } LineInit(g, lat1, lon1, azi1, salp1, calp1, caps); }
private static int Transit(double lon1, double lon2) { // Return 1 or -1 if crossing prime meridian in east or west direction. // Otherwise return zero. // Compute lon12 the same way as Geodesic.Inverse. lon1 = GeoMath.AngNormalize(lon1); lon2 = GeoMath.AngNormalize(lon2); double lon12 = GeoMath.AngDiff(lon1, lon2).First; int cross = lon1 <= 0 && lon2 > 0 && lon12 > 0 ? 1 : (lon2 <= 0 && lon1 > 0 && lon12 < 0 ? -1 : 0); return(cross); }
/** * Add a point to the polygon or polyline. * <p> * @param lat the latitude of the point (degrees). * @param lon the latitude of the point (degrees). * <p> * <i>lat</i> should be in the range [−90°, 90°]. **********************************************************************/ public void AddPoint(double lat, double lon) { lon = GeoMath.AngNormalize(lon); if (_num == 0) { _lat0 = _lat1 = lat; _lon0 = _lon1 = lon; } else { GeodesicData g = _earth.Inverse(_lat1, _lon1, lat, lon, _mask); _perimetersum.Add(g.Distance); if (!_polyline) { _areasum.Add(g.GeodesicScale12); _crossings += Transit(_lon1, lon); } _lat1 = lat; _lon1 = lon; } ++_num; }
/** * The general position function. {@link #Position(double, int) Position} * and {@link #ArcPosition(double, int) ArcPosition} are defined in terms of * this function. * <p> * @param arcmode boolean flag determining the meaning of the second * parameter; if arcmode is false, then the GeodesicLine object must have * been constructed with <i>caps</i> |= {@link GeodesicMask#DISTANCE_IN}. * @param s12_a12 if <i>arcmode</i> is false, this is the distance between * point 1 and point 2 (meters); otherwise it is the arc length between * point 1 and point 2 (degrees); it can be negative. * @param outmask a bitor'ed combination of {@link GeodesicMask} values * specifying which results should be returned. * @return a {@link GeodesicData} object with the requested results. * <p> * The {@link GeodesicMask} values possible for <i>outmask</i> are * <ul> * <li> * <i>outmask</i> |= {@link GeodesicMask#LATITUDE} for the latitude * <i>lat2</i>; * <li> * <i>outmask</i> |= {@link GeodesicMask#LONGITUDE} for the latitude * <i>lon2</i>; * <li> * <i>outmask</i> |= {@link GeodesicMask#AZIMUTH} for the latitude * <i>azi2</i>; * <li> * <i>outmask</i> |= {@link GeodesicMask#DISTANCE} for the distance * <i>s12</i>; * <li> * <i>outmask</i> |= {@link GeodesicMask#REDUCEDLENGTH} for the reduced * length <i>m12</i>; * <li> * <i>outmask</i> |= {@link GeodesicMask#GEODESICSCALE} for the geodesic * scales <i>M12</i> and <i>M21</i>; * <li> * <i>outmask</i> |= {@link GeodesicMask#ALL} for all of the above; * <li> * <i>outmask</i> |= {@link GeodesicMask#LONG_UNROLL} to unroll <i>lon2</i> * (instead of reducing it to the range [−180°, 180°]). * </ul> * <p> * Requesting a value which the GeodesicLine object is not capable of * computing is not an error; Double.NaN is returned instead. **********************************************************************/ public GeodesicData Position(bool arcmode, double s12_a12, int outmask) { outmask &= _caps & GeodesicMask.OUT_MASK; GeodesicData r = new GeodesicData(); if (!(Init() && (arcmode || (_caps & (GeodesicMask.OUT_MASK & GeodesicMask.DISTANCE_IN)) != 0) )) { // Uninitialized or impossible distance calculation requested return(r); } r.Latitude1 = _lat1; r.InitialAzimuth = _azi1; r.Longitude1 = ((outmask & GeodesicMask.LONG_UNROLL) != 0) ? _lon1 : GeoMath.AngNormalize(_lon1); // Avoid warning about uninitialized B12. double sig12, ssig12, csig12, B12 = 0, AB1 = 0; if (arcmode) { // Interpret s12_a12 as spherical arc length r.ArcLength = s12_a12; sig12 = Math2.ToRadians(s12_a12); { Pair p = GeoMath.SinCosD(s12_a12); ssig12 = p.First; csig12 = p.Second; } } else { // Interpret s12_a12 as distance r.Distance = s12_a12; double tau12 = s12_a12 / (_b * (1 + _A1m1)), s = Math.Sin(tau12), c = Math.Cos(tau12); // tau2 = tau1 + tau12 B12 = -Geodesic.SinCosSeries(true, _stau1 * c + _ctau1 * s, _ctau1 * c - _stau1 * s, _C1pa); sig12 = tau12 - (B12 - _B11); ssig12 = Math.Sin(sig12); csig12 = Math.Cos(sig12); if (Math.Abs(_f) > 0.01) { // Reverted distance series is inaccurate for |f| > 1/100, so correct // sig12 with 1 Newton iteration. The following table shows the // approximate maximum error for a = WGS_a() and various f relative to // GeodesicExact. // erri = the error in the inverse solution (nm) // errd = the error in the direct solution (series only) (nm) // errda = the error in the direct solution // (series + 1 Newton) (nm) // // f erri errd errda // -1/5 12e6 1.2e9 69e6 // -1/10 123e3 12e6 765e3 // -1/20 1110 108e3 7155 // -1/50 18.63 200.9 27.12 // -1/100 18.63 23.78 23.37 // -1/150 18.63 21.05 20.26 // 1/150 22.35 24.73 25.83 // 1/100 22.35 25.03 25.31 // 1/50 29.80 231.9 30.44 // 1/20 5376 146e3 10e3 // 1/10 829e3 22e6 1.5e6 // 1/5 157e6 3.8e9 280e6 double sssig2 = _ssig1 * csig12 + _csig1 * ssig12, scsig2 = _csig1 * csig12 - _ssig1 * ssig12; B12 = Geodesic.SinCosSeries(true, sssig2, scsig2, _C1a); double serr = (1 + _A1m1) * (sig12 + (B12 - _B11)) - s12_a12 / _b; sig12 = sig12 - serr / Math.Sqrt(1 + _k2 * GeoMath.Square(sssig2)); ssig12 = Math.Sin(sig12); csig12 = Math.Cos(sig12); // Update B12 below } r.ArcLength = Math2.ToDegrees(sig12); } double ssig2, csig2, sbet2, cbet2, salp2, calp2; // sig2 = sig1 + sig12 ssig2 = _ssig1 * csig12 + _csig1 * ssig12; csig2 = _csig1 * csig12 - _ssig1 * ssig12; double dn2 = Math.Sqrt(1 + _k2 * GeoMath.Square(ssig2)); if ((outmask & (GeodesicMask.DISTANCE | GeodesicMask.REDUCEDLENGTH | GeodesicMask.GEODESICSCALE)) != 0) { if (arcmode || Math.Abs(_f) > 0.01) { B12 = Geodesic.SinCosSeries(true, ssig2, csig2, _C1a); } AB1 = (1 + _A1m1) * (B12 - _B11); } // sin(bet2) = cos(alp0) * sin(sig2) sbet2 = _calp0 * ssig2; // Alt: cbet2 = hypot(csig2, salp0 * ssig2); cbet2 = GeoMath.Hypot(_salp0, _calp0 * csig2); if (cbet2 == 0) { // I.e., salp0 = 0, csig2 = 0. Break the degeneracy in this case cbet2 = csig2 = Geodesic.tiny_; } // tan(alp0) = cos(sig2)*tan(alp2) salp2 = _salp0; calp2 = _calp0 * csig2; // No need to normalize if ((outmask & GeodesicMask.DISTANCE) != 0 && arcmode) { r.Distance = _b * ((1 + _A1m1) * sig12 + AB1); } if ((outmask & GeodesicMask.LONGITUDE) != 0) { // tan(omg2) = sin(alp0) * tan(sig2) double somg2 = _salp0 * ssig2, comg2 = csig2, // No need to normalize E = GeoMath.CopySign(1, _salp0); // east or west going? // omg12 = omg2 - omg1 double omg12 = ((outmask & GeodesicMask.LONG_UNROLL) != 0) ? E * (sig12 - (Math.Atan2(ssig2, csig2) - Math.Atan2(_ssig1, _csig1)) + (Math.Atan2(E * somg2, comg2) - Math.Atan2(E * _somg1, _comg1))) : Math.Atan2(somg2 * _comg1 - comg2 * _somg1, comg2 * _comg1 + somg2 * _somg1); double lam12 = omg12 + _A3c * (sig12 + (Geodesic.SinCosSeries(true, ssig2, csig2, _C3a) - _B31)); double lon12 = Math2.ToDegrees(lam12); r.Longitude2 = ((outmask & GeodesicMask.LONG_UNROLL) != 0) ? _lon1 + lon12 : GeoMath.AngNormalize(r.Longitude1 + GeoMath.AngNormalize(lon12)); } if ((outmask & GeodesicMask.LATITUDE) != 0) { r.Latitude2 = GeoMath.Atan2d(sbet2, _f1 * cbet2); } if ((outmask & GeodesicMask.AZIMUTH) != 0) { r.FinalAzimuth = GeoMath.Atan2d(salp2, calp2); } if ((outmask & (GeodesicMask.REDUCEDLENGTH | GeodesicMask.GEODESICSCALE)) != 0) { double B22 = Geodesic.SinCosSeries(true, ssig2, csig2, _C2a), AB2 = (1 + _A2m1) * (B22 - _B21), J12 = (_A1m1 - _A2m1) * sig12 + (AB1 - AB2); if ((outmask & GeodesicMask.REDUCEDLENGTH) != 0) { // Add parens around (_csig1 * ssig2) and (_ssig1 * csig2) to ensure // accurate cancellation in the case of coincident points. r.ReducedLength = _b * ((dn2 * (_csig1 * ssig2) - _dn1 * (_ssig1 * csig2)) - _csig1 * csig2 * J12); } if ((outmask & GeodesicMask.GEODESICSCALE) != 0) { double t = _k2 * (ssig2 - _ssig1) * (ssig2 + _ssig1) / (_dn1 + dn2); r.GeodesicScale12 = csig12 + (t * ssig2 - csig2 * J12) * _ssig1 / _dn1; r.GeodesicScale21 = csig12 - (t * _ssig1 - _csig1 * J12) * ssig2 / dn2; } } if ((outmask & GeodesicMask.AREA) != 0) { double B42 = Geodesic.SinCosSeries(false, ssig2, csig2, _C4a); double salp12, calp12; if (_calp0 == 0 || _salp0 == 0) { // alp12 = alp2 - alp1, used in atan2 so no need to normalize salp12 = salp2 * _calp1 - calp2 * _salp1; calp12 = calp2 * _calp1 + salp2 * _salp1; } else { // tan(alp) = tan(alp0) * sec(sig) // tan(alp2-alp1) = (tan(alp2) -tan(alp1)) / (tan(alp2)*tan(alp1)+1) // = calp0 * salp0 * (csig1-csig2) / (salp0^2 + calp0^2 * csig1*csig2) // If csig12 > 0, write // csig1 - csig2 = ssig12 * (csig1 * ssig12 / (1 + csig12) + ssig1) // else // csig1 - csig2 = csig1 * (1 - csig12) + ssig12 * ssig1 // No need to normalize salp12 = _calp0 * _salp0 * (csig12 <= 0 ? _csig1 * (1 - csig12) + ssig12 * _ssig1 : ssig12 * (_csig1 * ssig12 / (1 + csig12) + _ssig1)); calp12 = GeoMath.Square(_salp0) + GeoMath.Square(_calp0) * _csig1 * csig2; } r.AreaUnderGeodesic = _c2 * Math.Atan2(salp12, calp12) + _A4 * (B42 - _B41); } return(r); }