Changeset 6120

Timestamp:

Jan 6, 2009, 4:26:24 PM (16 years ago)

Author:

ole

Message:

Added functionality to read multiple polygons with associated values from
a single csv file.

Location:

anuga_core/source/anuga/shallow_water

Files:

• data_manager.py (modified) (1 diff)
• test_data_manager.py (modified) (1 diff)

anuga_core/source/anuga/shallow_water/data_manager.py

@@ -996 +996 @@
 
 
+def csv2building_polygons(file_name, floor_height=3):
+    """
+    Convert CSV files of the form:
+
+    easting,northing,id,floors
+    422664.22,870785.46,2,0
+    422672.48,870780.14,2,0
+    422668.17,870772.62,2,0
+    422660.35,870777.17,2,0
+    422664.22,870785.46,2,0
+    422661.30,871215.06,3,1
+    422667.50,871215.70,3,1
+    422668.30,871204.86,3,1
+    422662.21,871204.33,3,1
+    422661.30,871215.06,3,1
+
+    to a dictionary of polygons with id as key.
+    The associated number of floors are converted to m above MSL and 
+    returned as a separate dictionary also keyed by id.
+    
+    Optional parameter floor_height is the height of each building story.
+    
+    See csv2polygons for more details
+    """
+
+    polygons, values = csv2polygons(file_name, value_name='floors')    
+
+    
+    heights = {}
+    for key in values.keys():
+        v = float(values[key])
+        heights[key] = v*floor_height
+        
+    return polygons, heights                
+            
+
+##
+# @brief Convert CSV file into a dictionary of polygons and associated values.
+# @param filename The path to the file to read, value_name name for the 4th column
+def csv2polygons(file_name, value_name='value'):
+    """
+    Convert CSV files of the form:
+
+    easting,northing,id,value
+    422664.22,870785.46,2,0
+    422672.48,870780.14,2,0
+    422668.17,870772.62,2,0
+    422660.35,870777.17,2,0
+    422664.22,870785.46,2,0
+    422661.30,871215.06,3,1
+    422667.50,871215.70,3,1
+    422668.30,871204.86,3,1
+    422662.21,871204.33,3,1
+    422661.30,871215.06,3,1
+
+    to a dictionary of polygons with id as key.
+    The associated values are returned as a separate dictionary also keyed by id.
+
+
+    easting: x coordinate relative to zone implied by the model
+    northing: y coordinate relative to zone implied by the model    
+    id: tag for polygon comprising points with this tag
+    value: numeral associated with each polygon. These must be the same for all points in each polygon.
+   
+    The last header, value, can take on other names such as roughness, floors, etc - or it can be omitted 
+    in which case the returned values will be None
+    
+    Eastings and Northings will be returned as floating point values while
+    id and values will be returned as strings.
+    
+    See underlying function csv2dict for more details.
+    """
+
+    X, _ = csv2dict(file_name)
+
+    msg = 'Polygon csv file must have 3 or 4 columns'
+    assert len(X.keys()) in [3, 4], msg
+    
+    msg = 'Did not find expected column header: easting'
+    assert 'easting' in X.keys(), msg
+    
+    msg = 'Did not find expected column header: northing'    
+    assert 'northing' in X.keys(), northing
+    
+    msg = 'Did not find expected column header: northing'        
+    assert 'id' in X.keys(), msg
+    
+    if value_name is not None:
+        msg = 'Did not find expected column header: %s' % value_name        
+        assert value_name in X.keys(), msg    
+    
+    polygons = {}
+    if len(X.keys()) == 4:
+        values = {}
+    else:
+        values = None
+
+    # Loop through entries and compose polygons
+    for i, id in enumerate(X['id']):
+        
+        if id not in polygons:
+            # Start new polygon
+            polygons[id] = []
+            if values is not None:
+                values[id] = X[value_name][i]
+            
+        # Append this point to current polygon
+        point = [float(X['easting'][i]), float(X['northing'][i])]
+        polygons[id].append(point)    
+            
+        # Check that value is the same across each polygon
+        assert values[id] == X[value_name][i]
+        
+    return polygons, values
+
+
+            
+            
 ##
 # @brief Convert CSV file to a dictionary of arrays.

anuga_core/source/anuga/shallow_water/test_data_manager.py

