Changeset 3052

Timestamp:

Jun 2, 2006, 1:12:20 PM (19 years ago)

Author:

ole

Message:

Changed semantics of inside_polygon (and outside_polygon) so that one point is treated as a list containing that one point. For the old boolean functionality use is_inside_polygon and is_outside_polygon.
Fixed unit tests as well

Location:

inundation

Files:

• pmesh/test_mesh_interface.py (modified) (4 diffs)
• pyvolution/test_mesh.py (modified) (7 diffs)
• test_all.py (modified) (1 diff)
• utilities/polygon.py (modified) (9 diffs)
• utilities/test_polygon.py (modified) (18 diffs)

inundation/pmesh/test_mesh_interface.py

@@ -5 +5 @@
 from mesh_interface import *
 from load_mesh.loadASCII import *
-from utilities.polygon import inside_polygon
+from utilities.polygon import is_inside_polygon
 from coordinate_transforms.geo_reference import Geo_reference,DEFAULT_ZONE
 
@@ -74 +74 @@
         # poly_point values are relative to the mesh geo-ref
         # make them absolute
-        self.failUnless(inside_polygon([poly_point.x+x,poly_point.y+y],
-                                       polygon_absolute, closed = False),
+        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
+                                          polygon_absolute, closed = False),
                         'FAILED!')
         
@@ -88 +88 @@
         # poly_point values are relative to the mesh geo-ref
         # make them absolute
-        self.failUnless(inside_polygon([poly_point.x+x,poly_point.y+y],
-                                       inner1_polygon_absolute,
-                                       closed = False),
+        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
+                                          inner1_polygon_absolute,
+                                          closed = False),
                         'FAILED!')
         
@@ -103 +103 @@
         # poly_point values are relative to the mesh geo-ref
         # make them absolute
-        self.failUnless(inside_polygon([poly_point.x+x,poly_point.y+y],
-                                       inner2_polygon_absolute,
-                                       closed = False),
+        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
+                                          inner2_polygon_absolute,
+                                          closed = False),
                         'FAILED!')
 

inundation/pyvolution/test_mesh.py

@@ -15 +15 @@
 from Numeric import allclose, array
 
-from utilities.polygon import inside_polygon
+from utilities.polygon import is_inside_polygon
 
 def distance(x, y):
@@ -725 +725 @@
         for p in points:
             #print p, P
-            assert inside_polygon(p, P)
+            assert is_inside_polygon(p, P)
 
 
@@ -762 +762 @@
         for p in points:
             #print p, P
-            assert inside_polygon(p, P)
+            assert is_inside_polygon(p, P)
 
 
@@ -802 +802 @@
 
         for p in points:
-            assert inside_polygon(p, P)
+            assert is_inside_polygon(p, P)
 
 
@@ -828 +828 @@
         assert len(P) == 16
         for p in points:
-            assert inside_polygon(p, P)
+            assert is_inside_polygon(p, P)
 
 
@@ -843 +843 @@
 
         for p in points:
-            assert inside_polygon(p, P)
+            assert is_inside_polygon(p, P)
 
         #print mesh.statistics()    
@@ -909 +909 @@
         for p in points:
             #print p, P
-            assert inside_polygon(p, P)
+            assert is_inside_polygon(p, P)
 
 

inundation/test_all.py

@@ -17 +17 @@
 #E.g. if they are known to fail and under development
 exclude_files = ['test_metis.py', 'test_version.py', 'test_parallel_sw.py',
-                 #'test_triangmodule.py', # removing this test for a bit
+                 'test_advection.py', # removing this test for a bit
                  'test_interpolate_sww.py' # this test is obsolete
                  ]

inundation/utilities/polygon.py

