anuga 1.3.5__zip

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/geometry/polygon_function.py

@@ -0,0 +1,133 @@
+"""
+    Callable function to determine if points lie inside or outside a polygon.
+    
+    As of June 2010 this module has a pylint quality rating of 8.85/10.
+"""
+
+import anuga.utilities.log as log
+import numpy as num
+from polygon import inside_polygon
+
+class Polygon_function:
+    """Create callable object f: x,y -> z, where a,y,z are vectors and
+    where f will return different values depending on whether x,y belongs
+    to specified polygons.
+
+    To instantiate:
+
+       Polygon_function(polygons)
+
+    where polygons is a list of tuples of the form
+
+      [ (P0, v0), (P1, v1), ...]
+
+      with Pi being lists of vertices defining polygons and vi either
+      constants or functions of x,y to be applied to points with the polygon.
+
+    The function takes an optional argument, default which is the value
+    (or function) to used for points not belonging to any polygon.
+    For example:
+
+       Polygon_function(polygons, default = 0.03)
+
+    If omitted the default value will be 0.0
+
+    Note: If two polygons overlap, the one last in the list takes precedence
+
+    Coordinates specified in the call are assumed to be relative to the
+    origin (georeference) e.g. used by domain.
+    By specifying the optional argument georeference,
+    all points are made relative.
+
+    FIXME: This should really work with geo_spatial point sets.
+    """
+
+    def __init__(self, regions, default=0.0, geo_reference=None):
+        """Create instance of a polygon function.
+
+        regions A list of (x,y) tuples defining a polygon.
+        default Value or function returning value for points outside poly.
+        geo_reference ??
+        """
+
+        try:
+            len(regions)
+        except:
+            msg = ('Polygon_function takes a list of pairs (polygon, value).'
+                   'Got %s' % str(regions))
+            raise Exception, msg
+
+        first_region = regions[0]
+
+        if isinstance(first_region, basestring):
+            msg = ('You passed in a list of text values into polygon_function '
+                   'instead of a list of pairs (polygon, value): "%s"'
+                   % str(first_region))
+            raise Exception, msg
+
+        try:
+            num_region_components = len(first_region)
+        except:
+            msg = ('Polygon_function takes a list of pairs (polygon, value). '
+                   'Got %s' % str(num_region_components))
+            raise Exception, msg
+
+        msg = ('Each entry in regions have two components: (polygon, value). '
+               'I got %s' % str(num_region_components))
+        assert num_region_components == 2, msg
+
+        if geo_reference is None:
+            from anuga.coordinate_transforms.geo_reference import Geo_reference
+            geo_reference = Geo_reference()
+
+        self.default = default
+
+        # Make points in polygons relative to geo_reference
+        self.regions = []
+        for polygon, value in regions:
+            georeffed_poly = geo_reference.change_points_geo_ref(polygon)
+            self.regions.append((georeffed_poly, value))
+
+    def __call__(self, pts_x, pts_y):
+        """Implement the 'callable' property of Polygon_function.
+
+        x List of x coordinates of points ot interest.
+        y List of y coordinates of points ot interest.
+        """
+        pts_x = num.array(pts_x, num.float)
+        pts_y = num.array(pts_y, num.float)
+
+        # x and y must be one-dimensional and same length
+        assert len(pts_x.shape) == 1 and len(pts_y.shape) == 1
+        pts_len = pts_x.shape[0]
+        assert pts_y.shape[0] == pts_len, 'x and y must be same length'
+
+        points = num.ascontiguousarray(num.concatenate((pts_x[:, num.newaxis],
+                                                        pts_y[:, num.newaxis]),
+                                                       axis = 1 ))
+
+        if callable(self.default):
+            result = self.default(pts_x, pts_y)
+        else:
+            result = num.ones(pts_len, num.float) * self.default
+
+        for polygon, value in self.regions:
+            indices = inside_polygon(points, polygon)
+
+            # FIXME: This needs to be vectorised
+            if callable(value):
+                for i in indices:
+                    xx = num.array([pts_x[i]])
+                    yy = num.array([pts_y[i]])
+                    result[i] = value(xx, yy)[0]
+            else:
+                for i in indices:
+                    result[i] = value
+
+        if len(result) == 0:
+            msg = ('Warning: points provided to Polygon function did not fall '
+                   'within its regions in [%.2f, %.2f], y in [%.2f, %.2f]'
+                   % (min(pts_x), max(pts_x), min(pts_y), max(pts_y)))
+            log.critical(msg)
+
+        return result

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/geometry/quad.py

