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)