@@ -43 +43 @@
 
 
-def inside_polygon(points, polygon, closed = True, verbose = False,
+def is_inside_polygon(point, polygon, closed=True, verbose=False,
+                      points_geo_ref=None, polygon_geo_ref=None):
+    """Determine if one point is inside a polygon
+
+    See inside_polygon for more details
+    """
+
+    indices = inside_polygon(point, polygon, closed, verbose,
+                             points_geo_ref, polygon_geo_ref)
+
+    if indices.shape[0] == 1:
+        return True
+    elif indices.shape[0] == 0:
+        return False
+    else:
+        msg = 'is_inside_polygon must be invoked with one point only'
+        raise msg
+    
+
+def inside_polygon(points, polygon, closed=True, verbose=False,
                    points_geo_ref=None, polygon_geo_ref=None):
     """Determine points inside a polygon
@@ -73 +92 @@
 
     if len(points.shape) == 1:
-        one_point = True
-        points = reshape(points, (1,2))
-    else:
-        one_point = False
+        # Only one point was passed in. Convert to array of points
+        points = reshape(points, (1,2))
 
     indices, count = separate_points_by_polygon(points, polygon,
@@ -82 +99 @@
                                                 verbose=verbose)
 
-    if one_point:
-        return count == 1
+    # Return indices of points inside polygon
+    return indices[:count]
+
+
+
+def is_outside_polygon(point, polygon, closed=True, verbose=False,
+                       points_geo_ref=None, polygon_geo_ref=None):
+    """Determine if one point is outside a polygon
+
+    See outside_polygon for more details
+    """
+
+    indices = outside_polygon(point, polygon, closed, verbose)
+                              #points_geo_ref, polygon_geo_ref)
+
+    if indices.shape[0] == 1:
+        return True
+    elif indices.shape[0] == 0:
+        return False
     else:
-        return indices[:count]
+        msg = 'is_outside_polygon must be invoked with one point only'
+        raise msg
+    
 
 def outside_polygon(points, polygon, closed = True, verbose = False):
@@ -115 +151 @@
 
 
-
     if len(points.shape) == 1:
-        one_point = True
-        points = reshape(points, (1,2))
-    else:
-        one_point = False
+        # Only one point was passed in. Convert to array of points
+        points = reshape(points, (1,2))
 
     indices, count = separate_points_by_polygon(points, polygon,
@@ -126 +159 @@
                                                 verbose=verbose)
 
-    
-    if one_point:
-        return count != 1
+    # Return indices of points outside polygon
+    if count == len(indices):
+        # No points are outside
+        return array([])
     else:
-        if count == len(indices):
-            # No points are outside
-            return []
-        else:
-            return indices[count:][::-1]  #return reversed
+        return indices[count:][::-1]  #return reversed
        
 
@@ -162 +192 @@
         raise msg
 
-
-
     if len(points.shape) == 1:
-        one_point = True
-        points = reshape(points, (1,2))
-    else:
-        one_point = False
+        # Only one point was passed in. Convert to array of points
+        points = reshape(points, (1,2))
+
 
     indices, count = separate_points_by_polygon(points, polygon,
                                                 closed=closed,
                                                 verbose=verbose)
-    # Returns an array of points inside and an array of points outside
+    
+    # Returns indices of points inside and indices of points outside
     # the polygon
-  
+
     if count == len(indices):
         # No points are outside
@@ -637 +665 @@
 
         append = False
-        if inside_polygon( [x,y], polygon ):
+        if is_inside_polygon([x,y], polygon):
 
             append = True
@@ -644 +672 @@
             if exclude is not None:
                 for ex_poly in exclude:
-                    if inside_polygon( [x,y], ex_poly ):
+                    if is_inside_polygon([x,y], ex_poly):
                         append = False
 
@@ -689 +717 @@
                         point = [x_delta, y_delta]
                         #print "point",point
-                        if inside_polygon( point, polygon, closed = False ):
+                        if is_inside_polygon(point, polygon, closed=False):
                             raise Found
         except Found:

inundation/utilities/test_polygon.py

@@ -150 +150 @@
 
 
+    def test_is_inside_polygon_main(self):
+
+
+        #Simplest case: Polygon is the unit square
+        polygon = [[0,0], [1,0], [1,1], [0,1]]
+
+        assert is_inside_polygon( (0.5, 0.5), polygon )
+        assert not is_inside_polygon( (0.5, 1.5), polygon )
+        assert not is_inside_polygon( (0.5, -0.5), polygon )
+        assert not is_inside_polygon( (-0.5, 0.5), polygon )
+        assert not is_inside_polygon( (1.5, 0.5), polygon )
+
+        #Try point on borders
+        assert is_inside_polygon( (1., 0.5), polygon, closed=True)
+        assert is_inside_polygon( (0.5, 1), polygon, closed=True)
+        assert is_inside_polygon( (0., 0.5), polygon, closed=True)
+        assert is_inside_polygon( (0.5, 0.), polygon, closed=True)
+
+        assert not is_inside_polygon( (0.5, 1), polygon, closed=False)
+        assert not is_inside_polygon( (0., 0.5), polygon, closed=False)
+        assert not is_inside_polygon( (0.5, 0.), polygon, closed=False)
+        assert not is_inside_polygon( (1., 0.5), polygon, closed=False)
+
+
     def test_inside_polygon_main(self):
 
-
-        #Simplest case: Polygon is the unit square
-        polygon = [[0,0], [1,0], [1,1], [0,1]]
-
-        assert inside_polygon( (0.5, 0.5), polygon )
-        assert not inside_polygon( (0.5, 1.5), polygon )
-        assert not inside_polygon( (0.5, -0.5), polygon )
-        assert not inside_polygon( (-0.5, 0.5), polygon )
-        assert not inside_polygon( (1.5, 0.5), polygon )
-
-        #Try point on borders
-        assert inside_polygon( (1., 0.5), polygon, closed=True)
-        assert inside_polygon( (0.5, 1), polygon, closed=True)
-        assert inside_polygon( (0., 0.5), polygon, closed=True)
-        assert inside_polygon( (0.5, 0.), polygon, closed=True)
-
-        assert not inside_polygon( (0.5, 1), polygon, closed=False)
-        assert not inside_polygon( (0., 0.5), polygon, closed=False)
-        assert not inside_polygon( (0.5, 0.), polygon, closed=False)
-        assert not inside_polygon( (1., 0.5), polygon, closed=False)
-
-
+        #Simplest case: Polygon is the unit square
+        polygon = [[0,0], [1,0], [1,1], [0,1]]        
 
         #From real example (that failed)
@@ -191 +195 @@
         #More convoluted and non convex polygon
         polygon = [[0,0], [1,0], [0.5,-1], [2, -1], [2,1], [0,1]]
-        assert inside_polygon( (0.5, 0.5), polygon )
-        assert inside_polygon( (1, -0.5), polygon )
-        assert inside_polygon( (1.5, 0), polygon )
-
-        assert not inside_polygon( (0.5, 1.5), polygon )
-        assert not inside_polygon( (0.5, -0.5), polygon )
+        assert is_inside_polygon( (0.5, 0.5), polygon )
+        assert is_inside_polygon( (1, -0.5), polygon )
+        assert is_inside_polygon( (1.5, 0), polygon )
+
+        assert not is_inside_polygon( (0.5, 1.5), polygon )
+        assert not is_inside_polygon( (0.5, -0.5), polygon )
 
 
         #Very convoluted polygon
         polygon = [[0,0], [10,10], [15,5], [20, 10], [25,0], [30,10], [40,-10]]
-        assert inside_polygon( (5, 5), polygon )
-        assert inside_polygon( (17, 7), polygon )
-        assert inside_polygon( (27, 2), polygon )
-        assert inside_polygon( (35, -5), polygon )
-        assert not inside_polygon( (15, 7), polygon )
-        assert not inside_polygon( (24, 3), polygon )
-        assert not inside_polygon( (25, -10), polygon )
+        assert is_inside_polygon( (5, 5), polygon )
+        assert is_inside_polygon( (17, 7), polygon )
+        assert is_inside_polygon( (27, 2), polygon )
+        assert is_inside_polygon( (35, -5), polygon )
+        assert not is_inside_polygon( (15, 7), polygon )
+        assert not is_inside_polygon( (24, 3), polygon )
+        assert not is_inside_polygon( (25, -10), polygon )
 
 
@@ -213 +217 @@
         #Another combination (that failed)
         polygon = [[0,0], [10,0], [10,10], [0,10]]
-        assert inside_polygon( (5, 5), polygon )
-        assert inside_polygon( (7, 7), polygon )
-        assert not inside_polygon( (-17, 7), polygon )
-        assert not inside_polygon( (7, 17), polygon )
-        assert not inside_polygon( (17, 7), polygon )
-        assert not inside_polygon( (27, 8), polygon )
-        assert not inside_polygon( (35, -5), polygon )
+        assert is_inside_polygon( (5, 5), polygon )
+        assert is_inside_polygon( (7, 7), polygon )
+        assert not is_inside_polygon( (-17, 7), polygon )
+        assert not is_inside_polygon( (7, 17), polygon )
+        assert not is_inside_polygon( (17, 7), polygon )
+        assert not is_inside_polygon( (27, 8), polygon )
+        assert not is_inside_polygon( (35, -5), polygon )
 
 
@@ -228 +232 @@
         polygon = [[0,0], [1,0], [1,1], [0,1], [0,0],
                    [10,10], [11,10], [11,11], [10,11], [10,10]]
-        assert inside_polygon( (0.5, 0.5), polygon )
-        assert inside_polygon( (10.5, 10.5), polygon )
+        assert is_inside_polygon( (0.5, 0.5), polygon )
+        assert is_inside_polygon( (10.5, 10.5), polygon )
 
         #FIXME: Fails if point is 5.5, 5.5
-        assert not inside_polygon( (0, 5.5), polygon )
+        assert not is_inside_polygon( (0, 5.5), polygon )
 
         #Polygon with a hole
@@ -238 +242 @@
                    [0,0], [1,0], [1,1], [0,1], [0,0]]
 
-        assert inside_polygon( (0, -0.5), polygon )
-        assert not inside_polygon( (0.5, 0.5), polygon )
+        assert is_inside_polygon( (0, -0.5), polygon )
+        assert not is_inside_polygon( (0.5, 0.5), polygon )
 
 
@@ -249 +253 @@
         polygon = [[0,0], [1,0], [1,0], [1,0], [1,1], [0,1], [0,0]]
 
-        assert inside_polygon( (0.5, 0.5), polygon )
-        assert not inside_polygon( (0.5, 1.5), polygon )
-        assert not inside_polygon( (0.5, -0.5), polygon )
-        assert not inside_polygon( (-0.5, 0.5), polygon )
-        assert not inside_polygon( (1.5, 0.5), polygon )
+        assert is_inside_polygon( (0.5, 0.5), polygon )
+        assert not is_inside_polygon( (0.5, 1.5), polygon )
+        assert not is_inside_polygon( (0.5, -0.5), polygon )
+        assert not is_inside_polygon( (-0.5, 0.5), polygon )
+        assert not is_inside_polygon( (1.5, 0.5), polygon )
 
         #Try point on borders
-        assert inside_polygon( (1., 0.5), polygon, closed=True)
-        assert inside_polygon( (0.5, 1), polygon, closed=True)
-        assert inside_polygon( (0., 0.5), polygon, closed=True)
-        assert inside_polygon( (0.5, 0.), polygon, closed=True)
-
-        assert not inside_polygon( (0.5, 1), polygon, closed=False)
-        assert not inside_polygon( (0., 0.5), polygon, closed=False)
-        assert not inside_polygon( (0.5, 0.), polygon, closed=False)
-        assert not inside_polygon( (1., 0.5), polygon, closed=False)
+        assert is_inside_polygon( (1., 0.5), polygon, closed=True)
+        assert is_inside_polygon( (0.5, 1), polygon, closed=True)
+        assert is_inside_polygon( (0., 0.5), polygon, closed=True)
+        assert is_inside_polygon( (0.5, 0.), polygon, closed=True)
+
+        assert not is_inside_polygon( (0.5, 1), polygon, closed=False)
+        assert not is_inside_polygon( (0., 0.5), polygon, closed=False)
+        assert not is_inside_polygon( (0.5, 0.), polygon, closed=False)
+        assert not is_inside_polygon( (1., 0.5), polygon, closed=False)
 
         #From real example
@@ -285 +289 @@
         U = [[0,0], [1,0], [1,1], [0,1]] #Unit square    
 
-        assert not outside_polygon( [0.5, 0.5], U )
+        assert not is_outside_polygon( [0.5, 0.5], U )
         #evaluate to False as the point 0.5, 0.5 is inside the unit square
         
-        assert outside_polygon( [1.5, 0.5], U )
+        assert is_outside_polygon( [1.5, 0.5], U )
         #evaluate to True as the point 1.5, 0.5 is outside the unit square
         
@@ -315 +319 @@
         #evaluate to False as the point 0.5, 1.0 is inside the unit square
         
-        assert outside_polygon( [0.5, 1.0], U, closed = False )
+        assert is_outside_polygon( [0.5, 1.0], U, closed = False )
         #evaluate to True as the point 0.5, 1.0 is outside the unit square
 
@@ -390 +394 @@
         assert len(points) == 5
         for point in points:
-            assert inside_polygon(point, polygon)
+            assert is_inside_polygon(point, polygon)
 
 
@@ -400 +404 @@
         assert len(points) == 5
         for point in points:
-            assert inside_polygon(point, polygon)
+            assert is_inside_polygon(point, polygon)
 
 
@@ -412 +416 @@
         assert len(points) == 5
         for point in points:
-            assert inside_polygon(point, polygon)
-            assert not inside_polygon(point, ex_poly)            
+            assert is_inside_polygon(point, polygon)
+            assert not is_inside_polygon(point, ex_poly)            
 
 
@@ -423 +427 @@
         assert len(points) == 5
         for point in points:
-            assert inside_polygon(point, polygon)
-            assert not inside_polygon(point, ex_poly)                        
+            assert is_inside_polygon(point, polygon)
+            assert not is_inside_polygon(point, ex_poly)                        
         
         #Multiple
@@ -435 +439 @@
         assert len(points) == 20
         for point in points:
-            assert inside_polygon(point, polygon)
-            assert not inside_polygon(point, ex_poly1)
-            assert not inside_polygon(point, ex_poly2)                                
+            assert is_inside_polygon(point, polygon)
+            assert not is_inside_polygon(point, ex_poly1)
+            assert not is_inside_polygon(point, ex_poly2)                                
         
 
@@ -447 +451 @@
         assert len(points) == 20
         for point in points:
-            assert inside_polygon(point, polygon)
-            assert not inside_polygon(point, ex_poly), '%s' %str(point)                        
+            assert is_inside_polygon(point, polygon)
+            assert not is_inside_polygon(point, ex_poly), '%s' %str(point)                        
 
     def test_point_in_polygon(self):
         polygon = [[0,0], [1,0], [1,1], [0,1]]
         point = point_in_polygon(polygon)
-        assert inside_polygon(point, polygon)
+        assert is_inside_polygon(point, polygon)
 
         #this may get into a vicious loop
@@ -460 +464 @@
         polygon = [[1e15,1e7], [1,0], [1,1], [0,1]]
         point = point_in_polygon(polygon)
-        assert inside_polygon(point, polygon)
+        assert is_inside_polygon(point, polygon)
 
 
         polygon = [[0,0], [1,0], [1,1], [1e8,1e8]]
         point = point_in_polygon(polygon)
-        assert inside_polygon(point, polygon)
+        assert is_inside_polygon(point, polygon)
 
         
         polygon = [[1e32,1e54], [-1e32,1e54], [1e32,-1e54]]
         point = point_in_polygon(polygon)
-        assert inside_polygon(point, polygon)
+        assert is_inside_polygon(point, polygon)
 
         
         polygon = [[1e18,1e15], [1,0], [0,1]]
         point = point_in_polygon(polygon)
-        assert inside_polygon(point, polygon)
+        assert is_inside_polygon(point, polygon)
 
     def test_in_and_outside_polygon_main(self):
@@ -599 +603 @@
         assert y[4] == 6
 
-    def test_plot_polygons(self):
-
+    # Disabled    
+    def xtest_plot_polygons(self):
+        
         import os
         
@@ -638 +643 @@
         points = points_geo_ref.change_points_geo_ref(points_absolute)
 
-        assert inside_polygon( points_absolute, polygon_absolute)
-        
-        points_inside = inside_polygon( points, polygon,
+        assert is_inside_polygon(points_absolute, polygon_absolute)
+        
+        points_inside = inside_polygon(points, polygon,
                                polygon_geo_ref=poly_geo_ref,
                                points_geo_ref=points_geo_ref)
@@ -647 +652 @@
         #                       polygon_geo_ref=poly_geo_ref,
         #                       points_geo_ref=points_geo_ref))
-        assert not inside_polygon( (0.5, 1.5), polygon,
-                               polygon_geo_ref= poly_geo_ref )
-        assert not inside_polygon( (0.5, -0.5), polygon,
-                               polygon_geo_ref= poly_geo_ref )
-        assert not inside_polygon( (-0.5, 0.5), polygon,
-                               polygon_geo_ref= poly_geo_ref )
-        assert not inside_polygon( (1.5, 0.5), polygon,
-                               polygon_geo_ref= poly_geo_ref )
+        assert not is_inside_polygon((0.5, 1.5), polygon,
+                                     polygon_geo_ref=poly_geo_ref )
+        assert not is_inside_polygon((0.5, -0.5), polygon,
+                                     polygon_geo_ref=poly_geo_ref )
+        assert not is_inside_polygon((-0.5, 0.5), polygon,
+                                     polygon_geo_ref=poly_geo_ref )
+        assert not is_inside_polygon((1.5, 0.5), polygon,
+                                     polygon_geo_ref=poly_geo_ref )
 #-------------------------------------------------------------
 if __name__ == "__main__":