@@ -0,0 +1,190 @@
+"""quad.py - quad tree data structure for fast indexing of regions in the plane.
+
+This generic structure can be used to store any geometry in a quadtree.
+It is naive, and does not exploit any coherency - it merely tests a point
+against all bounding boxes in its heirarchy.
+
+It returns a list of bounding boxes which intersect with the test point, which
+may then be iterated over with a proper intersection test to detect actual
+geometry intersections.
+
+As of June 2010 this module has a pylint quality rating of 10/10.
+
+"""
+
+import anuga.utilities.log as log
+
+            
+class Cell():
+    """ One cell in the plane.
+        A cell is defined by an AABB, and can have smaller AABB children.
+        The children can be rapidly searched for intersections in log(n) time.
+    """
+  
+    def __init__(self, extents, parent,
+         name = 'cell'):
+        """ Construct a new cell.
+            extents is an AABB defining a region on the plane.
+            parent is the node above this one, or None if it is root.
+        """
+    
+        self.extents = extents
+        self.parent = parent
+        
+        # The points in this cell     
+        self.leaves = []
+        self.children = None
+        
+    
+    def __repr__(self):
+        """ String representation of the quadtree. """
+        ret_str = '%s: leaves: %d' \
+               % (self.name , len(self.leaves))    
+        if self.children:
+            ret_str += ', children: %d' % (len(self.children))
+        return ret_str
+
+
+    def insert(self, new_leaf):
+        """ Insert a leaf into the quadtree.
+            new_leaf is a tuple of (AABB extents, data), where data can
+                     be any user data (geometry, triangle index, etc.).
+        """
+        if type(new_leaf)==type(list()):
+            for leaf in new_leaf:
+                self.insert_item(leaf)
+        else:
+            self.insert_item(new_leaf)
+
+
+    def insert_item(self, new_leaf):   
+        """ Internal recursive insert a single item.
+            new_leaf is a tuple of (AABB extents, data), where data can
+                     be any user data (geometry, triangle index, etc.).       
+        """
+        new_region, _ = new_leaf
+        
+        # recurse down to any children until we get an intersection
+        if self.children:
+            for child in self.children:
+                if child.extents.is_trivial_in(new_region):
+                    child.insert_item(new_leaf)
+                    return
+        else:            
+            # try splitting this cell and see if we get a trivial in
+            subregion1, subregion2 = self.extents.split()
+            
+            # option 1 - try splitting 4 ways
+            #subregion11, subregion12 = subregion1.split()    
+            #subregion21, subregion22 = subregion2.split()
+            #regions = [subregion11, subregion12, subregion21, subregion22]
+            #for region in regions:
+                #if region.is_trivial_in(new_region):
+                    #self.children = [Cell(x, parent=self) for x in regions]
+                    #self.insert_item(new_leaf)
+                    #return               
+
+            # option 2 - try splitting 2 ways - no performance difference
+            # noticed in practise between this and the above option.
+            if subregion1.is_trivial_in(new_region):
+                self.children = [Cell(subregion1, self), \
+                                 Cell(subregion2, self)]    
+                self.children[0].insert_item(new_leaf)
+                return
+            elif subregion2.is_trivial_in(new_region):
+                self.children = [Cell(subregion1, self), \
+                                 Cell(subregion2, self)]    
+                self.children[1].insert_item(new_leaf)
+                return                
+    
+        # recursion ended without finding a fit, so attach it as a leaf
+        self.leaves.append(new_leaf)
+        
+     
+    def retrieve(self):
+        """Get all leaves from this tree.
+           return a traversal of the entire tree.
+        """
+        
+        leaves_found = list(self.leaves)
+        
+        if not self.children:
+            return leaves_found
+
+        for child in self.children:
+            leaves_found.extend(child.retrieve())
+            
+        return leaves_found
+
+    def count(self):
+        """Count all leaves from this tree.
+           return num of leaves in the tree.
+        """
+        
+        leaves_found = len(self.leaves)
+        
+        if not self.children:
+            return leaves_found
+
+        for child in self.children:
+            leaves_found += child.count()
+            
+        return leaves_found        
+
+    def show(self, depth=0):
+        """Traverse tree below self, dumping all information.
+        """
+        if depth == 0:
+            log.critical() 
+        print '%s%s'  % ('  '*depth, self.name), self.extents, ' [', \
+            self.leaves, ']'
+        if self.children:
+            log.critical()
+            for child in self.children:
+                child.show(depth+1)
+
+    def search(self, point):
+        """
+            Search the tree for intersection with leaves
+            point is a test point.
+            return a list of possible intersections with geometry.
+        """
+        intersecting_regions = self.test_leaves(point)
+        
+        # recurse down into nodes that the point passes through
+        if self.children:
+            for child in self.children:    
+                if child.extents.contains(point):
+                    intersecting_regions.extend(child.search(point))
+             
+        return intersecting_regions
+ 
+ 
+    def test_leaves(self, point):
+        """ Test all leaves on this node to see if they intersect x.
+            Does not recurse into children.
+            x is a point to test
+            return a list of leaves that intersect x
+        """
+        intersecting_regions = []
+        
+        # test all leaves to see if they intersect the point
+        for leaf in self.leaves:
+            aabb, data = leaf
+            if aabb.contains(point):
+                intersecting_regions.append([data, self])
+                
+        return intersecting_regions                
+ 
+ 
+    def get_siblings(self):
+        """ return siblings of this node. If there is no parent, it
+                   returns an empty list.
+        """
+        if not self.parent:
+            return []
+         
+        siblings = list(self.parent.children)
+        siblings.remove(self)
+        return siblings
+                

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/geometry/setup.py

