def test_triangulation_points_georeference(self): # # filename = tempfile.mktemp("_data_manager.sww") outfile = NetCDFFile(filename, netcdf_mode_w) points_utm = num.array([[0.,0.],[1.,1.], [0.,1.]]) volumes = [[0,1,2]] elevation = [0,1,2] new_origin = None points_georeference = Geo_reference(56, 1, 554354) points_utm = points_georeference.change_points_geo_ref(points_utm) times = [0, 10] number_of_volumes = len(volumes) number_of_points = len(points_utm) sww = Write_sww(['elevation'], ['stage', 'xmomentum', 'ymomentum']) sww.store_header(outfile, times, number_of_volumes, number_of_points, description='fully sick testing', verbose=self.verbose,sww_precision=netcdf_float) sww.store_triangulation(outfile, points_utm, volumes, elevation, new_origin=new_origin, points_georeference=points_georeference, verbose=self.verbose) outfile.close() fid = NetCDFFile(filename) x = fid.variables['x'][:] y = fid.variables['y'][:] results_georef = Geo_reference() results_georef.read_NetCDF(fid) assert results_georef == points_georeference fid.close() assert num.allclose(num.array(map(None, x,y)), points_utm) os.remove(filename)
def test_triangulation_2_geo_refs(self): # # filename = tempfile.mktemp("_data_manager.sww") outfile = NetCDFFile(filename, netcdf_mode_w) points_utm = num.array([[0., 0.], [1., 1.], [0., 1.]]) volumes = [[0, 1, 2]] elevation = [0, 1, 2] new_origin = Geo_reference(56, 1, 1) points_georeference = Geo_reference(56, 0, 0) points_utm = points_georeference.change_points_geo_ref(points_utm) times = [0, 10] number_of_volumes = len(volumes) number_of_points = len(points_utm) sww = Write_sww(['elevation'], ['stage', 'xmomentum', 'ymomentum']) sww.store_header(outfile, times, number_of_volumes, number_of_points, description='fully sick testing', verbose=self.verbose, sww_precision=netcdf_float) sww.store_triangulation(outfile, points_utm, volumes, elevation, new_origin=new_origin, points_georeference=points_georeference, verbose=self.verbose) outfile.close() fid = NetCDFFile(filename) x = fid.variables['x'][:] y = fid.variables['y'][:] results_georef = Geo_reference() results_georef.read_NetCDF(fid) assert results_georef == new_origin fid.close() absolute = Geo_reference(56, 0, 0) assert num.allclose( num.array( absolute.change_points_geo_ref(map(None, x, y), new_origin)), points_utm) os.remove(filename)
def concept_create_mesh_from_regions_with_ungenerate(self): x=0 y=0 mesh_geo = geo_reference=Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0,0], [100,0], [100,100], [0,100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0,1], 'bom': [2]} inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) max_area = 10000000 interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, max_area, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo) m.export_mesh_file('a_test_mesh_iknterface.tsh') fileName = tempfile.mktemp('.txt') file = open(fileName, 'w') file.write(' 1 ?? ??\n\ 90.0 90.0\n\ 81.0 90.0\n\ 81.0 81.0\n\ 90.0 81.0\n\ 90.0 90.0\n\ END\n\ 2 ?? ??\n\ 10.0 80.0\n\ 10.0 90.0\n\ 20.0 90.0\n\ 10.0 80.0\n\ END\n\ END\n') file.close() m.import_ungenerate_file(fileName, tag='wall') os.remove(fileName) m.generate_mesh(maximum_triangle_area=max_area, verbose=False) m.export_mesh_file('b_test_mesh_iknterface.tsh')
def concept_create_mesh_from_regions_with_ungenerate(self): x = 0 y = 0 mesh_geo = geo_reference = Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0, 1], 'bom': [2]} inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) max_area = 10000000 interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, max_area, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo) m.export_mesh_file('a_test_mesh_iknterface.tsh') fileName = tempfile.mktemp('.txt') file = open(fileName, 'w') file.write(' 1 ?? ??\n\ 90.0 90.0\n\ 81.0 90.0\n\ 81.0 81.0\n\ 90.0 81.0\n\ 90.0 90.0\n\ END\n\ 2 ?? ??\n\ 10.0 80.0\n\ 10.0 90.0\n\ 20.0 90.0\n\ 10.0 80.0\n\ END\n\ END\n') file.close() m.import_ungenerate_file(fileName, tag='wall') os.remove(fileName) m.generate_mesh(maximum_triangle_area=max_area, verbose=False) m.export_mesh_file('b_test_mesh_iknterface.tsh')
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 __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 test_create_mesh_from_regions2(self): # These are the absolute values min_x = -10 min_y = -88 polygon_absolute = [[min_x, min_y], [1000, 100], [1000, 1000], [100, 1000]] x_p = -10 y_p = -40 zone = 808 geo_ref_poly = Geo_reference(zone, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0, 1], 'bom': [2, 3]} inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, 10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly) # Test the mesh instance self.assertTrue(len(m.regions) == 3, 'FAILED!') segs = m.getUserSegments() self.assertTrue(len(segs) == 12, 'FAILED!') self.assertTrue(len(m.userVertices) == 12, 'FAILED!') self.assertTrue(segs[0].tag == 'walls', 'FAILED!') self.assertTrue(segs[1].tag == 'walls', 'FAILED!') self.assertTrue(segs[2].tag == 'bom', 'FAILED!') self.assertTrue(segs[3].tag == 'bom', 'FAILED!') self.assertTrue(m.geo_reference.get_zone() == zone, 'FAILED!') self.assertTrue(m.geo_reference.get_xllcorner() == min_x, 'FAILED!') self.assertTrue(m.geo_reference.get_yllcorner() == min_y, 'FAILED!')
def test_create_mesh_from_regions2(self): # These are the absolute values min_x = -10 min_y = -88 polygon_absolute = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]] x_p = -10 y_p = -40 zone = 808 geo_ref_poly = Geo_reference(zone, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0,1], 'bom': [2,3]} inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, 10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly) # Test the mesh instance self.assertTrue(len(m.regions)==3, 'FAILED!') segs = m.getUserSegments() self.assertTrue(len(segs)==12, 'FAILED!') self.assertTrue(len(m.userVertices)==12, 'FAILED!') self.assertTrue(segs[0].tag=='walls', 'FAILED!') self.assertTrue(segs[1].tag=='walls', 'FAILED!') self.assertTrue(segs[2].tag=='bom', 'FAILED!') self.assertTrue(segs[3].tag=='bom', 'FAILED!') self.assertTrue(m.geo_reference.get_zone()==zone, 'FAILED!') self.assertTrue(m.geo_reference.get_xllcorner()==min_x, 'FAILED!') self.assertTrue(m.geo_reference.get_yllcorner()==min_y, 'FAILED!')
def test_create_mesh_from_regions_with_duplicate_verts(self): # These are the absolute values polygon_absolute = [[0.0, 0.0], [0, 4.0], [4.0, 4.0], [4.0, 0.0], [4.0, 0.0]] x_p = -10 y_p = -40 zone = 808 geo_ref_poly = Geo_reference(zone, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = { '50': [0], '40': [1], '30': [2], 'no where seg': [3], '20': [4] } m = create_mesh_from_regions(polygon, boundary_tags, 10000000, poly_geo_reference=geo_ref_poly, verbose=False) fileName = 'badmesh.tsh'
def test_create_mesh_from_regions_with_duplicate_verts(self): # These are the absolute values polygon_absolute = [[0.0, 0.0], [0, 4.0], [4.0, 4.0], [4.0, 0.0], [4.0, 0.0]] x_p = -10 y_p = -40 zone = 808 geo_ref_poly = Geo_reference(zone, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'50': [0], '40': [1], '30': [2], 'no where seg': [3], '20': [4]} m = create_mesh_from_regions(polygon, boundary_tags, 10000000, poly_geo_reference=geo_ref_poly, verbose=False) fileName = 'badmesh.tsh'
def concept_ungenerateII(self): from anuga import Domain, Reflective_boundary, Dirichlet_boundary x = 0 y = 0 mesh_geo = geo_reference = Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'wall': [0, 1, 3], 'wave': [2]} inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) max_area = 1 interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, max_area, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo) m.export_mesh_file('a_test_mesh_iknterface.tsh') fileName = tempfile.mktemp('.txt') file = open(fileName, 'w') file.write(' 1 ?? ??\n\ 90.0 90.0\n\ 81.0 90.0\n\ 81.0 81.0\n\ 90.0 81.0\n\ 90.0 90.0\n\ END\n\ 2 ?? ??\n\ 10.0 80.0\n\ 10.0 90.0\n\ 20.0 90.0\n\ 10.0 80.0\n\ END\n\ END\n') file.close() m.import_ungenerate_file(fileName) #, tag='wall') os.remove(fileName) m.generate_mesh(maximum_triangle_area=max_area, verbose=False) mesh_filename = 'bento_b.tsh' m.export_mesh_file(mesh_filename) domain = Domain(mesh_filename, use_cache=False) Br = Reflective_boundary(domain) Bd = Dirichlet_boundary([3, 0, 0]) domain.set_boundary({'wall': Br, 'wave': Bd}) yieldstep = 0.1 finaltime = 10 for t in domain.evolve(yieldstep, finaltime): domain.write_time()
def test_create_mesh_from_regions(self): x = -500 y = -1000 mesh_geo = geo_reference = Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0, 1], 'bom': [2, 3]} inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, 10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo) # Test the mesh instance self.assertTrue(len(m.regions) == 3, 'FAILED!') segs = m.getUserSegments() self.assertTrue(len(segs) == 12, 'FAILED!') self.assertTrue(len(m.userVertices) == 12, 'FAILED!') self.assertTrue(segs[0].tag == 'walls', 'FAILED!') self.assertTrue(segs[1].tag == 'walls', 'FAILED!') self.assertTrue(segs[2].tag == 'bom', 'FAILED!') self.assertTrue(segs[3].tag == 'bom', 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[0] # poly_point values are relative to the mesh geo-ref # make them absolute msg = ('Expected point (%s,%s) to be inside polygon %s' % (str(poly_point.x + x), str(poly_point.y + y), str(polygon_absolute))) self.assertTrue( is_inside_polygon([poly_point.x + x, poly_point.y + y], polygon_absolute, closed=False), msg) # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[1] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue( is_inside_polygon([poly_point.x + x, poly_point.y + y], inner1_polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[2] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue( is_inside_polygon([poly_point.x + x, poly_point.y + y], inner2_polygon_absolute, closed=False), 'FAILED!')
def test_create_mesh_from_regions_with_caching(self): x = -500 y = -1000 mesh_geo = geo_reference = Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0, 1], 'bom': [2, 3]} inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] interior_holes = None # Clear cache first from anuga.caching import cache cache(_create_mesh_from_regions, (polygon, boundary_tags), { 'minimum_triangle_angle': 28.0, 'maximum_triangle_area': 10000000, 'interior_regions': interior_regions, 'interior_holes': interior_holes, 'poly_geo_reference': geo_ref_poly, 'mesh_geo_reference': mesh_geo, 'verbose': False }, verbose=False, clear=1) m = create_mesh_from_regions(polygon, boundary_tags, maximum_triangle_area=10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo, verbose=False, use_cache=True) # Test the mesh instance self.assertTrue(len(m.regions) == 3, 'FAILED!') segs = m.getUserSegments() self.assertTrue(len(segs) == 12, 'FAILED!') self.assertTrue(len(m.userVertices) == 12, 'FAILED!') self.assertTrue(segs[0].tag == 'walls', 'FAILED!') self.assertTrue(segs[1].tag == 'walls', 'FAILED!') self.assertTrue(segs[2].tag == 'bom', 'FAILED!') self.assertTrue(segs[3].tag == 'bom', 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[0] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue( is_inside_polygon([poly_point.x + x, poly_point.y + y], polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[1] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue( is_inside_polygon([poly_point.x + x, poly_point.y + y], inner1_polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[2] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue( is_inside_polygon([poly_point.x + x, poly_point.y + y], inner2_polygon_absolute, closed=False), 'FAILED!') # Now create m using cached values m_cache = create_mesh_from_regions(polygon, boundary_tags, 10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo, verbose=False, use_cache=True)
def store_points(self, outfile, points_utm, elevation, zone=None, new_origin=None, points_georeference=None, verbose=False): """ points_utm - currently a list or array of the points in UTM. points_georeference - the georeference of the points_utm How about passing new_origin and current_origin. If you get both, do a convertion from the old to the new. If you only get new_origin, the points are absolute, convert to relative if you only get the current_origin the points are relative, store as relative. if you get no georefs create a new georef based on the minimums of points_utm. (Another option would be to default to absolute) Yes, and this is done in another part of the code. Probably geospatial. If you don't supply either geo_refs, then supply a zone. If not the default zone will be used. precondition: header has been called. """ number_of_points = len(points_utm) points_utm = num.array(points_utm) # given the two geo_refs and the points, do the stuff # described in the method header points_georeference = ensure_geo_reference(points_georeference) new_origin = ensure_geo_reference(new_origin) if new_origin is None and points_georeference is not None: points = points_utm geo_ref = points_georeference else: if new_origin is None: new_origin = Geo_reference(zone, min(points_utm[:,0]), min(points_utm[:,1])) points = new_origin.change_points_geo_ref(points_utm, points_georeference) geo_ref = new_origin # At this stage I need a georef and points # the points are relative to the georef geo_ref.write_NetCDF(outfile) x = points[:,0] y = points[:,1] z = outfile.variables['elevation'][:] if verbose: log.critical('------------------------------------------------') log.critical('More Statistics:') log.critical(' Extent (/lon):') log.critical(' x in [%f, %f], len(lat) == %d' % (min(x), max(x), len(x))) log.critical(' y in [%f, %f], len(lon) == %d' % (min(y), max(y), len(y))) log.critical(' z in [%f, %f], len(z) == %d' % (min(elevation), max(elevation), len(elevation))) log.critical('geo_ref: %s' % str(geo_ref)) log.critical('------------------------------------------------') z = resize(bath_grid,outfile.variables['elevation'][:].shape) outfile.variables['x'][:] = points[:,0] #- geo_ref.get_xllcorner() outfile.variables['y'][:] = points[:,1] #- geo_ref.get_yllcorner() #outfile.variables['z'][:] = elevation outfile.variables['elevation'][:] = elevation #FIXME HACK4 # This updates the _range values q = 'elevation' outfile.variables[q + Write_sts.RANGE][0] = min(elevation) outfile.variables[q + Write_sts.RANGE][1] = max(elevation)
def store_points(self, outfile, points_utm, elevation, zone=None, new_origin=None, points_georeference=None, verbose=False): """ points_utm - currently a list or array of the points in UTM. points_georeference - the georeference of the points_utm How about passing new_origin and current_origin. If you get both, do a convertion from the old to the new. If you only get new_origin, the points are absolute, convert to relative if you only get the current_origin the points are relative, store as relative. if you get no georefs create a new georef based on the minimums of points_utm. (Another option would be to default to absolute) Yes, and this is done in another part of the code. Probably geospatial. If you don't supply either geo_refs, then supply a zone. If not the default zone will be used. precondition: header has been called. """ number_of_points = len(points_utm) points_utm = num.array(points_utm) # given the two geo_refs and the points, do the stuff # described in the method header points_georeference = ensure_geo_reference(points_georeference) new_origin = ensure_geo_reference(new_origin) if new_origin is None and points_georeference is not None: points = points_utm geo_ref = points_georeference else: if new_origin is None: new_origin = Geo_reference(zone, min(points_utm[:, 0]), min(points_utm[:, 1])) points = new_origin.change_points_geo_ref(points_utm, points_georeference) geo_ref = new_origin # At this stage I need a georef and points # the points are relative to the georef geo_ref.write_NetCDF(outfile) x = points[:, 0] y = points[:, 1] z = outfile.variables['elevation'][:] if verbose: log.critical('------------------------------------------------') log.critical('More Statistics:') log.critical(' Extent (/lon):') log.critical(' x in [%f, %f], len(lat) == %d' % (min(x), max(x), len(x))) log.critical(' y in [%f, %f], len(lon) == %d' % (min(y), max(y), len(y))) log.critical(' z in [%f, %f], len(z) == %d' % (min(elevation), max(elevation), len(elevation))) log.critical('geo_ref: %s' % str(geo_ref)) log.critical('------------------------------------------------') z = resize(bath_grid, outfile.variables['elevation'][:].shape) outfile.variables['x'][:] = points[:, 0] #- geo_ref.get_xllcorner() outfile.variables['y'][:] = points[:, 1] #- geo_ref.get_yllcorner() #outfile.variables['z'][:] = elevation outfile.variables['elevation'][:] = elevation #FIXME HACK4 # This updates the _range values q = 'elevation' outfile.variables[q + Write_sts.RANGE][0] = min(elevation) outfile.variables[q + Write_sts.RANGE][1] = max(elevation)
def concept_ungenerateII(self): from anuga import Domain, Reflective_boundary, Dirichlet_boundary x=0 y=0 mesh_geo = geo_reference=Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0,0], [100,0], [100,100], [0,100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'wall': [0,1,3], 'wave': [2]} inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) max_area = 1 interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, max_area, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo) m.export_mesh_file('a_test_mesh_iknterface.tsh') fileName = tempfile.mktemp('.txt') file = open(fileName, 'w') file.write(' 1 ?? ??\n\ 90.0 90.0\n\ 81.0 90.0\n\ 81.0 81.0\n\ 90.0 81.0\n\ 90.0 90.0\n\ END\n\ 2 ?? ??\n\ 10.0 80.0\n\ 10.0 90.0\n\ 20.0 90.0\n\ 10.0 80.0\n\ END\n\ END\n') file.close() m.import_ungenerate_file(fileName) #, tag='wall') os.remove(fileName) m.generate_mesh(maximum_triangle_area=max_area, verbose=False) mesh_filename = 'bento_b.tsh' m.export_mesh_file(mesh_filename) domain = Domain(mesh_filename, use_cache = False) Br = Reflective_boundary(domain) Bd = Dirichlet_boundary([3, 0, 0]) domain.set_boundary({'wall': Br, 'wave': Bd}) yieldstep = 0.1 finaltime = 10 for t in domain.evolve(yieldstep, finaltime): domain.write_time()
def test_create_mesh_from_regions(self): x=-500 y=-1000 mesh_geo = geo_reference=Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0,0], [100,0], [100,100], [0,100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0,1], 'bom': [2,3]} inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, 10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo) # Test the mesh instance self.assertTrue(len(m.regions)==3, 'FAILED!') segs = m.getUserSegments() self.assertTrue(len(segs)==12, 'FAILED!') self.assertTrue(len(m.userVertices)==12, 'FAILED!') self.assertTrue(segs[0].tag=='walls', 'FAILED!') self.assertTrue(segs[1].tag=='walls', 'FAILED!') self.assertTrue(segs[2].tag=='bom', 'FAILED!') self.assertTrue(segs[3].tag=='bom', 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[0] # poly_point values are relative to the mesh geo-ref # make them absolute msg = ('Expected point (%s,%s) to be inside polygon %s' % (str(poly_point.x+x), str(poly_point.y+y), str(polygon_absolute))) self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y], polygon_absolute, closed=False), msg) # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[1] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y], inner1_polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[2] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y], inner2_polygon_absolute, closed=False), 'FAILED!')
def test_create_mesh_from_regions_with_caching(self): x=-500 y=-1000 mesh_geo = geo_reference=Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0,0], [100,0], [100,100], [0,100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'walls': [0,1], 'bom': [2,3]} inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] interior_holes = None # Clear cache first from anuga.caching import cache cache(_create_mesh_from_regions, (polygon, boundary_tags), {'minimum_triangle_angle': 28.0, 'maximum_triangle_area': 10000000, 'interior_regions': interior_regions, 'interior_holes': interior_holes, 'poly_geo_reference': geo_ref_poly, 'mesh_geo_reference': mesh_geo, 'verbose': False}, verbose=False, clear=1) m = create_mesh_from_regions(polygon, boundary_tags, maximum_triangle_area=10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo, verbose=False, use_cache=True) # Test the mesh instance self.assertTrue(len(m.regions)==3, 'FAILED!') segs = m.getUserSegments() self.assertTrue(len(segs)==12, 'FAILED!') self.assertTrue(len(m.userVertices)==12, 'FAILED!') self.assertTrue(segs[0].tag=='walls', 'FAILED!') self.assertTrue(segs[1].tag=='walls', 'FAILED!') self.assertTrue(segs[2].tag=='bom', 'FAILED!') self.assertTrue(segs[3].tag=='bom', 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[0] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y], polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[1] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y], inner1_polygon_absolute, closed=False), 'FAILED!') # Assuming the order of the region points is known. # (This isn't true, if you consider create_mesh_from_regions # a black box) poly_point = m.getRegions()[2] # poly_point values are relative to the mesh geo-ref # make them absolute self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y], inner2_polygon_absolute, closed=False), 'FAILED!') # Now create m using cached values m_cache = create_mesh_from_regions(polygon, boundary_tags, 10000000, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo, verbose=False, use_cache=True)