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")