@@ -11042 +11042 @@
         assert (polygon == [[0.0, 0.0],[1.0, 0.0],[0.0, 1.0]])
         
-
-
-
+    
+    def test_csv2polygons(self):
+        """test_csv2polygons
+        """
+        
+        path = get_pathname_from_package('anuga.shallow_water')                
+        testfile = os.path.join(path, 'polygon_values_example.csv')                
+
+        polygons, values = csv2polygons(testfile, 
+                                        value_name='floors')
+
+        assert len(polygons) == 7, 'Must have seven polygons'
+        assert len(values) == 7, 'Must have seven values'
+            
+        # Known floor values
+        floors = {'1': 2, '2': 0, '3': 1, '4': 2, '5': 0, '8': 1, '9': 1}
+        
+        # Known polygon values
+        known_polys = {'1': [[422681.61,871117.55],
+                             [422691.02,871117.60],
+                             [422690.87,871084.23],
+                             [422649.36,871081.85],
+                             [422649.36,871080.39],
+                             [422631.86,871079.50],
+                             [422631.72,871086.75],
+                             [422636.75,871087.20],
+                             [422636.75,871091.50],
+                             [422649.66,871092.09],
+                             [422649.83,871084.91],
+                             [422652.94,871084.90],
+                             [422652.84,871092.39],
+                             [422681.83,871093.73],
+                             [422681.61,871117.55]],
+                       '2': [[422664.22,870785.46],
+                             [422672.48,870780.14],
+                             [422668.17,870772.62],
+                             [422660.35,870777.17],
+                             [422664.22,870785.46]],
+                       '3': [[422661.30,871215.06],
+                             [422667.50,871215.70],
+                             [422668.30,871204.86],
+                             [422662.21,871204.33],
+                             [422661.30,871215.06]],
+                       '4': [[422473.44,871191.22],
+                             [422478.33,871192.26],
+                             [422479.52,871186.03],
+                             [422474.78,871185.14],
+                             [422473.44,871191.22]],
+                       '5': [[422369.69,871049.29],
+                             [422378.63,871053.58],
+                             [422383.91,871044.51],
+                             [422374.97,871040.32],
+                             [422369.69,871049.29]],
+                       '8': [[422730.56,871203.13],
+                             [422734.10,871204.90],
+                             [422735.26,871202.18],
+                             [422731.87,871200.58],
+                             [422730.56,871203.13]],
+                       '9': [[422659.85,871213.80],
+                             [422660.91,871210.97],
+                             [422655.42,871208.85],
+                             [422654.36,871211.68],
+                             [422659.85,871213.80]]
+                       }        
+        
+
+        
+                
+        for id in ['1', '2', '3', '4', '5' ,'8' ,'9']:
+            assert id in polygons.keys()
+            assert id in values.keys()            
+
+            assert int(values[id]) == int(floors[id])
+            assert len(polygons[id]) == len(known_polys[id])
+            assert allclose(polygons[id], known_polys[id])
+
+
+    
+    def test_csv2building_polygons(self):
+        """test_csv2building_polygons
+        """
+        
+        path = get_pathname_from_package('anuga.shallow_water')                
+        testfile = os.path.join(path, 'polygon_values_example.csv')                
+
+        polygons, values = csv2building_polygons(testfile, 
+                                                 floor_height=3)
+
+        assert len(polygons) == 7, 'Must have seven polygons'
+        assert len(values) == 7, 'Must have seven values'
+            
+        # Known floor values
+        floors = {'1': 6, '2': 0, '3': 3, '4': 6, '5': 0, '8': 3, '9': 3}
+        
+                
+        for id in ['1', '2', '3', '4', '5' ,'8' ,'9']:
+            assert id in polygons.keys()
+            assert id in values.keys()            
+
+            assert float(values[id]) == float(floors[id])
+
+            
+            
 #-------------------------------------------------------------
 if __name__ == "__main__":
 
     suite = unittest.makeSuite(Test_Data_Manager,'test')
-#    suite = unittest.makeSuite(Test_Data_Manager,'test_export_gridIII')
     #suite = unittest.makeSuite(Test_Data_Manager,'test_file_boundary_stsIV_sinewave_ordering')
     #suite = unittest.makeSuite(Test_Data_Manager,'test_get_flow_through_cross_section_with_geo')