def _intersects2(center1, r1, center2, r2, sphere=True, too_d=None, # in .ellipsoidalBase._intersections2
Vector=None, **Vector_kwds):
# (INTERNAL) Intersect two spheres or circles, see L{intersections2}
# above, separated to allow callers to embellish any exceptions
def _V3(x, y, z):
v = Vector3d(x, y, z)
n = intersections2.__name__
return _V_n(v, n, Vector, Vector_kwds)
def _xV3(c1, u, x, y):
xy1 = x, y, _1_0 # transform to original space
return _V3(fdot(xy1, u.x, -u.y, c1.x),
fdot(xy1, u.y, u.x, c1.y), _0_0)
c1 = _otherV3d(sphere=sphere, center1=center1)
c2 = _otherV3d(sphere=sphere, center2=center2)
if r1 < r2: # r1, r2 == R, r
c1, c2 = c2, c1
r1, r2 = r2, r1
m = c2.minus(c1)
d = m.length
if d < max(r2 - r1, EPS):
raise ValueError(_near_concentric_)
o = fsum_(-d, r1, r2) # overlap == -(d - (r1 + r2))
# compute intersections with c1 at (0, 0) and c2 at (d, 0), like
# <https://MathWorld.Wolfram.com/Circle-CircleIntersection.html>
if o > EPS: # overlapping, r1, r2 == R, r
x = _radical2(d, r1, r2).xline
y = _1_0 - (x / r1)**2
if y > EPS:
y = r1 * sqrt(y) # y == a / 2
elif y < 0:
raise ValueError(_invalid_)
else: # abutting
y = _0_0
elif o < 0:
t = d if too_d is None else too_d
raise ValueError(_too_(Fmt.distant(t)))
else: # abutting
x, y = r1, _0_0
u = m.unit()
if sphere: # sphere center and radius
c = c1 if x < EPS else (
c2 if x > EPS1 else c1.plus(u.times(x)))
t = _V3(c.x, c.y, c.z), Radius(y)
elif y > 0: # intersecting circles
t = _xV3(c1, u, x, y), _xV3(c1, u, x, -y)
else: # abutting circles
t = _xV3(c1, u, x, 0)
t = t, t
return t
def _intersects2(c1, rad1, c2, rad2, radius=R_M, # in .ellipsoidalBase._intersects2
height=None, wrap=True, too_d=None,
LatLon=LatLon, **LatLon_kwds):
# (INTERNAL) Intersect two spherical circles, see L{intersections2}
# above, separated to allow callers to embellish any exceptions
def _dest3(bearing, h):
a, b = _destination2(a1, b1, r1, bearing)
return _latlon3(degrees90(a), degrees180(b), h,
intersections2, LatLon, **LatLon_kwds)
r1, r2, f = _rads3(rad1, rad2, radius)
if f: # swapped
c1, c2 = c2, c1 # PYCHOK swap
a1, b1 = c1.philam
a2, b2 = c2.philam
db, b2 = unrollPI(b1, b2, wrap=wrap)
d = vincentys_(a2, a1, db) # radians
if d < max(r1 - r2, EPS):
raise ValueError(_near_concentric_)
x = fsum_(r1, r2, -d) # overlap
if x > EPS:
sd, cd, sr1, cr1, _, cr2 = sincos2(d, r1, r2)
x = sd * sr1
if abs(x) < EPS:
raise ValueError(_invalid_)
x = acos1((cr2 - cd * cr1) / x) # 0 <= x <= PI
elif x < 0:
t = (d * radius) if too_d is None else too_d
raise ValueError(_too_distant_fmt_ % (t,))
if height is None: # "radical height"
f = _radical2(d, r1, r2).ratio
h = Height(favg(c1.height, c2.height, f=f))
else:
h = Height(height)
b = bearing_(a1, b1, a2, b2, final=False, wrap=wrap)
if x < _EPS_I2: # externally ...
r = _dest3(b, h)
elif x > _PI_EPS_I2: # internally ...
r = _dest3(b + PI, h)
else:
return _dest3(b + x, h), _dest3(b - x, h)
return r, r # ... abutting circles
def _intersects2(
c1,
r1,
c2,
r2,
height=None,
wrap=True, # MCCABE 16
equidistant=None,
tol=_TOL_M,
LatLon=None,
**LatLon_kwds):
# (INTERNAL) Intersect two spherical circles, see L{_intersections2}
# above, separated to allow callers to embellish any exceptions
from pygeodesy.formy import _euclidean, _radical2
from pygeodesy.sphericalTrigonometry import _intersects2 as _si2, LatLon as _LLS
from pygeodesy.utily import m2degrees, unroll180
from pygeodesy.vector3d import _intersects2 as _vi2
def _latlon4(t, h, n):
if LatLon is None:
r = LatLon4Tuple(t.lat, t.lon, h, t.datum)
else:
kwds = _xkwds(LatLon_kwds, datum=t.datum, height=h)
r = LatLon(t.lat, t.lon, **kwds)
r._iteration = t.iteration # ._iteration for tests
return _xnamed(r, n)
if r1 < r2:
c1, c2 = c2, c1
r1, r2 = r2, r1
E = c1.ellipsoids(c2)
if r1 > (E.b * PI):
raise ValueError(_exceed_PI_radians_)
if wrap: # unroll180 == .karney._unroll2
_, lon2 = unroll180(c1.lon, c2.lon, wrap=True)
if lon2 != c2.lon:
c2 = c2.classof(c2.lat, lon2, c2.height, datum=c2.datum)
# distance between centers and radii are
# measured along the ellipsoid's surface
m = c1.distanceTo(c2, wrap=False) # meter
if m < max(r1 - r2, EPS):
raise ValueError(_near_concentric_)
if fsum_(r1, r2, -m) < 0:
raise ValueError(_too_distant_fmt_ % (m, ))
f = _radical2(m, r1, r2).ratio # "radical lat"
r = E.rocMean(favg(c1.lat, c2.lat, f=f))
e = max(m2degrees(tol, radius=r), EPS)
# get the azimuthal equidistant projection
if equidistant is None:
from pygeodesy.azimuthal import equidistant as A
else:
A = equidistant # preferably EquidistantKarney
A = A(0, 0, datum=c1.datum)
# gu-/estimate initial intersections, spherically ...
t1, t2 = _si2(_LLS(c1.lat, c1.lon, height=c1.height),
r1,
_LLS(c2.lat, c2.lon, height=c2.height),
r2,
radius=r,
height=height,
wrap=False,
too_d=m)
h, n = t1.height, t1.name
# ... and then iterate like Karney suggests to find
# tri-points of median lines, @see: references above
ts, ta = [], None
for t in ((t1, ) if t1 is t2 else (t1, t2)):
p = None # force d == p False
for i in range(_TRIPS):
A.reset(t.lat, t.lon) # gu-/estimate as origin
# convert centers to projection space
t1 = A.forward(c1.lat, c1.lon)
t2 = A.forward(c2.lat, c2.lon)
# compute intersections in projection space
v1, v2 = _vi2(
t1,
r1, # XXX * t1.scale?,
t2,
r2, # XXX * t2.scale?,
sphere=False,
too_d=m)
# convert intersections back to geodetic
t1 = A.reverse(v1.x, v1.y)
t2 = A.reverse(v2.x, v2.y)
# consider only the closer intersection
d1 = _euclidean(t1.lat - t.lat, t1.lon - t.lon)
d2 = _euclidean(t2.lat - t.lat, t2.lon - t.lon)
# break if below tolerance or if unchanged
t, d = (t1, d1) if d1 < d2 else (t2, d2)
if d < e or d == p:
t._iteration = i + 1 # _NamedTuple._iteration
ts.append(t)
if v1 is v2: # abutting
ta = t
break
p = d
else:
raise ValueError(_no_convergence_fmt_ % (tol, ))
if ta: # abutting circles
r = _latlon4(ta, h, n)
elif len(ts) == 2:
return _latlon4(ts[0], h, n), _latlon4(ts[1], h, n)
elif len(ts) == 1: # XXX assume abutting
r = _latlon4(ts[0], h, n)
else:
raise _AssertionError(ts=ts)
return r, r