@@ -0,0 +1,27 @@
+from __future__ import division, print_function
+
+import os
+import sys
+
+from os.path import join
+
+def configuration(parent_package='',top_path=None):
+    
+    from numpy.distutils.misc_util import Configuration
+    from numpy.distutils.system_info import get_info
+    
+    config = Configuration('geometry', parent_package, top_path)
+
+    config.add_data_dir('tests')
+
+    util_dir = os.path.abspath(join(os.path.dirname(__file__),'..','utilities'))
+    
+    config.add_extension('polygon_ext',
+                         sources=['polygon_ext.c'],
+                         include_dirs=[util_dir])
+    
+    return config
+    
+if __name__ == '__main__':
+    from numpy.distutils.core import setup
+    setup(configuration=configuration)

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/geometry/tests/__init__.py

@@ -0,0 +1,8 @@
+"""Make directory available as a Python package
+"""
+
+pass
+
+
+
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/geometry/tests/test_geometry.py

@@ -0,0 +1,110 @@
+""" Test for the geometry classes.
+
+    Pylint quality rating as of June 2010: 8.51/10.
+"""
+
+import unittest
+
+from anuga.geometry.aabb import AABB
+from anuga.geometry.quad import Cell
+
+#-------------------------------------------------------------
+
+class Test_Geometry(unittest.TestCase):
+    """ Test geometry classes. """
+    def setUp(self):
+        """ Generic set up for geometry tests. """
+        pass
+
+    def tearDown(self):
+        """ Generic shut down for geometry tests. """
+        pass
+
+    def test_aabb_contains(self):
+        """ Test if point is correctly classified as falling inside or
+            outside of bounding box. """
+        box = AABB(1, 21, 1, 11)
+        assert box.contains([10, 5])
+        assert box.contains([1, 1])
+        assert box.contains([20, 6])
+        assert not box.contains([-1, -1])
+        assert not box.contains([5, 70])
+        assert not box.contains([6, -70])
+        assert not box.contains([-1, 6])
+        assert not box.contains([50, 6])        
+        
+    def test_aabb_split_vert(self):
+        """ Test that a bounding box can be split correctly along an axis.
+        """
+        parent = AABB(1, 21, 1, 11)
+        
+        child1, child2 = parent.split(0.6)
+
+        self.assertEqual(child1.xmin, 1)
+        self.assertEqual(child1.xmax, 13)
+        self.assertEqual(child1.ymin, 1)
+        self.assertEqual(child1.ymax, 11)
+        
+        self.assertEqual(child2.xmin, 9)
+        self.assertEqual(child2.xmax, 21)
+        self.assertEqual(child2.ymin, 1)
+        self.assertEqual(child2.ymax, 11)    
+
+    def test_aabb_split_horiz(self):
+        """ Test that a bounding box will be split along the horizontal axis
+        correctly. """
+        parent = AABB(1, 11, 1, 41)
+        
+        child1, child2 = parent.split(0.6)
+
+        self.assertEqual(child1.xmin, 1)
+        self.assertEqual(child1.xmax, 11)
+        self.assertEqual(child1.ymin, 1)
+        self.assertEqual(child1.ymax, 25)
+        
+        self.assertEqual(child2.xmin, 1)
+        self.assertEqual(child2.xmax, 11)
+        self.assertEqual(child2.ymin, 17)
+        self.assertEqual(child2.ymax, 41)          
+        
+    def test_add_data(self):
+        """ Test add and retrieve arbitrary data from tree structure. """
+        cell = Cell(AABB(0, 10, 0, 5), None)
+        cell.insert([(AABB(1, 3, 1, 3), 111), (AABB(8, 9, 1, 2), 222),  \
+                     (AABB(7, 8, 3, 4), 333), (AABB(1, 10, 0, 1), 444)])
+
+        result = cell.retrieve()
+        assert isinstance(result, (list, tuple)), 'should be a list'
+
+        self.assertEqual(len(result), 4)
+        
+    def test_search(self):
+        """ Test search tree for an intersection. """
+        test_tag = 222
+        cell = Cell(AABB(0, 10, 0,5), None)
+        cell.insert([(AABB(1, 3, 1, 3), 111), (AABB(8, 9, 1, 2), test_tag),  \
+                     (AABB(7, 8, 3, 4), 333), (AABB(1, 10, 0, 1), 444)])
+
+        result = cell.search([8.5, 1.5])
+        assert isinstance(result, (list, tuple)), 'should be a list'
+        assert(len(result) == 1)
+        data, _ = result[0]
+        self.assertEqual(data, test_tag, 'only 1 point should intersect')
+
+    def test_get_siblings(self):
+        """ Make sure children know their parent. """
+        cell = Cell(AABB(0, 10, 0, 5), None)
+        cell.insert([(AABB(1, 3, 1, 3), 111), (AABB(8, 9, 1, 2), 222)])
+
+        assert len(cell.children) == 2
+        assert cell.parent == None
+        assert cell.children[0].parent == cell
+        assert cell.children[1].parent == cell
+
+
+################################################################################
+
+if __name__ == "__main__":
+    mysuite = unittest.makeSuite(Test_Geometry, 'test')
+    runner = unittest.TextTestRunner()
+    runner.run(mysuite)