def overlaps(self, other):
"""Tests if the current area overlaps the *other* area. This is based
solely on the corners of areas, assuming the boundaries to be great
circles.
Parameters
----------
other : object
Instance of subclass of BaseDefinition
Returns
-------
overlaps : bool
"""
from pyresample.spherical_geometry import Arc
self_corners = self.corners
other_corners = other.corners
for i in self_corners:
if i in other:
return True
for i in other_corners:
if i in self:
return True
self_arc1 = Arc(self_corners[0], self_corners[1])
self_arc2 = Arc(self_corners[1], self_corners[2])
self_arc3 = Arc(self_corners[2], self_corners[3])
self_arc4 = Arc(self_corners[3], self_corners[0])
other_arc1 = Arc(other_corners[0], other_corners[1])
other_arc2 = Arc(other_corners[1], other_corners[2])
other_arc3 = Arc(other_corners[2], other_corners[3])
other_arc4 = Arc(other_corners[3], other_corners[0])
for i in (self_arc1, self_arc2, self_arc3, self_arc4):
for j in (other_arc1, other_arc2, other_arc3, other_arc4):
if i.intersects(j):
return True
return False
def test_intersects(self):
"""Test if two arcs intersect."""
p0_ = Coordinate(0, 0)
p1_ = Coordinate(0, 1)
p2_ = Coordinate(1, 0)
p3_ = Coordinate(0, -1)
p4_ = Coordinate(-1, 0)
p5_ = Coordinate(1, 1)
p6_ = Coordinate(1, -1)
arc13 = Arc(p1_, p3_)
arc24 = Arc(p2_, p4_)
arc32 = Arc(p3_, p2_)
arc41 = Arc(p4_, p1_)
arc40 = Arc(p4_, p0_)
arc56 = Arc(p5_, p6_)
arc45 = Arc(p4_, p5_)
arc02 = Arc(p0_, p2_)
arc35 = Arc(p3_, p5_)
self.assertTrue(arc13.intersects(arc24))
self.assertFalse(arc32.intersects(arc41))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc45.intersects(arc02))
self.assertTrue(arc35.intersects(arc24))
p0_ = Coordinate(180, 0)
p1_ = Coordinate(180, 1)
p2_ = Coordinate(-179, 0)
p3_ = Coordinate(-180, -1)
p4_ = Coordinate(179, 0)
p5_ = Coordinate(-179, 1)
p6_ = Coordinate(-179, -1)
arc13 = Arc(p1_, p3_)
arc24 = Arc(p2_, p4_)
arc32 = Arc(p3_, p2_)
arc41 = Arc(p4_, p1_)
arc40 = Arc(p4_, p0_)
arc56 = Arc(p5_, p6_)
arc45 = Arc(p4_, p5_)
arc02 = Arc(p0_, p2_)
arc35 = Arc(p3_, p5_)
self.assertTrue(arc13.intersects(arc24))
self.assertFalse(arc32.intersects(arc41))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc45.intersects(arc02))
self.assertTrue(arc35.intersects(arc24))
# case of the north pole
p0_ = Coordinate(0, 90)
p1_ = Coordinate(0, 89)
p2_ = Coordinate(90, 89)
p3_ = Coordinate(180, 89)
p4_ = Coordinate(-90, 89)
p5_ = Coordinate(45, 89)
p6_ = Coordinate(135, 89)
arc13 = Arc(p1_, p3_)
arc24 = Arc(p2_, p4_)
arc32 = Arc(p3_, p2_)
arc41 = Arc(p4_, p1_)
arc40 = Arc(p4_, p0_)
arc56 = Arc(p5_, p6_)
arc45 = Arc(p4_, p5_)
arc02 = Arc(p0_, p2_)
arc35 = Arc(p3_, p5_)
self.assertTrue(arc13.intersects(arc24))
self.assertFalse(arc32.intersects(arc41))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc45.intersects(arc02))
self.assertTrue(arc35.intersects(arc24))
def test_angle(self):
"""Testing the angle value between two arcs."""
base = 0
p0_ = Coordinate(base, base)
p1_ = Coordinate(base, base + 1)
p2_ = Coordinate(base + 1, base)
p3_ = Coordinate(base, base - 1)
p4_ = Coordinate(base - 1, base)
arc1 = Arc(p0_, p1_)
arc2 = Arc(p0_, p2_)
arc3 = Arc(p0_, p3_)
arc4 = Arc(p0_, p4_)
self.assertAlmostEqual(arc1.angle(arc2),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc2.angle(arc3),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc3.angle(arc4),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc4.angle(arc1),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc1.angle(arc4),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc4.angle(arc3),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc3.angle(arc2),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc2.angle(arc1),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc1.angle(arc3),
math.pi,
msg="this should be pi")
self.assertAlmostEqual(arc3.angle(arc1),
math.pi,
msg="this should be pi")
self.assertAlmostEqual(arc2.angle(arc4),
math.pi,
msg="this should be pi")
self.assertAlmostEqual(arc4.angle(arc2),
math.pi,
msg="this should be pi")
p5_ = Coordinate(base + 1, base + 1)
p6_ = Coordinate(base + 1, base - 1)
p7_ = Coordinate(base - 1, base - 1)
p8_ = Coordinate(base - 1, base + 1)
arc5 = Arc(p0_, p5_)
arc6 = Arc(p0_, p6_)
arc7 = Arc(p0_, p7_)
arc8 = Arc(p0_, p8_)
self.assertAlmostEqual(arc1.angle(arc5),
math.pi / 4,
3,
msg="this should be pi/4")
self.assertAlmostEqual(arc5.angle(arc2),
math.pi / 4,
3,
msg="this should be pi/4")
self.assertAlmostEqual(arc2.angle(arc6),
math.pi / 4,
3,
msg="this should be pi/4")
self.assertAlmostEqual(arc6.angle(arc3),
math.pi / 4,
3,
msg="this should be pi/4")
self.assertAlmostEqual(arc3.angle(arc7),
math.pi / 4,
3,
msg="this should be pi/4")
self.assertAlmostEqual(arc7.angle(arc4),
math.pi / 4,
3,
msg="this should be pi/4")
self.assertAlmostEqual(arc4.angle(arc8),
math.pi / 4,
3,
msg="this should be pi/4")
self.assertAlmostEqual(arc8.angle(arc1),
math.pi / 4,
3,
msg="this should be pi/4")
self.assertAlmostEqual(arc1.angle(arc6),
3 * math.pi / 4,
3,
msg="this should be 3pi/4")
c0_ = Coordinate(180, 0)
c1_ = Coordinate(180, 1)
c2_ = Coordinate(-179, 0)
c3_ = Coordinate(-180, -1)
c4_ = Coordinate(179, 0)
arc1 = Arc(c0_, c1_)
arc2 = Arc(c0_, c2_)
arc3 = Arc(c0_, c3_)
arc4 = Arc(c0_, c4_)
self.assertAlmostEqual(arc1.angle(arc2),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc2.angle(arc3),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc3.angle(arc4),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc4.angle(arc1),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc1.angle(arc4),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc4.angle(arc3),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc3.angle(arc2),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc2.angle(arc1),
-math.pi / 2,
msg="this should be -pi/2")
# case of the north pole
c0_ = Coordinate(0, 90)
c1_ = Coordinate(0, 89)
c2_ = Coordinate(-90, 89)
c3_ = Coordinate(180, 89)
c4_ = Coordinate(90, 89)
arc1 = Arc(c0_, c1_)
arc2 = Arc(c0_, c2_)
arc3 = Arc(c0_, c3_)
arc4 = Arc(c0_, c4_)
self.assertAlmostEqual(arc1.angle(arc2),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc2.angle(arc3),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc3.angle(arc4),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc4.angle(arc1),
math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc1.angle(arc4),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc4.angle(arc3),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc3.angle(arc2),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc2.angle(arc1),
-math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(Arc(c1_, c2_).angle(arc1),
math.pi / 4,
3,
msg="this should be pi/4")
self.assertAlmostEqual(Arc(c4_, c3_).angle(arc4),
-math.pi / 4,
3,
msg="this should be -pi/4")
self.assertAlmostEqual(Arc(c1_, c4_).angle(arc1),
-math.pi / 4,
3,
msg="this should be -pi/4")
def corners(self):
"""Returns the corners of the current area.
"""
try:
# Try to just set normal CoordinateDefinition corners
# (Which doesn't work with bad vals in corners)
return super(CoordinateDefinition, self).corners
except ValueError:
#print ' Corners failed on CoordinateDefinition, try falsecorners'
pass
lons, lats = self.get_lonlats()
#Determine which rows and columns contain good data
rows = lons.any(axis=1)
cols = lons.any(axis=0)
#Get the minimum and maximum row and column that contain good data
good_row_inds = np.where(~rows.mask)[0]
min_row = good_row_inds.min()
max_row = good_row_inds.max()
good_col_inds = np.where(~cols.mask)[0]
min_col = good_col_inds.min()
max_col = good_col_inds.max()
log.info(' USING FALSE CORNERS!! setting corners. min row/col: '+\
str(min_row)+' '+str(min_col)+' '+\
'max row/col: '+str(max_row)+' '+str(max_col)+' '+\
'shape: '+str(lons.shape))
#from .spherical import SCoordinate as Coordinate
#from .spherical import Arc
from pyresample.spherical_geometry import Coordinate, Arc
#Calculate the eight possible corners and produce arcs for each pair
#Corners for top side
# Right side was failing with Divide by Zero error for NCC data because there was
# a single good point in the max_col. Keep incrementing or decrementing until good.min
# doesn't equal good.max
good = np.where(~lons[min_row, :].mask)[0]
tries = 0
while (tries < 20 and good.min() == good.max()):
#print 'good.min() can\'t equal good.max() for top side, incrementing min_row! Would have failed with ZeroDivisionError before!'
min_row += 1
tries += 1
good = np.where(~lons[min_row, :].mask)[0]
top_corners = [
Coordinate(*self.get_lonlat(min_row, good.min())),
Coordinate(*self.get_lonlat(min_row, good.max()))
]
top_arc = Arc(top_corners[0], top_corners[1])
#Corners for bottom side
good = np.where(~lons[max_row, :].mask)[0]
tries = 0
while (tries < 20 and good.min() == good.max()):
#print 'good.min() can\'t equal good.max() for bottom side, decrementing max_row! Would have failed with ZeroDivisionError before!'
max_row -= 1
tries += 1
good = np.where(~lons[max_row, :].mask)[0]
bot_corners = [
Coordinate(*self.get_lonlat(max_row, good.min())),
Coordinate(*self.get_lonlat(max_row, good.max()))
]
bot_arc = Arc(bot_corners[0], bot_corners[1])
#Corners for left side
good = np.where(~lons[:, min_col].mask)[0]
tries = 0
while (tries < 20 and good.min() == good.max()):
#print 'good.min() can\'t equal good.max() for left side, incrementing min_col! Would have failed with ZeroDivisionError before!'
min_col += 1
tries += 1
good = np.where(~lons[:, min_col].mask)[0]
left_corners = [
Coordinate(*self.get_lonlat(good.min(), min_col)),
Coordinate(*self.get_lonlat(good.max(), min_col))
]
left_arc = Arc(left_corners[0], left_corners[1])
#Corners for right side
good = np.where(~lons[:, max_col].mask)[0]
tries = 0
while (tries < 20 and good.min() == good.max()):
#print 'good.min() can\'t equal good.max() for right side, decrementing max_col! Would have failed with ZeroDivisionError before!'
max_col -= 1
tries += 1
good = np.where(~lons[:, max_col].mask)[0]
right_corners = [
Coordinate(*self.get_lonlat(good.min(), max_col)),
Coordinate(*self.get_lonlat(good.max(), max_col))
]
right_arc = Arc(right_corners[0], right_corners[1])
#Calculate the four false corners
_corners = []
#Top left false corner
top_intersections = top_arc.intersections(left_arc)
dists = [inter.distance(top_corners[0]) for inter in top_intersections]
if dists[0] < dists[1]:
_corners.append(top_intersections[0])
else:
_corners.append(top_intersections[1])
#Top right false corner
top_intersections = top_arc.intersections(right_arc)
dists = [inter.distance(top_corners[1]) for inter in top_intersections]
if dists[0] < dists[1]:
_corners.append(top_intersections[0])
else:
_corners.append(top_intersections[1])
#Bottom right false corner
bot_intersections = bot_arc.intersections(right_arc)
dists = [inter.distance(bot_corners[1]) for inter in bot_intersections]
if dists[0] < dists[1]:
_corners.append(bot_intersections[0])
else:
_corners.append(bot_intersections[1])
#Bottom left false corner
bot_intersections = bot_arc.intersections(left_arc)
dists = [inter.distance(bot_corners[0]) for inter in bot_intersections]
if dists[0] < dists[1]:
_corners.append(bot_intersections[0])
else:
_corners.append(bot_intersections[1])
return _corners
def test_intersects(self):
"""Test if two arcs intersect.
"""
p0_ = Coordinate(0, 0)
p1_ = Coordinate(0, 1)
p2_ = Coordinate(1, 0)
p3_ = Coordinate(0, -1)
p4_ = Coordinate(-1, 0)
p5_ = Coordinate(1, 1)
p6_ = Coordinate(1, -1)
arc13 = Arc(p1_, p3_)
arc24 = Arc(p2_, p4_)
arc32 = Arc(p3_, p2_)
arc41 = Arc(p4_, p1_)
arc40 = Arc(p4_, p0_)
arc56 = Arc(p5_, p6_)
arc45 = Arc(p4_, p5_)
arc02 = Arc(p0_, p2_)
arc35 = Arc(p3_, p5_)
self.assertTrue(arc13.intersects(arc24))
self.assertFalse(arc32.intersects(arc41))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc45.intersects(arc02))
self.assertTrue(arc35.intersects(arc24))
p0_ = Coordinate(180, 0)
p1_ = Coordinate(180, 1)
p2_ = Coordinate(-179, 0)
p3_ = Coordinate(-180, -1)
p4_ = Coordinate(179, 0)
p5_ = Coordinate(-179, 1)
p6_ = Coordinate(-179, -1)
arc13 = Arc(p1_, p3_)
arc24 = Arc(p2_, p4_)
arc32 = Arc(p3_, p2_)
arc41 = Arc(p4_, p1_)
arc40 = Arc(p4_, p0_)
arc56 = Arc(p5_, p6_)
arc45 = Arc(p4_, p5_)
arc02 = Arc(p0_, p2_)
arc35 = Arc(p3_, p5_)
self.assertTrue(arc13.intersects(arc24))
self.assertFalse(arc32.intersects(arc41))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc45.intersects(arc02))
self.assertTrue(arc35.intersects(arc24))
# case of the north pole
p0_ = Coordinate(0, 90)
p1_ = Coordinate(0, 89)
p2_ = Coordinate(90, 89)
p3_ = Coordinate(180, 89)
p4_ = Coordinate(-90, 89)
p5_ = Coordinate(45, 89)
p6_ = Coordinate(135, 89)
arc13 = Arc(p1_, p3_)
arc24 = Arc(p2_, p4_)
arc32 = Arc(p3_, p2_)
arc41 = Arc(p4_, p1_)
arc40 = Arc(p4_, p0_)
arc56 = Arc(p5_, p6_)
arc45 = Arc(p4_, p5_)
arc02 = Arc(p0_, p2_)
arc35 = Arc(p3_, p5_)
self.assertTrue(arc13.intersects(arc24))
self.assertFalse(arc32.intersects(arc41))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc56.intersects(arc40))
self.assertFalse(arc45.intersects(arc02))
self.assertTrue(arc35.intersects(arc24))
def test_angle(self):
"""Testing the angle value between two arcs.
"""
base = 0
p0_ = Coordinate(base, base)
p1_ = Coordinate(base, base + 1)
p2_ = Coordinate(base + 1, base)
p3_ = Coordinate(base, base - 1)
p4_ = Coordinate(base - 1, base)
arc1 = Arc(p0_, p1_)
arc2 = Arc(p0_, p2_)
arc3 = Arc(p0_, p3_)
arc4 = Arc(p0_, p4_)
self.assertAlmostEqual(arc1.angle(arc2), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc2.angle(arc3), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc3.angle(arc4), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc4.angle(arc1), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc1.angle(arc4), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc4.angle(arc3), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc3.angle(arc2), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc2.angle(arc1), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc1.angle(arc3), math.pi,
msg="this should be pi")
self.assertAlmostEqual(arc3.angle(arc1), math.pi,
msg="this should be pi")
self.assertAlmostEqual(arc2.angle(arc4), math.pi,
msg="this should be pi")
self.assertAlmostEqual(arc4.angle(arc2), math.pi,
msg="this should be pi")
p5_ = Coordinate(base + 1, base + 1)
p6_ = Coordinate(base + 1, base - 1)
p7_ = Coordinate(base - 1, base - 1)
p8_ = Coordinate(base - 1, base + 1)
arc5 = Arc(p0_, p5_)
arc6 = Arc(p0_, p6_)
arc7 = Arc(p0_, p7_)
arc8 = Arc(p0_, p8_)
self.assertAlmostEqual(arc1.angle(arc5), math.pi / 4, 3,
msg="this should be pi/4")
self.assertAlmostEqual(arc5.angle(arc2), math.pi / 4, 3,
msg="this should be pi/4")
self.assertAlmostEqual(arc2.angle(arc6), math.pi / 4, 3,
msg="this should be pi/4")
self.assertAlmostEqual(arc6.angle(arc3), math.pi / 4, 3,
msg="this should be pi/4")
self.assertAlmostEqual(arc3.angle(arc7), math.pi / 4, 3,
msg="this should be pi/4")
self.assertAlmostEqual(arc7.angle(arc4), math.pi / 4, 3,
msg="this should be pi/4")
self.assertAlmostEqual(arc4.angle(arc8), math.pi / 4, 3,
msg="this should be pi/4")
self.assertAlmostEqual(arc8.angle(arc1), math.pi / 4, 3,
msg="this should be pi/4")
self.assertAlmostEqual(arc1.angle(arc6), 3 * math.pi / 4, 3,
msg="this should be 3pi/4")
c0_ = Coordinate(180, 0)
c1_ = Coordinate(180, 1)
c2_ = Coordinate(-179, 0)
c3_ = Coordinate(-180, -1)
c4_ = Coordinate(179, 0)
arc1 = Arc(c0_, c1_)
arc2 = Arc(c0_, c2_)
arc3 = Arc(c0_, c3_)
arc4 = Arc(c0_, c4_)
self.assertAlmostEqual(arc1.angle(arc2), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc2.angle(arc3), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc3.angle(arc4), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc4.angle(arc1), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc1.angle(arc4), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc4.angle(arc3), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc3.angle(arc2), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc2.angle(arc1), -math.pi / 2,
msg="this should be -pi/2")
# case of the north pole
c0_ = Coordinate(0, 90)
c1_ = Coordinate(0, 89)
c2_ = Coordinate(-90, 89)
c3_ = Coordinate(180, 89)
c4_ = Coordinate(90, 89)
arc1 = Arc(c0_, c1_)
arc2 = Arc(c0_, c2_)
arc3 = Arc(c0_, c3_)
arc4 = Arc(c0_, c4_)
self.assertAlmostEqual(arc1.angle(arc2), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc2.angle(arc3), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc3.angle(arc4), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc4.angle(arc1), math.pi / 2,
msg="this should be pi/2")
self.assertAlmostEqual(arc1.angle(arc4), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc4.angle(arc3), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc3.angle(arc2), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(arc2.angle(arc1), -math.pi / 2,
msg="this should be -pi/2")
self.assertAlmostEqual(Arc(c1_, c2_).angle(arc1), math.pi / 4, 3,
msg="this should be pi/4")
self.assertAlmostEqual(Arc(c4_, c3_).angle(arc4), -math.pi / 4, 3,
msg="this should be -pi/4")
self.assertAlmostEqual(Arc(c1_, c4_).angle(arc1), -math.pi / 4, 3,
msg="this should be -pi/4")
