Context Navigation

source: inundation/pmesh/test_mesh.py @ 3236

Last change on this file since 3236 was 3213, checked in by duncan, 19 years ago
name change
File size: 80.0 KB

Rev	Line
[349]	1	#!/usr/bin/env python
	2	#
	3	import tempfile
	4	import unittest
[2282]	5
[3213]	6	#try:
	7	from pmesh.mesh import *
	8	#except ImportError:
	9	# from mesh import *
[2282]	10
[349]	11	from load_mesh.loadASCII import *
[1023]	12	from coordinate_transforms.geo_reference import Geo_reference
[3177]	13	from geospatial_data.geospatial_data import Geospatial_data
[3097]	14	from utilities.polygon import is_inside_polygon ### inside_polygon
[349]	15
	16	class meshTestCase(unittest.TestCase):
	17	def setUp(self):
	18	pass
[2276]	19
[349]	20	def tearDown(self):
	21	pass
	22
	23	def testPointDistance(self):
	24	a = Point(0.0, 0.0)
	25	b = Point(0.0, 10.0)
	26
	27	self.failUnless( a.DistanceToPoint(b) == 10.0,
	28	'Point DistanceToPoint is wrong!')
	29
	30	def testVertexDistance(self):
	31	a = Vertex (0.0, 0.0)
	32	b = Vertex (0.0, 10.0)
	33
	34	self.failUnless( a.DistanceToPoint(b) == 10.0,
	35	'Point DistanceToPoint is wrong!')
	36
	37	def testTriangle(self):
	38	a = Vertex (0.0, 0.0)
	39	b = Vertex (0.0, 2.0)
	40	c = Vertex (2.0,0.0)
	41	d = Vertex (0.0, 4.0)
	42	e = Vertex (2.0, 2.0)
	43	f = Vertex (4.0,0.0)
	44
	45	t1 = Triangle(b,a,c)
	46	t2 = Triangle(b,c,e)
	47	t3 = Triangle(e,c,f)
	48	t4 = Triangle(d,b,e)
	49	t2.setNeighbors(t3,t4,t1)
	50
	51	self.failUnless( t2.neighbors[2].vertices[0] == b, 'Triangle initialisation is wrong!')
	52
	53
	54	def testSegment(self):
	55	a = Vertex (0.0, 0.0)
	56	b = Vertex (0.0, 10.0)
[969]	57	s = Segment(a,b, tag = 20)
[349]	58
	59	self.failUnless( s.vertices[0].DistanceToPoint(s.vertices[1]) == 10.0,
	60	'vertices in a segment are wrong')
	61
[969]	62	self.failUnless( s.tag == 20.0,
	63	'tag in a segment are wrong')
[349]	64
	65	def testdeleteUserVertex(self):
	66
	67
	68	mesh = Mesh()
	69	a = mesh.addUserVertex(0.0, 0.0)
	70	b = mesh.addUserVertex (0.0, 2.0)
	71	c = mesh.addUserVertex (2.0,0.0)
	72
	73	s1 = mesh.addUserSegment(a,b)
	74	s2 = mesh.addUserSegment(a,c)
	75	s3 = mesh.addUserSegment(c,b)
	76
	77	mesh.deleteMeshObject (a)
	78	self.failUnless(mesh.userSegments[0] == s3,
	79	'Bad segment. ')
	80	self.failUnless(len(mesh.userSegments) ==1,
	81	'Segments not deleted.')
	82	self.failUnless(len(mesh.userVertices) == 2,
	83	'Vertex not deleted.')
	84
	85
[2276]	86	# FIXME add test for minAngle
[349]	87	def testgenerateMesh(self):
	88	a = Vertex (0.0, 0.0)
	89	d = Vertex (0.0, 4.0)
	90	f = Vertex (4.0,0.0)
	91
	92	s1 = Segment(a,d)
	93	s2 = Segment(d,f)
	94	s3 = Segment(a,f)
	95
	96	r1 = Region(0.3, 0.3,tag = 1.3,maxArea = .6)
	97	#print r1
	98	m = Mesh(userVertices=[a,d,f], userSegments=[s1,s2,s3], regions=[r1] )
	99
[2346]	100	m.generateMesh("Q", maxArea = 2.1 )
[349]	101
	102	#print m
	103
	104	#m.plotMeshTriangle()
	105
	106	result = 1.414214
	107	delta = 0.00001
	108
	109	self.failUnless((m.meshTriangles[1].vertices[0].x < result + delta) or
	110	(m.meshTriangles[1].vertices[0].x > result - delta),
	111	'generated mesh is wrong!')
	112
	113	def test_regionalMaxArea(self):
	114	v0 = Vertex (0.0, 0.0)
	115	v1 = Vertex (6.0, 0.0)
	116	v2 = Vertex (6.0,6.0)
	117	v3 = Vertex (0.0,6.0)
	118
	119	s1 = Segment(v0,v1)
	120	s2 = Segment(v1,v2)
	121	s3 = Segment(v3,v2)
	122	s4 = Segment(v3,v0)
	123	s5 = Segment(v2,v0)
	124
	125	r1 = Region(3, 1,tag = 1.3)
	126	#print r1
	127	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5], regions=[r1] )
	128
[2346]	129	m.generateMesh("Q", maxArea = 36 )
[349]	130
	131	#m.plotMeshTriangle()
	132	#print "len(m.meshTriangles)",len(m.meshTriangles)
	133
	134	self.failUnless(len(m.meshTriangles) == 2,
	135	'test_regionalMaxArea 1:generated mesh is wrong!')
	136
	137	## Another test case
	138	r1 = Region(3, 1,tag = 1.3)
	139	r2 = Region(1, 3,tag = 1.3, maxArea = 8)
	140	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
	141	regions=[r1,r2] )
[2346]	142	m.generateMesh("Q", maxArea = 36 )
[349]	143
[2141]	144	self.failUnless(len(m.meshTriangles) >= 6,
	145	'testregion_with_maxarea 2: # of tris is wrong!')
[2030]	146
	147
[349]	148	## Another test case
	149	r1 = Region(3, 1, tag = 1.3, maxArea = 8)
	150	r2 = Region(1, 3, tag = 1.3, maxArea = 8)
	151	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
	152	regions=[r1,r2] )
[2346]	153	m.generateMesh("Q", maxArea = 36 )
[2030]	154	#print "len(m.meshTriangles)",len(m.meshTriangles)
[349]	155
[2141]	156	self.failUnless(len(m.meshTriangles) >= 8,
[2030]	157	'testregion_with_maxarea 3: # of tris is wrong!')
	158
	159
[349]	160	## Another test case
	161	r1 = Region(3, 1, tag = 1.3 )
	162	r2 = Region(1, 3, tag = 1.3, maxArea = 8)
	163	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
	164	regions=[r1,r2] )
[2346]	165	m.generateMesh("Q", maxArea = 8 )
[2141]	166	self.failUnless(len(m.meshTriangles) >= 8,
	167	'testregion_with_maxarea 4: # of tris is wrong!')
[2030]	168
[349]	169
	170	## Another test case
	171	r1 = Region(3, 1,tag = 1.3, maxArea = 8)
	172	r2 = Region(1, 3,tag = 1.3, maxArea = 8)
	173	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
	174	regions=[r1,r2] )
[2346]	175	m.generateMesh("Q", maxArea = 36,isRegionalMaxAreas = False )
[349]	176	self.failUnless(len(m.meshTriangles) == 2,
	177	'test_regionalMaxArea 5:generated mesh is wrong!')
	178
[3193]	179	## Another test case
	180	r1 = Region(3, 1,tag = 1.3, maxArea = 8)
	181	r2 = Region(1, 3,tag = 1.3, maxArea = 8)
	182	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
	183	regions=[r1,r2] )
	184	m.generateMesh("Q",isRegionalMaxAreas = False )
	185	self.failUnless(len(m.meshTriangles) == 2,
	186	'test_regionalMaxArea 5:generated mesh is wrong!')
	187
	188	def test_generate_mesh(self):
	189	v0 = Vertex (0.0, 0.0)
	190	v1 = Vertex (6.0, 0.0)
	191	v2 = Vertex (6.0,6.0)
	192	v3 = Vertex (0.0,6.0)
	193
	194	s1 = Segment(v0,v1)
	195	s2 = Segment(v1,v2)
	196	s3 = Segment(v3,v2)
	197	s4 = Segment(v3,v0)
	198	s5 = Segment(v2,v0)
	199
	200	r1 = Region(3, 1,tag = 1.3)
	201	#print r1
	202	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
	203	regions=[r1] )
	204
	205	m.generate_mesh(maximum_triangle_area=36,verbose=False)
	206
	207	self.failUnless(len(m.meshTriangles) == 2,
	208	'test_regionalMaxArea 1:generated mesh is wrong!')
	209
	210	## Another test case
	211	r1 = Region(3, 1,tag = 1.3)
	212	r2 = Region(1, 3,tag = 1.3, maxArea = 8)
	213	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
	214	regions=[r1,r2] )
	215	m.generate_mesh(maximum_triangle_area=36,verbose=False)
	216
	217	self.failUnless(len(m.meshTriangles) >= 6,
	218	'testregion_with_maxarea 2: # of tris is wrong!')
	219
	220	## Another test case
	221	r1 = Region(3, 1, tag = 1.3, maxArea = 8)
	222	r2 = Region(1, 3, tag = 1.3, maxArea = 8)
	223	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
	224	regions=[r1,r2] )
	225	m.generate_mesh(maximum_triangle_area=36,verbose=False)
	226	#print "len(m.meshTriangles)",len(m.meshTriangles)
	227
	228	self.failUnless(len(m.meshTriangles) >= 8,
	229	'testregion_with_maxarea 3: # of tris is wrong!')
	230
	231	## Another test case
	232	r1 = Region(3, 1, tag = 1.3 )
	233	r2 = Region(1, 3, tag = 1.3, maxArea = 8)
	234	m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
	235	regions=[r1,r2] )
	236	m.generate_mesh(maximum_triangle_area=8,verbose=False)
	237	self.failUnless(len(m.meshTriangles) >= 8,
	238	'testregion_with_maxarea 4: # of tris is wrong!')
	239
	240	## Another test case r1 = Region(3, 1,tag = 1.3, maxArea = 8)
	241	r2 = Region(1, 3,tag = 1.3, maxArea = 8)
	242	m = Mesh(userVertices=[v0,v1,v2,v3],
	243	userSegments=[s1,s2,s3,s4,s5], regions=[r1,r2] )
	244	m.generate_mesh(verbose=False)
	245	#print "en(m.meshTriangles)", len(m.meshTriangles)
	246	self.failUnless(len(m.meshTriangles) >= 8,
	247	'You have issues!')
	248
[349]	249	def testdeleteUserVertex(self):
	250	mesh = Mesh()
	251	a = mesh.addUserVertex(0.0, 0.0)
	252	b = mesh.addUserVertex (0.0, 2.0)
	253	c = mesh.addUserVertex (2.0,0.0)
	254
	255	s1 = mesh.addUserSegment(a,b)
	256	s2 = mesh.addUserSegment(a,c)
	257	s3 = mesh.addUserSegment(c,b)
	258
	259	mesh.deleteMeshObject (s2)
	260
	261	#print ",s2 in mesh.userSegments" ,s2 in mesh.userSegments
	262	self.failUnless(not(s2 in mesh.userSegments),
	263	'Bad segment. ')
	264	self.failUnless(len(mesh.userSegments) ==2,
	265	'Segments not deleted.')
	266	self.failUnless(len(mesh.userVertices) == 3,
	267	'Vertex deleted, instead of segment.')
	268
	269	def testTriangleArea(self):
	270	a = Vertex (10.0, 10.0)
	271	b = Vertex (10.0, 20.0)
	272	c = Vertex (20.0,10.0)
	273
	274	d = Vertex (-20.0, 0.0)
	275	e = Vertex (-20.0, -20.0)
	276	f = Vertex (20.0,-20.0)
	277
	278	t1 = Triangle(b,a,c)
	279	t2 = Triangle(e,d,f)
	280
	281	# print "t1", t1
	282	# print "t1 area ", t1.calcArea()
	283	# print "t2", t2
	284	# print "t2 area ", t2.calcArea()
	285	self.failUnless( t1.calcArea() == 50 and t2.calcArea() == 400, 'Triangle area is wrong!')
	286	def testisUserSegmentNew (self):
	287	mesh = Mesh()
	288	a = mesh.addUserVertex(0.0, 0.0)
	289	b = mesh.addUserVertex (0.0, 2.0)
	290	c = mesh.addUserVertex (2.0,0.0)
	291	d = mesh.addUserVertex (2.0,3.0)
	292
	293	s1 = mesh.addUserSegment(a,b)
	294	s2 = mesh.addUserSegment(a,c)
	295	s3 = mesh.addUserSegment(c,b)
	296
	297	self.failUnless(mesh.isUserSegmentNew(a,d) ,
	298	'Segment should be new. ')
	299	self.failUnless(not(mesh.isUserSegmentNew(a,b)) ,
	300	'Segment should not be new. ')
	301
[702]	302
[3013]	303	def testisUserSegmentNewII (self):
[702]	304	mesh = Mesh()
	305	a = mesh.addUserVertex(0.0, 0.0)
	306	b = mesh.addUserVertex (0.0, 2.0)
	307	c = mesh.addUserVertex (2.0,0.0)
	308	d = mesh.addUserVertex (2.0,3.0)
[349]	309
[702]	310	s1 = mesh.addUserSegment(a,b)
	311	s2 = mesh.addUserSegment(a,c)
	312	s3 = mesh.addUserSegment(c,b)
[349]	313
[702]	314	self.failUnless(mesh.representedUserSegment(a,d) == None,
	315	'Segment should be new. ')
	316	self.failUnless(mesh.representedUserSegment(a,b) == s1 ,
	317	'Segment should not be new. ')
[349]	318
[1401]	319	def testautoSegment(self):
[702]	320	p0 = Vertex (0.0, 0.0)
	321	p1 = Vertex (0.0, 4.0)
	322	p2 = Vertex (4.0,4.0)
	323	p3 = Vertex (4.0,0.0)
[349]	324
[702]	325	s1 = Segment(p0,p1)
[349]	326
[702]	327	m = Mesh(userVertices=[p0, p1, p2, p3], userSegments=[s1] )
[349]	328	m.autoSegment()
	329
	330	#print 'Len', len(m.userSegments)
[702]	331	self.failUnless(len(m.getUserSegments()) == 4 ,
	332	'userSegments is wrong!')
	333
	334	m.autoSegment()
	335	self.failUnless(len(m.getUserSegments()) == 4 ,
	336	'userSegments is wrong!')
	337
[1401]	338	def testautoSegmentII(self):
[702]	339	p1 = Vertex (3.0, 4.0)
	340	p2 = Vertex (3.0,2.0)
	341	p3 = Vertex (3.0,0.0)
	342	p4 = Vertex (6.0, 4.0)
	343	p5 = Vertex (6.0,2.0)
	344	p0 = Vertex (6.0,0.0)
[349]	345
[702]	346
	347	s1 = Segment(p2,p3)
	348	s2 = Segment(p4,p5)
	349
	350	m = Mesh(userVertices=[p0, p1, p2, p3, p4, p5],
	351	userSegments=[s1, s2])
	352
	353	m.autoSegment()
	354
	355	s3 = m.representedAlphaUserSegment(p3,p0)
	356	self.failUnless(not (s3 == None) ,
[349]	357	'userSegments is wrong!')
[702]	358
	359
	360	s6 = m.representedAlphaUserSegment(p1,p4)
	361	self.failUnless(not (s6 == None) ,
	362	'userSegments is wrong!')
	363
	364	# remove a segment, add a point, autosegment
	365	m.alphaUserSegments.remove(s3)
	366	p6 = Vertex (1.0, 2.0)
	367	m.userVertices.append(p6)
[1421]	368
[702]	369	m.autoSegment()
	370
	371	s1_now = m.representedUserSegment(p3,p2)
	372	self.failUnless(s1_now == s1 ,
	373	'userSegments is wrong!')
	374
	375	s2_now = m.representedUserSegment(p5,p4)
	376	self.failUnless(s2_now == s2 ,
	377	'userSegments is wrong!')
	378
	379	s3 = m.representedAlphaUserSegment(p3,p6)
	380	self.failUnless(not (s3 == None) ,
	381	'userSegments is wrong!')
	382
	383	s4 = m.representedAlphaUserSegment(p3,p6)
	384	self.failUnless(not (s4 == None) ,
	385	'userSegments is wrong!')
	386
	387	s5 = m.representedAlphaUserSegment(p4,p6)
	388	self.failUnless(s5 == None ,
	389	'userSegments is wrong!')
	390	#print m
	391
[349]	392	def testRegions(self):
	393	a = Vertex (0.0, 0.0)
	394	b = Vertex (0.0, 2.0)
	395	c = Vertex (2.0,0.0)
	396	d = Vertex (0.0, 4.0)
	397	e = Vertex (2.0, 2.0)
	398	f = Vertex (4.0,0.0)
	399	g = Vertex (0.0,-2.0)
	400
	401	Segment.set_default_tag("")
	402	s1 = Segment(a,b)
	403	s2 = Segment(b,e)
	404	s3 = Segment(e,c)
	405	s4 = Segment(c,a)
	406	s5 = Segment(b,d)
	407	s6 = Segment(e,d)
	408	s7 = Segment(e,f)
	409	s8 = Segment(c,f)
	410	s9 = Segment(g,c)
	411	s10 = Segment(g,a)
	412
	413	r1 = Region(0.1,0.1,tag="22")
	414	r2 = Region(0.1,2.1,tag="11")
	415	r3 = Region(2.1,0.1)
	416
	417	m = Mesh(userVertices=[a,b,c,d,e,f,g], userSegments=[s1,s2,s3,s4,s5,s6,s7,s8,s9,s10], regions=[r1,r2,r3] )
[2346]	418	m.generateMesh("Q", maxArea = 2.1 )
[349]	419	#print m
	420	Triangulation = m.getTriangulation()
	421	#print Triangulation[0].attribute
	422	#print Triangulation[1].attribute
	423	#print Triangulation[2].attribute
	424	#print Triangulation[3].attribute
	425	#print Triangulation[4].attribute
	426
	427	self.failUnless(Triangulation[0].attribute == "" and
	428	Triangulation[1].attribute == "22" and
	429	Triangulation[2].attribute == "" and
	430	Triangulation[3].attribute == "11" and
	431	Triangulation[4].attribute == "22" ,
	432	'region attributes are wrong!')
	433
	434	def test_vertexAttribs(self):
	435	a = Vertex (0.0, 0.0, attributes = [12.0,2.0])
	436	d = Vertex (0.0, 4.0, attributes = [9.0,7.0])
	437	f = Vertex (4.0,0.0, attributes = [14.0,3.0])
	438
	439	Segment.set_default_tag("")
	440	s1 = Segment(a,d)
	441	s2 = Segment(d,f)
	442	s3 = Segment(a,f)
	443
	444	r1 = Region(0.3, 0.3, tag = 88.9)
	445
	446	m = Mesh(userVertices=[a,d,f], userSegments=[s1,s2,s3], regions=[r1])
	447
[2346]	448	m.generateMesh("Q", maxArea = 2.1)
[349]	449
	450	vert = m.getMeshVertices()
	451
	452	self.failUnless(vert[0].attributes == [12.0, 2.0] and
	453	vert[1].attributes == [9.0, 7.0] and
	454	vert[2].attributes == [14.0,3.0] and
	455	vert[3].attributes == [12.232233047033631, 4.4142135623730949] and
	456	vert[4].attributes == [13.0, 2.5] ,
	457	'vertex attributes are wrong!')
	458
	459
	460	def test_vertexAttribs2(self):
	461
	462	a = Vertex (0.0, 0.0)
	463	d = Vertex (0.0, 4.0)
	464	f = Vertex (4.0,0.0)
	465
	466	Segment.set_default_tag("")
	467	s1 = Segment(a,d)
	468	s2 = Segment(d,f)
	469	s3 = Segment(a,f)
	470
	471	r1 = Region(0.3, 0.3, tag = 88.9)
	472
	473	m = Mesh(userVertices=[a,d,f], userSegments=[s1,s2,s3], regions=[r1])
	474
[2346]	475	m.generateMesh("Q", maxArea = 2.1 )
[349]	476
	477	vert = m.getMeshVertices()
	478	self.failUnless(vert[0].attributes == [] and
	479	vert[1].attributes == [] and
	480	vert[2].attributes == [] and
	481	vert[3].attributes == [] and
	482	vert[4].attributes == [],
	483	'vertex attributes are wrong!')
	484
[969]	485	def test_segtag(self):
[349]	486
	487	a = Vertex (0.0, 0.0)
	488	d = Vertex (0.0, 4.0)
	489	f = Vertex (4.0,0.0)
	490
[969]	491	s1 = Segment(a,d,tag = 5)
	492	s2 = Segment(d,f,tag = 7)
	493	s3 = Segment(a,f,tag = 9)
[349]	494
	495	m = Mesh(userVertices=[a,d,f], userSegments=[s1,s2,s3])
	496
[2346]	497	m.generateMesh("Q", maxArea = 2.1 )
[349]	498
[3001]	499	#m.export_mesh_file("from_test_mesh.tsh")
[349]	500	seg = m.getMeshSegments()
[2024]	501	#print "seg",seg
[969]	502	#print "seg[0].tag"
	503	#print seg[0].tag
	504	#print "seg[0].tag"
[2028]	505
[2141]	506	self.failUnless(seg[0].tag == 5 and
[969]	507	seg[1].tag == 7 and
	508	seg[2].tag == 9 and
	509	seg[3].tag == 7 and
[2028]	510	seg[4].tag == 9,
	511	'seg tags are wrong')
	512
[349]	513
[969]	514	def test_segtag2(self):
[349]	515
	516	a = Vertex (0.0, 0.0)
	517	d = Vertex (0.0, 4.0)
	518	f = Vertex (4.0,0.0)
	519	e = Vertex (1.0,1.0)
	520
	521	s1 = Segment(a,d)
	522	s2 = Segment(d,f)
	523	s3 = Segment(a,f)
	524	s4 = Segment(a,e)
	525
	526	m = Mesh(userVertices=[a,d,f,e], userSegments=[s1,s2,s3,s4])
	527
[2346]	528	m.generateMesh("Q", maxArea = 2.1)
[349]	529
	530	seg = m.getMeshSegments()
[969]	531	self.failUnless(seg[0].tag == "exterior" and
	532	seg[1].tag == "exterior" and
	533	seg[2].tag == "exterior" and
	534	seg[3].tag == "" and
	535	seg[4].tag == "exterior",
	536	'2nd seg tags are wrong')
[349]	537
	538	def test_asciiFile(self):
	539
[364]	540	a = Vertex (0.0, 0.0) #, attributes = [1.1])
	541	d = Vertex (0.0, 4.0) #, attributes = [1.2])
	542	f = Vertex (4.0,0.0) #, attributes = [1.3])
	543	e = Vertex (1.0,1.0) #, attributes = [1.4])
[349]	544
	545	s1 = Segment(a,d)
	546	s2 = Segment(d,f)
	547	s3 = Segment(a,f)
	548	s4 = Segment(a,e)
	549
	550	m = Mesh(userVertices=[a,d,f,e], userSegments=[s1,s2,s3,s4])
	551
[2346]	552	m.generateMesh("Q", maxArea = 2.1 )
[349]	553	seg = m.getMeshSegments()
	554
[996]	555	fileName = tempfile.mktemp(".tsh")
[1001]	556	m.export_mesh_file(fileName)
[349]	557	file = open(fileName)
	558	lFile = file.read().split('\n')
	559	file.close()
	560	os.remove(fileName)
	561
	562	#print "@^@^"
	563	#for l in lFile:
	564	# print l,"<"
	565	#print "@^@^"
[364]	566
[721]	567	# no need to check the title again
	568	#self.failUnless(lFile[0] == "5 0 # <vertex #> <x> <y> [attributes] ...Triangulation Vertices..."
	569	# ,'Ascii file is wrong, vertex title')
[364]	570	self.failUnless(lFile[1] == "0 0.0 0.0 " and #1.1 " and
	571	lFile[2] == "1 0.0 4.0 " and #1.2 " and
	572	lFile[3] == "2 4.0 0.0 " and #1.3 " and
	573	lFile[4] == "3 1.0 1.0 " and #1.4 " and
	574	lFile[5] == "4 2.0 2.0 " #1.25 "
[349]	575	,
	576	'Ascii file is wrong, vertex')
[364]	577
[721]	578	#self.failUnless(lFile[6] == "# attribute column titles ...Triangulation Vertex Titles..."
	579	# ,'Ascii file is wrong, attribute column title')
	580	self.failUnless(lFile[8] == "0 3 2 4 -1 2 3 " and
[364]	581	lFile[9] == "1 1 0 3 3 2 -1 " and
	582	lFile[10] == "2 3 4 1 -1 1 0 " and
	583	lFile[11] == "3 2 3 0 1 -1 0 "
	584	,
[349]	585	'Ascii file is wrong, triangle')
	586
[721]	587	self.failUnless( lFile[13] == "0 0 1 exterior" and
[714]	588	lFile[14] == "1 1 4 exterior" and
	589	lFile[15] == "2 2 0 exterior" and
[650]	590	lFile[16] == "3 0 3 " and
[714]	591	lFile[17] == "4 4 2 exterior" ,
[349]	592	'Ascii file is wrong, segment')
	593
[721]	594	# self.failUnless(lFile[18] == '4 0 # <vertex #> <x> <y> [attributes] ...Mesh Vertices...',
	595	# 'Ascii file is wrong, Mesh Vertices Title')
[349]	596
[364]	597	self.failUnless(lFile[19] == '0 0.0 0.0 ' and #1.1 ' and
	598	lFile[20] == '1 0.0 4.0 ' and #1.2 ' and
	599	lFile[21] == '2 4.0 0.0 ' and #1.3 ' and
	600	lFile[22] == '3 1.0 1.0 ' #1.4 '
	601	,
[349]	602	'Ascii file is wrong, Mesh Vertices II')
	603
[721]	604	self.failUnless(lFile[24] == '0 0 1 ' and
[364]	605	lFile[25] == '1 1 2 ' and
	606	lFile[26] == '2 0 2 ' and
[721]	607	lFile[27] == '3 0 3 '
	608	,'Ascii file is wrong, Mesh Segments')
[364]	609
[349]	610
	611	def test_ascii_file(self):
	612
[364]	613	a = Vertex (0.0, 0.0) #, attributes = [1.1])
	614	d = Vertex (0.0, 4.0) #, attributes = [1.2])
	615	f = Vertex (4.0,0.0) #, attributes = [1.3])
	616	e = Vertex (1.0,1.0) #, attributes = [1.4])
[349]	617
	618	s1 = Segment(a,d)
	619	s2 = Segment(d,f)
	620	s3 = Segment(a,f)
	621	s4 = Segment(a,e)
	622
	623	m = Mesh(userVertices=[a,d,f,e], userSegments=[s1,s2,s3,s4])
	624
[2346]	625	m.generateMesh("Q", maxArea = 2.1 )
[349]	626
	627	seg = m.getMeshSegments()
	628
[996]	629	fileName = tempfile.mktemp(".tsh")
[1001]	630	m.export_mesh_file(fileName)
[349]	631	file = open(fileName)
	632	lFile = file.read().split('\n')
	633	file.close()
	634	os.remove(fileName)
	635
[852]	636	#print "@^@^"
	637	#for l in lFile:
	638	# print l,"<"
	639	#print "@^@^"
[721]	640	self.failUnless(lFile[0] == "5 0 # <# of verts> <# of vert attributes>, next lines <vertex #> <x> <y> [attributes] ...Triangulation Vertices..."
[349]	641	,
	642	'Ascii file is wrong, vertex title')
[364]	643	self.failUnless(lFile[1] == "0 0.0 0.0 " and #1.1 " and
	644	lFile[2] == "1 0.0 4.0 " and #1.2 " and
	645	lFile[3] == "2 4.0 0.0 " and #1.3 " and
	646	lFile[4] == "3 1.0 1.0 " and #1.4 " and
	647	lFile[5] == "4 2.0 2.0 " #1.25 "
[349]	648	,
	649	'Ascii file is wrong, vertex')
[364]	650
	651	self.failUnless(lFile[6] == "# attribute column titles ...Triangulation Vertex Titles..."
[349]	652	,
[364]	653	'Ascii file is wrong, attribute column title')
[721]	654	self.failUnless(lFile[7] == "4 # <# of triangles>, next lines <triangle #> [<vertex #>] [<neigbouring triangle #>] [attribute of region] ...Triangulation Triangles..." and
[364]	655	lFile[8] == "0 3 2 4 -1 2 3 " and
	656	lFile[9] == "1 1 0 3 3 2 -1 " and
	657	lFile[10] == "2 3 4 1 -1 1 0 " and
	658	lFile[11] == "3 2 3 0 1 -1 0 "
	659	,
[349]	660	'Ascii file is wrong, triangle')
	661
[969]	662	self.failUnless(lFile[12] == "5 # <# of segments>, next lines <segment #> <vertex #> <vertex #> [boundary tag] ...Triangulation Segments..." and
[714]	663	lFile[13] == "0 0 1 exterior" and
	664	lFile[14] == "1 1 4 exterior" and
	665	lFile[15] == "2 2 0 exterior" and
[650]	666	lFile[16] == "3 0 3 " and
[714]	667	lFile[17] == "4 4 2 exterior" ,
[349]	668	'Ascii file is wrong, segment')
	669
[721]	670	self.failUnless(lFile[18] == '4 0 # <# of verts> <# of vert attributes>, next lines <vertex #> <x> <y> [attributes] ...Mesh Vertices...',
[349]	671	'Ascii file is wrong, Mesh Vertices Title')
	672
[364]	673	self.failUnless(lFile[19] == '0 0.0 0.0 ' and #1.1 ' and
	674	lFile[20] == '1 0.0 4.0 ' and #1.2 ' and
	675	lFile[21] == '2 4.0 0.0 ' and #1.3 ' and
	676	lFile[22] == '3 1.0 1.0 ' #1.4 '
	677	,
[349]	678	'Ascii file is wrong, Mesh Vertices II')
	679
[969]	680	self.failUnless(lFile[23] == '4 # <# of segments>, next lines <segment #> <vertex #> <vertex #> [boundary tag] ...Mesh Segments...' and
[364]	681	lFile[24] == '0 0 1 ' and
	682	lFile[25] == '1 1 2 ' and
	683	lFile[26] == '2 0 2 ' and
	684	lFile[27] == '3 0 3 ' and
[721]	685	lFile[28] == '0 # <# of holes>, next lines <Hole #> <x> <y> ...Mesh Holes...' and
	686	lFile[29] == '0 # <# of regions>, next lines <Region #> <x> <y> <tag>...Mesh Regions...'
[349]	687	,
	688	'Ascii file is wrong, Mesh Segments')
	689
	690
	691	def test_thinoutVertices(self):
	692
	693	v1 = Vertex(-20,-20)
	694	v2 = Vertex(-11,-11)
	695	v3 = Vertex(-10,-10)
	696	v4 = Vertex(-9,-1)
	697	v5 = Vertex(-8,2)
	698	v6 = Vertex(6,3)
	699	v7 = Vertex(12,9)
	700	v8 = Vertex(15,3)
	701	v9 = Vertex(24,3)
	702	m = Mesh(userVertices = [v1,v2,v3,v4,v5,v6,v7,v8,v9])
	703	m.thinoutVertices(10)
	704
	705	self.failUnless(v1 in m.userVertices,
	706	'test_thinoutVertices, test 1 failed')
	707	self.failUnless(v3 in m.userVertices,
	708	'test_thinoutVertices, test 2 failed')
	709	self.failUnless(v4 in m.userVertices,
	710	'test_thinoutVertices, test 3 failed')
	711	self.failUnless(v6 in m.userVertices,
	712	'test_thinoutVertices, test 4 failed')
	713	self.failUnless(v7 in m.userVertices,
	714	'test_thinoutVertices, test 5 failed')
	715	self.failUnless(v9 in m.userVertices,
	716	'test_thinoutVertices, test 6 failed')
	717	self.failUnless(v5 not in m.userVertices,
	718	'test_thinoutVertices, test 7 failed')
	719	self.failUnless(v2 not in m.userVertices,
	720	'test_thinoutVertices, test 8 failed')
	721	self.failUnless(v8 not in m.userVertices,
	722	'test_thinoutVertices, test 9 failed')
	723
	724	def test_same_x_y(self):
	725	v = Point(7,8)
	726	f = Point(7,8)
	727	f.same_x_y(v)
	728
	729	self.failUnless(f.same_x_y(v),
	730	'same_x_y True failed')
	731	e = Point(7,9)
	732	self.failUnless(not f.same_x_y(e),
	733	'same_x_y False failed')
	734
[1023]	735	def test_import_tsh(self):
[349]	736
	737	a_att = [5.0,2.0]
	738	d_att =[4.0,2.0]
	739	f_att = [3.0,2.0]
	740	e_att = [2.0,2.0]
	741	a_xy = [0.0, 0.0]
[364]	742	a = Vertex ( a_xy[0],a_xy[1]) #, attributes =a_att)
	743	d = Vertex (0.0, 4.0) #, attributes =d_att)
	744	f = Vertex (4.0,0.0) #, attributes =f_att)
	745	e = Vertex (1.0,1.0) #, attributes =e_att)
[349]	746
[969]	747	s1 = Segment(a,d, tag = "50")
	748	s2 = Segment(d,f, tag = "40")
	749	s3 = Segment(a,f, tag = "30")
	750	s4 = Segment(a,e, tag = "20")
[349]	751
	752	r1 = Region(0.3, 0.3,tag = "1.3")
[1023]	753	geo = Geo_reference(8.9,8.9,65)
[349]	754	m = Mesh(userVertices=[a,d,f,e],
	755	userSegments=[s1,s2,s3,s4],
[1023]	756	regions=[r1],
	757	geo_reference=geo)
[349]	758
[2346]	759	m.generateMesh("Q", maxArea = 2.1)
[349]	760	fileName = tempfile.mktemp(".tsh")
	761	#print "dgs!!!"
	762	#print "****************** fileName", fileName
[1001]	763	m.export_mesh_file(fileName)
[406]	764	#print "******************"
	765	#print "m", m
	766	#print "******************"
[349]	767	m_returned = importMeshFromFile(fileName)
[406]	768	#print "m_returned",m_returned
	769	#print "******************"
[349]	770	#print "****************** fileName", fileName
	771	os.remove(fileName)
	772	self.failUnless(0 == m.__cmp__(m_returned),
	773	'loading and saving of a mesh failed')
[1023]	774	# do this when .msh supports geo_refs
	775	#self.failUnless(m.geo_reference == m_returned.geo_reference,
	776	# 'loading and saving of a mesh geo refs failed')
[349]	777
[1023]	778	def test_import_mesh(self):
[349]	779
[1023]	780	a_att = [5.0,2.0]
	781	d_att =[4.0,2.0]
	782	f_att = [3.0,2.0]
	783	e_att = [2.0,2.0]
	784	a_xy = [0.0, 0.0]
	785	a = Vertex ( a_xy[0],a_xy[1]) #, attributes =a_att)
	786	d = Vertex (0.0, 4.0) #, attributes =d_att)
	787	f = Vertex (4.0,0.0) #, attributes =f_att)
	788	e = Vertex (1.0,1.0) #, attributes =e_att)
	789
	790	s1 = Segment(a,d, tag = "50")
	791	s2 = Segment(d,f, tag = "40")
	792	s3 = Segment(a,f, tag = "30")
	793	s4 = Segment(a,e, tag = "20")
	794
	795	r1 = Region(0.3, 0.3,tag = "1.3")
[1073]	796	geo = Geo_reference(65,8.9,8.9)
[1023]	797	m = Mesh(userVertices=[a,d,f,e],
	798	userSegments=[s1,s2,s3,s4],
	799	regions=[r1],
	800	geo_reference=geo)
	801
[2346]	802	m.generateMesh("Q", maxArea = 2.1)
[1023]	803	fileName = tempfile.mktemp(".msh")
	804	#print "dgs!!!"
	805	#print "****************** fileName", fileName
	806	m.export_mesh_file(fileName)
	807	#print "******************"
	808	#print "m", m
	809	#print "******************"
	810	m_returned = importMeshFromFile(fileName)
	811	#print "m_returned",m_returned
	812	#print "******************"
	813	#print "****************** fileName", fileName
	814	os.remove(fileName)
[1034]	815	#print "m.geo_reference",m.geo_reference
	816	#print "m_returned.geo_reference,",m_returned.geo_reference
[1023]	817	self.failUnless(0 == m.__cmp__(m_returned),
	818	'loading and saving of a mesh failed')
	819	self.failUnless(m.geo_reference == m_returned.geo_reference,
	820	'loading and saving of a mesh geo refs failed')
	821
[349]	822	def test_normaliseMesh(self):
	823
	824	a_att = [5.0,2.0]
	825	d_att =[4.0,2.0]
	826	f_att = [3.0,2.0]
	827	e_att = [2.0,2.0]
	828	a_xy = [10.0, 10.0]
	829	a = Vertex ( a_xy[0],a_xy[1], attributes =a_att)
	830	d = Vertex (15.0, 10.0, attributes =d_att)
	831	f = Vertex (10.0,20.0, attributes =f_att)
	832	e = Vertex (15.0,20.0, attributes =e_att)
	833
[969]	834	s1 = Segment(a,d, tag = 50)
	835	s2 = Segment(d,e, tag = 40)
	836	s3 = Segment(e,f, tag = 30)
	837	s4 = Segment(f,a, tag = 20)
[349]	838
	839	r1 = Region(0.3, 0.3,tag = 1.3)
	840	m = Mesh(userVertices=[a,d,f,e],
	841	userSegments=[s1,s2,s3,s4],
	842	regions=[r1])
	843	m.normaliseMesh(1,0,1)
	844	[xmin, ymin, xmax, ymax] = m.boxsize()
	845	[attmin, attmax] = m.maxMinVertAtt(0)
	846	self.failUnless(attmin == 0.0 and attmax == 1.0,
	847	'normalise failed')
	848	self.failUnless(xmin == 0.0 and ymin == 0.0 and xmax == 0.5 and ymax == 1.0,
	849	'normalise failed')
	850	m.normaliseMesh(200,-100,5)
	851	[xmin, ymin, xmax, ymax] = m.boxsize()
	852	[attmin, attmax] = m.maxMinVertAtt(0)
	853	self.failUnless(attmin == 0.0 and attmax == 5.0,
	854	'normalise failed')
	855	self.failUnless(xmin == -100.0 and ymin == -100.0 and xmax == 0.0 and ymax == 100.0,
	856	'normalise failed')
[1401]	857
	858	def test_exportASCIIsegmentoutlinefile(self):
[349]	859	a = Vertex (0,0)
	860	b = Vertex (0,3)
	861	c = Vertex (3,3)
	862	d = Vertex (1,2)
	863	e = Vertex (3,1)
	864
[969]	865	s1 = Segment(a,b, tag = "50")
	866	s2 = Segment(b,c, tag = "40")
	867	s3 = Segment(c,a, tag = "30")
[349]	868
	869	r1 = Region(2, 1,tag = "1.3")
	870	h1 = Hole(1,4)
	871	m = Mesh(userVertices=[a,b,c,d,e],
	872	userSegments=[s1,s2,s3],
	873	regions=[r1],
	874	holes = [h1])
	875
[2346]	876	m.generateMesh("Q", maxArea = 2.1)
[349]	877	#print "mesh **************dsg", m
	878
	879	fileName = tempfile.mktemp(".tsh")
	880	m.exportASCIIsegmentoutlinefile(fileName)
	881
	882	m_returned = importMeshFromFile(fileName)
	883
[1001]	884	#print "m_returned ****",m_returned
[349]	885	#print "****************** fileName", fileName
	886	os.remove(fileName)
	887
	888	#Trim mesh, so it should like like m_returned
	889	m.meshVertices = []
	890	m.meshTriangles = []
	891	m.meshSegments = []
	892	m.userVertices=[a,b,c]
[1001]	893	#print "mesh **************dsg", m
[349]	894	#print "(m.__cmp__(m_returned)", m.__cmp__(m_returned)
	895	self.failUnless(0 == m.__cmp__(m),
	896	'test_exportASCIIsegmentoutlinefile:loading and saving of a mesh failed')
[2144]	897	# Having problems with this on linux.
	898	#The ordering of the dictionary values wasn't the same as the windows
	899	#returned value (verts.values())
	900	#self.failUnless(0 == m.__cmp__(m_returned),
	901	# 'test_exportASCIIsegmentoutlinefile:loading and saving of a mesh failed')
[2145]	902
	903	self.failUnless(3 == len(m_returned.userVertices),
	904	'segmentoutlinefile:IO of a mesh failed')
[2144]	905	self.failUnless(len(m.userSegments) == len(m_returned.userSegments),
	906	'segmentoutlinefile:IO of a mesh failed')
	907	for i in range(len(m.userSegments)):
	908	self.failUnless(m.userSegments[i].vertices[0].x ==
	909	m_returned.userSegments[i].vertices[0].x,
	910	'loading and saving of a mesh outline fialed')
	911	self.failUnless(m.userSegments[i].vertices[0].y ==
	912	m_returned.userSegments[i].vertices[0].y,
	913	'loading and saving of a mesh outline fialed')
	914	self.failUnless(m.userSegments[i].vertices[1].x ==
	915	m_returned.userSegments[i].vertices[1].x,
	916	'loading and saving of a mesh outline fialed')
	917	self.failUnless(m.userSegments[i].vertices[1].y ==
	918	m_returned.userSegments[i].vertices[1].y,
	919	'loading and saving of a mesh outline fialed')
	920
[1401]	921
	922	def test_exportASCIIsegmentoutlinefile2(self):
	923	a = Vertex (0,0)
	924	b = Vertex (0,1)
	925	c = Vertex (1,0)
	926	d = Vertex (1,1)
	927	e = Vertex (0.5,0.5)
	928	f = Vertex (0.6,0.6)
	929
	930	s1 = Segment(a,e, tag = "50")
	931	s2 = Segment(b,e, tag = "40")
	932	s3 = Segment(c,e, tag = "30")
	933	s4 = Segment(d,e, tag = "30")
	934
	935	r1 = Region(2, 1,tag = "1.3")
	936	h1 = Hole(1,4)
	937	m = Mesh(userVertices=[a,b,c,d,e],
	938	userSegments=[s1,s2,s3,s4],
	939	regions=[r1],
	940	holes = [h1])
	941
	942	fileName = tempfile.mktemp(".tsh")
	943	m.exportASCIIsegmentoutlinefile(fileName)
	944
	945	m_returned = importMeshFromFile(fileName)
	946	#print "****************** fileName", fileName
	947	os.remove(fileName)
[349]	948
[1401]	949	#Trim mesh, so it should like like m_returned
	950	m.meshVertices = []
	951	m.meshTriangles = []
	952	m.meshSegments = []
	953	m.userVertices=[a,e,d,b,c]
	954	#print "mesh **************dsg", m
	955	#print "(m.__cmp__(m_returned)", m.__cmp__(m_returned)
	956	self.failUnless(0 == m.__cmp__(m),
[2145]	957	'loading and saving of a mesh failed')
[1401]	958
[2145]	959	self.failUnless(5 == len(m_returned.userVertices),
	960	'segmentoutlinefile:IO of a mesh failed')
	961	self.failUnless(len(m.userSegments) == len(m_returned.userSegments),
	962	'segmentoutlinefile:IO of a mesh failed')
	963	for i in range(len(m.userSegments)):
	964	self.failUnless(m.userSegments[i].vertices[0].x ==
	965	m_returned.userSegments[i].vertices[0].x,
	966	'loading and saving of a mesh outline fialed')
	967	self.failUnless(m.userSegments[i].vertices[0].y ==
	968	m_returned.userSegments[i].vertices[0].y,
	969	'loading and saving of a mesh outline fialed')
	970	self.failUnless(m.userSegments[i].vertices[1].x ==
	971	m_returned.userSegments[i].vertices[1].x,
	972	'loading and saving of a mesh outline fialed')
	973	self.failUnless(m.userSegments[i].vertices[1].y ==
	974	m_returned.userSegments[i].vertices[1].y,
	975	'loading and saving of a mesh outline fialed')
	976
	977
[852]	978	def test_loadxy(self):
	979	"""
	980	To test the mesh side of loading xya files.
	981	Not the loading of xya files
	982	"""
	983	import os
	984	import tempfile
	985
	986	fileName = tempfile.mktemp(".xya")
	987	file = open(fileName,"w")
	988	file.write("elevation speed \n\
	989	1.0 0.0 10.0 0.0\n\
	990	0.0 1.0 0.0 10.0\n\
	991	1.0 0.0 10.4 40.0\n")
	992	file.close()
	993	#print fileName
	994	m = importMeshFromFile(fileName)
	995	os.remove(fileName)
	996	self.failUnless(m.userVertices[0].x == 1.0,
	997	'loadxy, test 1 failed')
	998	self.failUnless(m.userVertices[0].y == 0.0,
	999	'loadxy, test 2 failed')
	1000	#self.failUnless(m.userVertices[0].attributes == [10.0,0.0],
	1001	# 'loadxy, test 2.2 failed')
	1002	self.failUnless(m.userVertices[1].x == 0.0,
	1003	'loadxy, test 3 failed')
	1004	self.failUnless(m.userVertices[1].y == 1.0,
	1005	'loadxy, test 4 failed')
	1006	#self.failUnless(m.userVertices[1].attributes == [0.0,10.0],
	1007	# 'loadxy, test 5 failed')
	1008
[1401]	1009	def test_exportPointsFile(self):
[349]	1010	a = Vertex (0,0)
	1011	b = Vertex (0,3)
	1012	c = Vertex (3,3)
	1013	d = Vertex (1,2)
	1014	e = Vertex (3,1)
[3013]	1015	#f = Vertex (3,1)
[349]	1016
[969]	1017	s1 = Segment(a,b, tag = 50)
	1018	s2 = Segment(b,c, tag = 40)
	1019	s3 = Segment(c,a, tag = 30)
[349]	1020
	1021	r1 = Region(2, 1,tag = 1.3)
	1022	h1 = Hole(1,4)
	1023	# Warning mesh can't produce this type of data structure its self
	1024	m = Mesh(userVertices=[a,b,c,d,e],
	1025	userSegments=[s1,s2,s3],
	1026	regions=[r1],
	1027	holes = [h1])
	1028
[1395]	1029	fileName = tempfile.mktemp(".xya")
[2028]	1030	#fileName = 't.xya'
	1031	#os.remove(fileName)
[1401]	1032	m.exportPointsFile(fileName)
[349]	1033	file = open(fileName)
	1034	lFile = file.read().split('\n')
	1035	file.close()
[355]	1036
[349]	1037	os.remove(fileName)
[1401]	1038	self.failUnless(lFile[0] == "" and
	1039	lFile[1] == "0,0" and
	1040	lFile[2] == "0,3" and
[2028]	1041	lFile[3] == "3,3"
	1042	,
	1043	'exported Ascii xya file is wrong')
	1044	self.failUnless(lFile[4] == "1,2" and
[1401]	1045	lFile[5] == "3,1"
[349]	1046	,
	1047	'exported Ascii xya file is wrong')
	1048
[2346]	1049	m.generateMesh("Q", maxArea = 2.1)
[1401]	1050	fileName = tempfile.mktemp(".xya")
[3001]	1051	#fileName = 't.xya'
	1052	#m.export_mesh_file('m.tsh')
[1401]	1053	m.exportPointsFile(fileName)
[349]	1054	file = open(fileName)
	1055	lFile = file.read().split('\n')
	1056	file.close()
[3001]	1057	os.remove(fileName)
[2030]	1058
[2141]	1059	self.failUnless(lFile[0] == "" and
[1401]	1060	lFile[1] == "0.0,0.0" and
	1061	lFile[2] == "0.0,3.0" and
	1062	lFile[3] == "3.0,3.0" and
[3013]	1063	lFile[4] == "1.0,2.0"
[2030]	1064	,
	1065	'exported Ascii xya file is wrong')
[1401]	1066
	1067	def test_exportPointsFilefile2(self):
	1068	m = Mesh()
[349]	1069
[1401]	1070	fileName = tempfile.mktemp(".xya")
	1071	m.exportPointsFile(fileName)
	1072	file = open(fileName)
	1073	lFile = file.read().split('\n')
	1074	file.close()
	1075
	1076	os.remove(fileName)
	1077	#print "************* test_mesh exportPointsFilefile"
	1078	#print "lFile",lFile
	1079	#print "************* test_mesh exportPointsFilefile"
	1080	self.failUnless(lFile[0] == ""
	1081	,
	1082	'exported Ascii xya file is wrong')
	1083
[349]	1084	def test_strings2ints(self):
	1085	list = ["sea","river inlet","","sea","","moat"]
	1086	preset = ["moat", "internal boundary"]
	1087	[intlist, converter] = segment_strings2ints(list,preset )
	1088	self.failUnless(intlist == [2,3 ,0 ,2 ,0 ,0 ]
	1089	,
	1090	'test_strings2ints produces bad intlist')
	1091	self.failUnless(converter == ['moat', 'internal boundary',
	1092	'sea', 'river inlet']
	1093	,
	1094	'test_strings2ints produces bad converter')
	1095
	1096	def test_ints2strings(self):
	1097	list = ["internal boundary","sea","river inlet",
	1098	"","sea","","moat","internal boundary"]
	1099	outlist = ['internal boundary', 'sea', 'river inlet', 'moat',
	1100	'sea', 'moat', 'moat', 'internal boundary']
	1101	preset = ["moat", "internal boundary"]
	1102	[intlist, converter] = segment_strings2ints(list,preset )
	1103	newlist = segment_ints2strings(intlist, converter)
	1104	self.failUnless(outlist == newlist
	1105	,
	1106	'test_strings2ints produces bad intlist')
	1107	self.failUnless(converter == ['moat', 'internal boundary',
	1108	'sea', 'river inlet']
	1109	,
	1110	'test_strings2ints produces bad converter')
	1111
	1112	def test_ints2strings2(self):
	1113	list = ["","",""]
	1114	preset = ["moat", "internal boundary"]
	1115	[intlist, converter] = segment_strings2ints(list,preset )
	1116	newlist = segment_ints2strings(intlist, converter)
	1117	outlist = ['moat', 'moat', 'moat']
	1118	self.failUnless(outlist == newlist
	1119	,
	1120	'test_strings2ints produces bad intlist')
	1121	self.failUnless(converter == ['moat', 'internal boundary']
	1122	,
	1123	'test_strings2ints produces bad converter')
	1124
	1125
	1126	def test_removeDuplicatedVertices(self):
	1127	a = Vertex (0,0)
	1128	a.index = 0
	1129	b = Vertex (0,3)
	1130	b.index = 1
	1131	c = Vertex (3,3)
	1132	c.index = 2
	1133	d = Vertex (1,1)
	1134	d.index = 3
	1135	e = Vertex (3,1)
	1136	e.index = 4
	1137	f = Vertex (1,1)
	1138	f.index = 5
	1139	g = Vertex (1,1)
	1140	g.index = 6
	1141	inputVerts_noDups = [a,b,c,d,e]
	1142
	1143	m = Mesh(userVertices=[a,b,c,d,e,f,g])
	1144	counter = m.removeDuplicatedUserVertices()
	1145	UserVerts = m.getUserVertices()
	1146
	1147
	1148	self.failUnless(UserVerts == inputVerts_noDups,
	1149	'duplicate verts not removed')
	1150	#for userVert, inputVert in map(None, UserVerts, inputVerts_noDups):
	1151	# self.failUnless(userVert.x == inputVert.x,
	1152	# 'x duplicate verts not removed')
	1153	# self.failUnless(userVert.y == inputVert.y,
	1154	# 'y duplicate verts not removed')
[406]	1155
[1401]	1156
[407]	1157	def test_ungenerateFileLoading(self):
[349]	1158
[406]	1159	fileName = tempfile.mktemp(".txt")
	1160	file = open(fileName,"w")
	1161	file.write(" 1 ?? ??\n\
	1162	0.0 0.0\n\
	1163	1.0 0.0\n\
	1164	1.0 1.0\n\
	1165	0.0 1.0\n\
	1166	0.0 0.0\n\
	1167	END\n\
	1168	2 ?? ??\n\
	1169	10.0 10.0\n\
	1170	10.0 20.0\n\
	1171	20.0 20.0\n\
	1172	10.0 10.0\n\
	1173	END\n\
	1174	END\n")
	1175	file.close()
	1176
	1177
	1178	a = Vertex (0.0, 0.0) #, attributes = [1.1])
	1179	b = Vertex (0.0, 40.0) #, attributes = [1.2])
	1180	c = Vertex (40.0,40.0) #, attributes = [1.3])
	1181	d = Vertex (40.0,0.0) #, attributes = [1.4])
	1182
	1183	s1 = Segment(a,b)
	1184	s2 = Segment(b,c)
	1185	s3 = Segment(c,d)
	1186	s4 = Segment(d,a)
	1187
	1188	m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
	1189	dict = importUngenerateFile(fileName)
[3100]	1190	#os.remove(fileName)
[407]	1191
	1192	tag = "DSG"
	1193	Segment.set_default_tag(tag)
[406]	1194	m.addVertsSegs(dict)
[407]	1195
	1196	# have to reset this , since it's a class attribute
	1197	Segment.set_default_tag("")
[406]	1198
	1199	self.failUnless(len(m.userSegments) ==11,
[407]	1200	'Wrong segment list length.')
[406]	1201	self.failUnless(len(m.userVertices) == 11,
[407]	1202	'Wrong vertex list length.')
[406]	1203	self.failUnless(m.userSegments[10].vertices[0] == m.userVertices[10],
[407]	1204	'bad vertex on segment.')
[406]	1205	self.failUnless(m.userSegments[10].vertices[1] == m.userVertices[8],
[407]	1206	'Bad segment.')
[969]	1207	self.failUnless(m.userSegments[10].tag == tag,
[407]	1208	'wrong tag.')
[3100]	1209
	1210	## let's test the method
	1211	a = Vertex (0.0, 0.0) #, attributes = [1.1])
	1212	b = Vertex (0.0, 40.0) #, attributes = [1.2])
	1213	c = Vertex (40.0,40.0) #, attributes = [1.3])
	1214	d = Vertex (40.0,0.0) #, attributes = [1.4])
	1215
	1216	s1 = Segment(a,b)
	1217	s2 = Segment(b,c)
	1218	s3 = Segment(c,d)
	1219	s4 = Segment(d,a)
	1220
	1221	m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
	1222
	1223	tag = "DSG"
	1224	initial_tag = "PIG"
	1225	Segment.set_default_tag(initial_tag)
	1226	m.import_ungenerate_file(fileName, tag=tag)
	1227
	1228	os.remove(fileName)
	1229
	1230	self.failUnless(Segment.get_default_tag() == initial_tag,
	1231	'Wrong segment list length.')
	1232
	1233
	1234	# have to reset this , since it's a class attribute
	1235	Segment.set_default_tag("")
	1236
	1237	self.failUnless(len(m.userSegments) ==11,
	1238	'Wrong segment list length.')
	1239	self.failUnless(len(m.userVertices) == 11,
	1240	'Wrong vertex list length.')
	1241	self.failUnless(m.userSegments[10].vertices[0] == m.userVertices[10],
	1242	'bad vertex on segment.')
	1243	self.failUnless(m.userSegments[10].vertices[1] == m.userVertices[8],
	1244	'Bad segment.')
	1245	self.failUnless(m.userSegments[10].tag == tag,
	1246	'wrong tag.')
	1247
[431]	1248	def test_ungenerateFileLoadingII(self):
[406]	1249
[431]	1250	fileName = tempfile.mktemp(".txt")
	1251	file = open(fileName,"w")
	1252	file.write(" 1 ?? ??\n\
	1253	0.0 0.0\n\
	1254	1.0 0.0\n\
	1255	1.0 1.0\n\
	1256	0.0 1.0\n\
	1257	0.0 0.0\n\
	1258	END\n\
	1259	2 ?? ??\n\
	1260	10.0 10.0\n\
	1261	10.0 20.0\n\
	1262	20.0 20.0\n\
	1263	END\n\
	1264	END\n")
	1265	file.close()
	1266
	1267
	1268	a = Vertex (0.0, 0.0) #, attributes = [1.1])
	1269	b = Vertex (0.0, 40.0) #, attributes = [1.2])
	1270	c = Vertex (40.0,40.0) #, attributes = [1.3])
	1271	d = Vertex (40.0,0.0) #, attributes = [1.4])
	1272
	1273	s1 = Segment(a,b)
	1274	s2 = Segment(b,c)
	1275	s3 = Segment(c,d)
	1276	s4 = Segment(d,a)
	1277
	1278	m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
	1279	dict = importUngenerateFile(fileName)
[3100]	1280	#os.remove(fileName)
[431]	1281
	1282	tag = "DSG"
	1283	Segment.set_default_tag(tag)
	1284	m.addVertsSegs(dict)
	1285
	1286	self.failUnless(len(m.userSegments) ==10,
	1287	'Wrong segment list length.')
	1288	self.failUnless(len(m.userVertices) == 11,
	1289	'Wrong vertex list length.')
[3100]	1290
	1291	# Test the method
	1292	a = Vertex (0.0, 0.0) #, attributes = [1.1])
	1293	b = Vertex (0.0, 40.0) #, attributes = [1.2])
	1294	c = Vertex (40.0,40.0) #, attributes = [1.3])
	1295	d = Vertex (40.0,0.0) #, attributes = [1.4])
	1296
	1297	s1 = Segment(a,b)
	1298	s2 = Segment(b,c)
	1299	s3 = Segment(c,d)
	1300	s4 = Segment(d,a)
	1301
	1302	m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
	1303	tag = "DSG"
	1304	initial_tag = "PIG"
	1305	Segment.set_default_tag(initial_tag)
	1306	m.import_ungenerate_file(fileName, tag=tag)
	1307
	1308	os.remove(fileName)
	1309
	1310	self.failUnless(Segment.get_default_tag() == initial_tag,
	1311	'Wrong segment list length.')
[1074]	1312
[3100]	1313
	1314	self.failUnless(len(m.userSegments) ==10,
	1315	'Wrong segment list length.')
	1316	self.failUnless(len(m.userVertices) == 11,
	1317	'Wrong vertex list length.')
	1318
	1319	# have to reset this , since it's a class attribute
	1320	Segment.set_default_tag("")
	1321
[1074]	1322	def test_addVertsSegs(self):
	1323	m = Mesh()
	1324	Segment.set_default_tag("food")
	1325	dict = {}
	1326	dict['points'] = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
	1327	dict['segments'] = [[0, 1], [1, 2]]
	1328	dict['segment_tags'] = ['','do-op']
	1329	m.addVertsSegs(dict)
	1330	# have to reset this , since it's a class attribute
	1331	Segment.set_default_tag("")
[935]	1332
[1074]	1333
	1334	self.failUnless(len(m.userSegments) ==2,
	1335	'Wrong segment list length.')
	1336	self.failUnless(len(m.userVertices) == 3,
	1337	'Wrong vertex list length.')
	1338	self.failUnless(m.userSegments[0].tag =='food',
	1339	'Wrong segment tag length.')
	1340	self.failUnless(m.userSegments[1].tag =='do-op',
	1341	'Wrong segment tag.')
	1342
[2200]	1343	def test_addVertsSegs2(self):
	1344	geo = Geo_reference(56,5,10)
	1345	m = Mesh(geo_reference=geo)
	1346	dict = {}
	1347	dict['points'] = [[2.0, 1.0], [3.0, 1.0], [2.0, 2.0]]
	1348	dict['segments'] = [[0, 1], [1, 2], [2,0]]
	1349	dict['segment_tags'] = ['','do-op','']
	1350	m.addVertsSegs(dict)
	1351
[935]	1352	def test_exportASCIImeshfile(self):
	1353
[1001]	1354	#a_att = [5,2]
	1355	#d_att =[4,2]
	1356	#f_att = [3,2]
	1357	#e_att = [2,2]
[935]	1358	a_xy = [0.0, 0.0]
[1001]	1359	a = Vertex ( a_xy[0],a_xy[1]) #, attributes =a_att)
	1360	d = Vertex (0.0, 4.0) #, attributes =d_att)
	1361	f = Vertex (4.0,0.0) #, attributes =f_att)
	1362	e = Vertex (1.0,1.0) #, attributes =e_att)
[935]	1363
[969]	1364	s1 = Segment(a,d, tag = "50")
	1365	s2 = Segment(d,f, tag = "40")
	1366	s3 = Segment(a,f, tag = "30")
	1367	s4 = Segment(a,e, tag = "20")
[935]	1368
	1369	r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 36)
	1370
	1371
	1372	h1 = Hole(0.2,0.6)
[431]	1373
[935]	1374	m = Mesh(userVertices=[a,d,f,e],
	1375	userSegments=[s1,s2,s3,s4],
	1376	regions=[r1],
	1377	holes=[h1])
	1378
	1379	seg = m.getUserSegments()
	1380	points = m.getUserVertices()
	1381	holes = m.getHoles()
	1382	regions = m.getRegions()
[1001]	1383	fileName = tempfile.mktemp(".tsh")
	1384	m.export_mesh_file(fileName)
[935]	1385	#print "***************************fileName", fileName
[1001]	1386	new_m = importMeshFromFile(fileName)
[935]	1387	os.remove(fileName)
[1001]	1388
[935]	1389
[1001]	1390	#print '@@@@@****'
	1391	#print "new_m",new_m
	1392	#print '@@@@@****'
	1393	#print "m",m
	1394	#print '@@@@@****'
	1395
	1396	self.failUnless( new_m == m,
	1397	'loadASCIITestCase failed. test new 1')
	1398
[968]	1399	def test_Mesh2MeshList(self):
	1400
	1401	a_att = [5,2]
	1402	d_att =[4,2]
	1403	f_att = [3,2]
	1404	e_att = [2,2]
	1405	a_xy = [0.0, 0.0]
	1406	a = Vertex ( a_xy[0],a_xy[1]) #, attributes =a_att)
	1407	d = Vertex (0.0, 4.0) #, attributes =d_att)
	1408	f = Vertex (4.0,0.0) #, attributes =f_att)
	1409	e = Vertex (1.0,1.0) #, attributes =e_att)
	1410
[969]	1411	s1 = Segment(a,d, tag = "50")
	1412	s2 = Segment(d,f, tag = "40")
	1413	s3 = Segment(a,f, tag = "30")
	1414	s4 = Segment(a,e, tag = "20")
[968]	1415
	1416	r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
	1417	m = Mesh(userVertices=[a,d,f,e],
	1418	userSegments=[s1,s2,s3,s4],
	1419	regions=[r1])
	1420
[2346]	1421	m.generateMesh("Qa2.1")
[968]	1422
	1423	seg = m.getMeshSegments()
	1424	points = m.getMeshVertices()
	1425	dict = m.Mesh2MeshList()
[1001]	1426	#print "dict",dict
[968]	1427	# test not finished...
	1428
	1429	def test_Mesh2IOTriangulationDict(self):
	1430
	1431	a_att = [5,2]
	1432	d_att =[4,2]
	1433	f_att = [3,2]
	1434	e_att = [2,2]
	1435	a_xy = [0.0, 0.0]
	1436	a = Vertex ( a_xy[0],a_xy[1] , attributes =a_att)
	1437	d = Vertex (0.0, 4.0 , attributes =d_att)
	1438	f = Vertex (4.0,0.0 , attributes =f_att)
	1439	e = Vertex (1.0,1.0 , attributes =e_att)
	1440
[969]	1441	s1 = Segment(a,d, tag = "50")
	1442	s2 = Segment(d,f, tag = "40")
	1443	s3 = Segment(a,f, tag = "30")
	1444	s4 = Segment(a,e, tag = "20")
[968]	1445
	1446	r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
	1447	m = Mesh(userVertices=[a,d,f,e],
	1448	userSegments=[s1,s2,s3,s4],
	1449	regions=[r1])
	1450	titles = ['ele','friction']
	1451	m.attributeTitles = titles
[2346]	1452	m.generateMesh("Qa2.1")
[968]	1453
	1454	seg = m.getMeshSegments()
	1455	verts = m.getMeshVertices()
	1456	dict = m.Mesh2IOTriangulationDict()
	1457	#print "dict",dict
[935]	1458
[968]	1459	self.failUnless( dict['vertex_attribute_titles'] == titles,
	1460	'test_Mesh2IOTriangulationDict failed. test 1')
	1461	answer = [a_xy,[0.0, 4.0],[4.0,0.0], [1.0,1.0], [2.0,2.0]]
	1462	#print "answer",answer
	1463	#print "dict['vertices']",dict['vertices']
	1464
	1465	self.failUnless( dict['vertices'] == answer,
	1466	'test_Mesh2IOTriangulationDict failed. test 2')
	1467
	1468
	1469	for pimport,pactual,pimpatt in map(None,dict['vertices'],
	1470	verts,dict['vertex_attributes']):
	1471	#assert all_close( pimport, (pactual.x,pactual.y))
	1472	self.failUnless( pimport == [pactual.x,pactual.y],
	1473	'test_Mesh2IOTriangulationDict failed. test 2.1')
	1474	self.failUnless( pimpatt == pactual.attributes,
	1475	'test_Mesh2IOTriangulationDict failed. test 2.2')
	1476	self.failUnless( dict['segments'][0] == [0,1],
	1477	'test_Mesh2IOTriangulationDict failed. test 3')
[969]	1478	for segimp,segactual in map(None,dict['segment_tags'],seg):
	1479	self.failUnless( segimp == segactual.tag,
[968]	1480	'test_Mesh2IOTriangulationDict failed. test 4')
	1481	#print " dict['triangles'][0]", dict['triangles'][0]
	1482	self.failUnless( dict['triangles'][0] == [3,2,4],
	1483	'test_Mesh2IOTriangulationDict failed. test 5')
	1484	self.failUnless( dict['triangle_neighbors'][0] == [-1,2,3],
	1485	'test_Mesh2IOTriangulationDict failed. test 6')
[1183]	1486	self.failUnless( dict['triangle_tags'][0] == "1.3",
[968]	1487	'test_Mesh2IOTriangulationDict failed. test 7')
	1488
	1489
	1490	def test_Mesh2IODict(self):
	1491
	1492	a_att = [5,2]
	1493	d_att =[4,2]
	1494	f_att = [3,2]
	1495	e_att = [2,2]
	1496	a_xy = [0.0, 0.0]
	1497	a = Vertex ( a_xy[0],a_xy[1] , attributes =a_att)
	1498	d = Vertex (0.0, 4.0 , attributes =d_att)
	1499	f = Vertex (4.0,0.0 , attributes =f_att)
	1500	e = Vertex (1.0,1.0 , attributes =e_att)
	1501
[969]	1502	s1 = Segment(a,d, tag = "50")
	1503	s2 = Segment(d,f, tag = "40")
	1504	s3 = Segment(a,f, tag = "30")
	1505	s4 = Segment(a,e, tag = "20")
[968]	1506
	1507	r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
	1508	m = Mesh(userVertices=[a,d,f,e],
	1509	userSegments=[s1,s2,s3,s4],
	1510	regions=[r1])
	1511	titles = ['ele','friction']
	1512	m.attributeTitles = titles
[2346]	1513	m.generateMesh("Qa2.1")
[968]	1514
	1515	seg = m.getMeshSegments()
	1516	verts = m.getMeshVertices()
	1517	dict = m.Mesh2IODict()
	1518	#print "dict",dict
	1519
	1520	self.failUnless( dict['vertex_attribute_titles'] == titles,
	1521	'test_Mesh2IOTriangulationDict failed. test 1')
	1522	answer = [a_xy,[0.0, 4.0],[4.0,0.0], [1.0,1.0], [2.0,2.0]]
	1523	#print "answer",answer
	1524	#print "dict['vertices']",dict['vertices']
	1525
	1526	self.failUnless( dict['vertices'] == answer,
	1527	'test_Mesh2IOTriangulationDict failed. test 2')
	1528
	1529
	1530	for pimport,pactual,pimpatt in map(None,dict['vertices'],
	1531	verts,dict['vertex_attributes']):
	1532	#assert all_close( pimport, (pactual.x,pactual.y))
	1533	self.failUnless( pimport == [pactual.x,pactual.y],
	1534	'test_Mesh2IODict failed. test 2.1')
	1535	self.failUnless( pimpatt == pactual.attributes,
	1536	'test_Mesh2IODict failed. test 2.2')
	1537	self.failUnless( dict['segments'][0] == [0,1],
	1538	'test_Mesh2IODict failed. test 3')
[969]	1539	for segimp,segactual in map(None,dict['segment_tags'],seg):
	1540	self.failUnless( segimp == segactual.tag,
[968]	1541	'test_Mesh2IODict failed. test 4')
	1542	#print " dict['triangles'][0]", dict['triangles'][0]
	1543	self.failUnless( dict['triangles'][0] == [3,2,4],
	1544	'test_Mesh2IODict failed. test 5')
	1545	self.failUnless( dict['triangle_neighbors'][0] == [-1,2,3],
	1546	'test_Mesh2IODict failed. test 6')
[1183]	1547	self.failUnless( dict['triangle_tags'][0] == "1.3",
[968]	1548	'test_Mesh2IODict failed. test 7')
	1549
	1550	seg = m.getUserSegments()
	1551	points = m.getUserVertices()
	1552	holes = m.getHoles()
	1553	regions = m.getRegions()
	1554
	1555	for pimport,pactual,pimpatt in map(None,dict['points'],points,dict['point_attributes']):
	1556	self.failUnless( pimport == [pactual.x,pactual.y],
	1557	'test_Mesh2IODict failed. test 1')
	1558	self.failUnless( pimpatt == pactual.attributes,
	1559	'test_Mesh2IODict failed. test 1.1')
	1560	self.failUnless( dict['outline_segments'][0] == [0,1],
	1561	'test_Mesh2IODict failed. test 3')
[969]	1562	for segimp,segactual in map(None,dict['outline_segment_tags'],seg):
	1563	self.failUnless( segimp == segactual.tag,
[968]	1564	'test_Mesh2IODict failed. test 4')
	1565	for holeimp,holeactual in map(None,dict['holes'],holes):
	1566	self.failUnless( holeimp == [holeactual.x,holeactual.y],
	1567	'test_Mesh2IODict failed. test 5')
	1568
[969]	1569	for regimp,regactual,regattimp, regmaxarea in map(None,dict['regions'],regions, dict['region_tags'], dict['region_max_areas']):
[968]	1570	self.failUnless( regimp == [regactual.x,regactual.y],
	1571	'loadASCIITestCase failed. test 6')
	1572	self.failUnless( regattimp == regactual.getTag(),
	1573	'loadASCIITestCase failed. test 7')
	1574	self.failUnless( regmaxarea == regactual.getMaxArea(),
	1575	'loadASCIITestCase failed. test 7')
	1576
	1577
	1578
	1579	def test_Mesh2IOOutlineDict(self):
	1580
	1581	a_att = [5,2]
	1582	d_att =[4,2]
	1583	f_att = [3,2]
	1584	e_att = [2,2]
	1585	a_xy = [0.0, 0.0]
	1586	a = Vertex ( a_xy[0],a_xy[1] , attributes =a_att)
	1587	d = Vertex (0.0, 4.0 , attributes =d_att)
	1588	f = Vertex (4.0,0.0 , attributes =f_att)
	1589	e = Vertex (1.0,1.0 , attributes =e_att)
	1590
[969]	1591	s1 = Segment(a,d, tag = "50")
	1592	s2 = Segment(d,f, tag = "40")
	1593	s3 = Segment(a,f, tag = "30")
	1594	s4 = Segment(a,e, tag = "20")
[968]	1595
	1596	r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
	1597	m = Mesh(userVertices=[a,d,f,e],
	1598	userSegments=[s1,s2,s3,s4],
	1599	regions=[r1])
	1600	titles = ['ele','friction']
	1601	m.attributeTitles = titles
[2346]	1602	m.generateMesh("Qa2.1")
[968]	1603
	1604	seg = m.getMeshSegments()
	1605	verts = m.getMeshVertices()
	1606	dict = m.Mesh2IOOutlineDict()
	1607
	1608	seg = m.getUserSegments()
	1609	points = m.getUserVertices()
	1610	holes = m.getHoles()
	1611	regions = m.getRegions()
	1612
	1613	for pimport,pactual,pimpatt in map(None,dict['points'],points,dict['point_attributes']):
	1614	self.failUnless( pimport == [pactual.x,pactual.y],
	1615	'loadASCIITestCase failed. test 1')
	1616	self.failUnless( pimpatt == pactual.attributes,
	1617	'loadASCIITestCase failed. test 1.1')
	1618	self.failUnless( dict['outline_segments'][0] == [0,1],
	1619	'loadASCIITestCase failed. test 3')
[969]	1620	for segimp,segactual in map(None,dict['outline_segment_tags'],seg):
	1621	self.failUnless( segimp == segactual.tag,
[968]	1622	'loadASCIITestCase failed. test 4')
	1623	for holeimp,holeactual in map(None,dict['holes'],holes):
	1624	self.failUnless( holeimp == [holeactual.x,holeactual.y],
	1625	'loadASCIITestCase failed. test 5')
	1626	#for regimp,regactual in map(None,dict['regions'],regions):
	1627	# self.failUnless( [regimp[0],regimp[1]]==[regactual.x,regactual.y],
	1628	# 'loadASCIITestCase failed. test 6')
	1629	# self.failUnless( regimp[2] == regactual.getTag(),
	1630	# 'loadASCIITestCase failed. test 7')
	1631	#self.failUnless( regimp[3] == regactual.getMaxArea(),
	1632	# 'loadASCIITestCase failed. test 7')
	1633
	1634
[969]	1635	for regimp,regactual,regattimp, regmaxarea in map(None,dict['regions'],regions, dict['region_tags'], dict['region_max_areas']):
[968]	1636	self.failUnless( regimp == [regactual.x,regactual.y],
	1637	'loadASCIITestCase failed. test 6')
	1638	self.failUnless( regattimp == regactual.getTag(),
	1639	'loadASCIITestCase failed. test 7')
	1640	self.failUnless( regmaxarea == regactual.getMaxArea(),
	1641	'loadASCIITestCase failed. test 7')
[1361]	1642
	1643
[2200]	1644	#___________beginning of Peters tests
[1361]	1645
	1646	def test_set_stuff(self):
	1647	"""
	1648	Documentation
	1649	"""
	1650	#making a test mesh
	1651	p0=[0.,2.]
	1652	p1=[1.,2.]
	1653	p2=[0.,1.]
	1654	p3=[1.,1.]
	1655	p4=[0.,0.]
	1656	p5=[2.,0.]
	1657	p6=[-1.,1.]
	1658	point_list = [p0,p1,p2,p3,p4,p5,p6]
	1659
	1660	a0=[0]
	1661	a1=[0]
	1662	a2=[100]
	1663	a3=[0]
	1664	a4=[0]
	1665	a5=[0]
	1666	a6=[0]
	1667	attribute=[a0,a1,a2,a3,a4,a5,a6]
	1668
	1669	t0=[0,3,1]
	1670	t1=[0,2,3]
	1671	t2=[2,4,3]
	1672	t3=[4,5,3]
	1673	t4=[1,3,5]
	1674	t5=[2,6,4]
	1675
	1676	n0=[4,-1,2]
	1677	n1=[2,0,-1]
	1678	n2=[3,1,5]
	1679	n3=[4,2,-1]
	1680	n4=[3,-1,0]
	1681	n5=[-1,2,-1]
	1682
	1683	tri_list = [t0,t1,t2,t3,t4,t5]
	1684	n_list = [n0,n1,n2,n3,n4,n5]
	1685	for i in range(6):
	1686	for j in (0,1,2):
	1687	a=attribute[tri_list[i][j]]
	1688	tri_list[i][j]=point_list[tri_list[i][j]]
	1689	tri_list[i][j]=Vertex(tri_list[i][j][0]\
	1690	,tri_list[i][j][1],a)
	1691	neighbours=n_list[i]
	1692	tri_list[i]=Triangle(tri_list[i][0],\
	1693	tri_list[i][1],tri_list[i][2]\
	1694	,neighbors=neighbours)
	1695
	1696	#testing selectAll
	1697	mesh = Mesh()
	1698	mesh.attributeTitles=['attrib']
	1699
	1700	mesh.meshTriangles=tri_list
	1701
	1702	mesh.selectAllTriangles()
	1703	A=mesh.sets[mesh.setID['All']]
	1704	assert list_comp(tri_list,A)
	1705
	1706	#testing threshold
	1707	mesh = Mesh()
	1708	mesh.attributeTitles=['attrib']
	1709
	1710	mesh.meshTriangles=tri_list
	1711	mesh.selectAllTriangles()
	1712	mesh.threshold('All',min=30,max=35,attribute_name = 'attrib')
	1713	A = [tri_list[1],tri_list[2],tri_list[5]]
	1714	B = mesh.sets[mesh.setID['All']]
	1715	assert list_comp(A,B)
	1716
	1717
	1718	A = [tri_list[3],tri_list[2],tri_list[5]]
	1719	assert not list_comp(A,B)
	1720
	1721	#testing
	1722
	1723	def test_Discretised_Tuple_Set_rounding(self):
	1724	#This is the hardest bit of DST
	1725
	1726	tol = 0.1
	1727	a=Discretised_Tuple_Set(p_rel=1,t_rel= tol)
	1728	m = 0.541
	1729	m_up = 0.6
	1730	m_down = 0.5
	1731	assert m_up == a.round_up_rel(m)
	1732	assert m_down == a.round_down_rel(m)
	1733
	1734	tol = 0.1
	1735	a=Discretised_Tuple_Set(p_rel=1,t_rel = tol)
	1736	m = 0.539
	1737	m_up = 0.5
	1738	m_down = 0.5
	1739	assert m_up == a.round_up_rel(m)
	1740	assert m_down == a.round_down_rel(m)
	1741
	1742	tol = 0.5
	1743	a=Discretised_Tuple_Set(p_rel=1,t_rel = tol)
	1744
	1745
	1746	m = 0.6
	1747	m_up = 0.7
	1748	m_down = 0.5
	1749	assert m_up == a.round_up_rel(m)
	1750	assert m_down == a.round_down_rel(m)
	1751
	1752	m = 0.599
	1753	m_up = 0.6
	1754	m_down = 0.5
	1755	assert m_up == a.round_up_rel(m)
	1756	assert m_down == a.round_down_rel(m)
	1757
	1758	def test_Discretised_Tuple_Set_get(self):
[3097]	1759
[1361]	1760	tol = 0.25
	1761	a=Discretised_Tuple_Set(p_rel=1,t_rel = tol)
	1762	b = (1.1,1.1)
	1763	a.append(b)
	1764	list = [(1.2,1.),(1.,1.),(1.,1.2),(1.2,1.2)]
	1765	for key in list:
	1766	assert a[key][0]==b
	1767	assert len(a[key])==1
	1768
	1769	c = (2.1,1.)
	1770	a.append(c)
	1771	assert a[(2.,1.)][0]==c
	1772	assert a[(2.2,1.)][0]==c
	1773
	1774	def test_mapped_Discretised_Tuple_Set(self):
	1775
	1776	def map(sequence):
	1777	return [len(sequence)]
	1778
	1779	tol = 0.5
	1780	a=Mapped_Discretised_Tuple_Set(map,p_rel=1,t_rel = tol)
	1781	b = range(20)
	1782	a.append(b)
	1783	assert b in a[range(17)]
	1784	assert b in a[range(22)]
	1785
	1786	tol = 0.01
	1787	a=Mapped_Discretised_Tuple_Set(map,p_rel=1,t_rel = tol)
	1788	b = range(20)
	1789	a.append(b)
	1790	assert b in a[range(20)]
	1791	assert b in a[range(19)]
	1792	assert not range(17) in a
	1793
[2200]	1794	#___________end of Peters tests
[1361]	1795
[2261]	1796	def test_add_region_from_polygon(self):
[2200]	1797	m=Mesh()
[2276]	1798	region = m.add_region_from_polygon([[0,0],[1,0],[0,1]],
	1799	max_triangle_area = 88)
[2200]	1800	self.failUnless(len(m.regions)==1,
	1801	'FAILED!')
[2276]	1802	self.failUnless(region.getMaxArea()==88,
	1803	'FAILED!')
[2200]	1804	self.failUnless(len(m.getUserSegments())==3,
	1805	'FAILED!')
	1806	self.failUnless(len(m.userVertices)==3,
	1807	'FAILED!')
	1808
[2261]	1809	def test_add_region_from_polygon2(self):
[2200]	1810	m=Mesh()
[2261]	1811	m.add_region_from_polygon([[0,0],[1,0],[1,1],[0,1]],
[2276]	1812	{'tagin':[0,1],'bom':[2]},
	1813	max_triangle_area=10)
[2200]	1814	self.failUnless(len(m.regions)==1,
	1815	'FAILED!')
	1816	segs = m.getUserSegments()
	1817	self.failUnless(len(segs)==4,
	1818	'FAILED!')
	1819	self.failUnless(len(m.userVertices)==4,
	1820	'FAILED!')
	1821	self.failUnless(segs[0].tag=='tagin',
	1822	'FAILED!')
	1823	self.failUnless(segs[1].tag=='tagin',
	1824	'FAILED!')
	1825
	1826	self.failUnless(segs[2].tag=='bom',
	1827	'FAILED!')
	1828	self.failUnless(segs[3].tag=='',
	1829	'FAILED!')
[2261]	1830
	1831	def test_add_region_from_polygon3(self):
[2276]	1832	x=-500
	1833	y=-1000
[2261]	1834	m=Mesh(geo_reference=Geo_reference(56,x,y))
[2276]	1835
	1836	# These are the absolute values
	1837	polygon_absolute = [[0,0],[1,0],[1,1],[0,1]]
	1838
	1839	x_p = -10
	1840	y_p = -40
[2261]	1841	geo_ref_poly = Geo_reference(56, x_p, y_p)
[2276]	1842	polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
	1843
	1844	poly_point = m.add_region_from_polygon(polygon,
	1845	{'tagin':[0,1],'bom':[2]},
	1846	geo_reference=geo_ref_poly,
	1847	max_triangle_area=10)
	1848	# poly_point values are relative to the mesh geo-ref
	1849	# make them absolute
[3097]	1850	self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
[2276]	1851	polygon_absolute, closed = False),
	1852	'FAILED!')
	1853
[2261]	1854	self.failUnless(len(m.regions)==1,
	1855	'FAILED!')
	1856	segs = m.getUserSegments()
	1857	self.failUnless(len(segs)==4,
	1858	'FAILED!')
	1859	self.failUnless(len(m.userVertices)==4,
	1860	'FAILED!')
	1861	self.failUnless(segs[0].tag=='tagin',
	1862	'FAILED!')
	1863	self.failUnless(segs[1].tag=='tagin',
	1864	'FAILED!')
	1865
	1866	self.failUnless(segs[2].tag=='bom',
	1867	'FAILED!')
	1868	self.failUnless(segs[3].tag=='',
	1869	'FAILED!')
	1870	verts = m.getUserVertices()
	1871	#print "User verts",verts
	1872	#print 'polygon',polygon
	1873	#vert values are relative
	1874	for point,new_point in map(None,polygon,verts):
	1875	point_x = point[0] + geo_ref_poly.get_xllcorner()
	1876	new_point_x = new_point.x + m.geo_reference.get_xllcorner()
	1877	point_y = point[1] + geo_ref_poly.get_yllcorner()
[2276]	1878	#print "new_point.y",new_point.y
	1879	#print "m.geo_ref.get_yllcorner()",m.geo_reference.get_yllcorner()
[2261]	1880	new_point_y = new_point.y + m.geo_reference.get_yllcorner()
	1881	#print "point_y",point_y
	1882	#print "new_point_y",new_point_y
	1883
	1884	self.failUnless(point_x == new_point_x, ' failed')
	1885	self.failUnless(point_y == new_point_y, ' failed')
	1886
	1887
	1888	def test_add_region_from_polygon4(self):
[2276]	1889	x=50000
	1890	y=1000
[2261]	1891	m=Mesh(geo_reference=Geo_reference(56,x,y))
	1892	polygon = [[0,0],[1,0],[1,1],[0,1]]
[2200]	1893
[2261]	1894	m.add_region_from_polygon(polygon,
[2276]	1895	{'tagin':[0,1],'bom':[2]},
	1896	max_triangle_area=10)
[2261]	1897	self.failUnless(len(m.regions)==1,
	1898	'FAILED!')
	1899	segs = m.getUserSegments()
	1900	self.failUnless(len(segs)==4,
	1901	'FAILED!')
	1902	self.failUnless(len(m.userVertices)==4,
	1903	'FAILED!')
	1904	self.failUnless(segs[0].tag=='tagin',
	1905	'FAILED!')
	1906	self.failUnless(segs[1].tag=='tagin',
	1907	'FAILED!')
	1908
	1909	self.failUnless(segs[2].tag=='bom',
	1910	'FAILED!')
	1911	self.failUnless(segs[3].tag=='',
	1912	'FAILED!')
	1913	verts = m.getUserVertices()
	1914	#print "User verts",verts
	1915	#print 'polygon',polygon
	1916	#vert values are relative
	1917	for point,new_point in map(None,polygon,verts):
	1918	point_x = point[0]
	1919	new_point_x = new_point.x + m.geo_reference.get_xllcorner()
	1920	#print "point_x",point_x
	1921	#print "new_point_x",new_point_x
	1922	point_y = point[1]
	1923	new_point_y = new_point.y + m.geo_reference.get_yllcorner()
	1924
	1925	self.failUnless(point_x == new_point_x, ' failed')
	1926	self.failUnless(point_y == new_point_y, ' failed')
[2200]	1927
[2261]	1928
[2297]	1929	def test_add_hole_from_polygon(self):
	1930	x=-500
	1931	y=-1000
	1932	m=Mesh(geo_reference=Geo_reference(56,x,y))
	1933
	1934	# These are the absolute values
	1935	polygon_absolute = [[0,0],[1,0],[1,1],[0,1]]
	1936
	1937	x_p = -10
	1938	y_p = -40
	1939	geo_ref_poly = Geo_reference(56, x_p, y_p)
	1940	polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
	1941
	1942	poly_point = m.add_hole_from_polygon(polygon,
	1943	{'tagin':[0,1],'bom':[2]},
	1944	geo_reference=geo_ref_poly)
	1945	# poly_point values are relative to the mesh geo-ref
	1946	# make them absolute
	1947	#print "poly_point.x+x",poly_point.x+x
[3097]	1948	#print "poly_point.y+y",poly_point.y+y
[2297]	1949	#print "polygon_absolute", polygon_absolute
[3097]	1950	self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
[2297]	1951	polygon_absolute, closed = False),
	1952	'FAILED!')
	1953
	1954	self.failUnless(len(m.holes)==1,
	1955	'FAILED!')
	1956	segs = m.getUserSegments()
	1957	self.failUnless(len(segs)==4,
	1958	'FAILED!')
	1959	self.failUnless(len(m.userVertices)==4,
	1960	'FAILED!')
	1961	self.failUnless(segs[0].tag=='tagin',
	1962	'FAILED!')
	1963	self.failUnless(segs[1].tag=='tagin',
	1964	'FAILED!')
	1965
	1966	self.failUnless(segs[2].tag=='bom',
	1967	'FAILED!')
	1968	self.failUnless(segs[3].tag=='',
	1969	'FAILED!')
	1970	verts = m.getUserVertices()
	1971	#print "User verts",verts
	1972	#print 'polygon',polygon
	1973	#vert values are relative
	1974	for point,new_point in map(None,polygon,verts):
	1975	point_x = point[0] + geo_ref_poly.get_xllcorner()
	1976	new_point_x = new_point.x + m.geo_reference.get_xllcorner()
	1977	point_y = point[1] + geo_ref_poly.get_yllcorner()
	1978	#print "new_point.y",new_point.y
	1979	#print "m.geo_ref.get_yllcorner()",m.geo_reference.get_yllcorner()
	1980	new_point_y = new_point.y + m.geo_reference.get_yllcorner()
	1981	#print "point_y",point_y
	1982	#print "new_point_y",new_point_y
	1983
	1984	self.failUnless(point_x == new_point_x, ' failed')
	1985	self.failUnless(point_y == new_point_y, ' failed')
[2301]	1986
	1987	def test_add_circle(self):
	1988	x=-500
	1989	y=-1000
	1990	m=Mesh(geo_reference=Geo_reference(56,x,y))
	1991
	1992	# These are the absolute values
	1993	tag = 'hey'
	1994	segment_count = 104
	1995	radius = 30
	1996	circle_center_absolute = [100,80]
	1997	x_p = -.666
	1998	y_p = -.777
	1999	geo_ref_poly = Geo_reference(56, x_p, y_p)
	2000	circle_center = \
	2001	geo_ref_poly.change_points_geo_ref(circle_center_absolute)
	2002	circle_center = circle_center[0] #make a list of lists a list
	2003	poly_point = m.add_circle(circle_center, radius, segment_count,
	2004	tag=tag,
	2005	region=True,
	2006	center_geo_reference=geo_ref_poly)
	2007	# poly_point values are relative to the mesh geo-ref
	2008	# make them absolute
	2009	#print "poly_point.x+x",poly_point.x+x
	2010	#print "polygon_absolute", polygon_absolute
	2011
	2012
[3001]	2013	#m.export_mesh_file("aaat.msh")
[2301]	2014
	2015	self.failUnless(len(m.regions)==1,
	2016	'FAILED!')
	2017	segs = m.getUserSegments()
	2018	self.failUnless(len(segs)==segment_count,
	2019	'FAILED!')
	2020	self.failUnless(len(m.userVertices)==segment_count,
	2021	'FAILED!')
	2022	self.failUnless(segs[0].tag==tag,
	2023	'FAILED!')
	2024	self.failUnless(segs[1].tag==tag,
	2025	'FAILED!')
	2026
	2027	verts = m.getUserVertices()
	2028
[3001]	2029	#m.export_mesh_file("aaat.msh")
[2301]	2030
[2396]	2031	def FIXMEtest_auto_set_geo_reference(self):
	2032	x=50000
	2033	y=1000
	2034	m=Mesh(geo_reference=Geo_reference(56,x,y))
	2035	polygon = [[0,0],[1,0],[1,1],[0,1]]
	2036
	2037	m.add_region_from_polygon(polygon,
	2038	{'tagin':[0,1],'bom':[2]},
	2039	max_triangle_area=10)
	2040	m.auto_set_geo_reference()
	2041
[2994]	2042
[3013]	2043	def test_duplicat_verts_are_removed(self):
[2994]	2044
	2045
	2046	a = Vertex ( 0.0 ,0.0)
	2047	b = Vertex (0.0, 4.0)
	2048	c = Vertex (4.0,4.0)
	2049	d = Vertex (4.0,0.0)
[3013]	2050	e = Vertex (4.0,0.0) # duplicate point
[2994]	2051
	2052	s1 = Segment(a,b, tag = "50")
	2053	s2 = Segment(b,c, tag = "40")
	2054	s3 = Segment(c,d, tag = "30")
[3013]	2055	s4 = Segment(d,e, tag = "no where seg")
	2056	s5 = Segment(e,a, tag = "20")
[2994]	2057
	2058
	2059	m = Mesh(userVertices=[a,b,c,d,e],
[3013]	2060	userSegments=[s1,s2,s3,s4,s5])
[2994]	2061
	2062	seg = m.getUserSegments()
	2063	points = m.getUserVertices()
	2064	holes = m.getHoles()
	2065	regions = m.getRegions()
[3013]	2066	#fileName = tempfile.mktemp(".tsh")
[3001]	2067	#fileName = "badmesh.tsh"
[3013]	2068	#m.export_mesh_file(fileName)
[3001]	2069	#print "***************************fileName", fileName
[2994]	2070	#new_m = importMeshFromFile(fileName)
[3013]	2071	#os.remove(fileName)
[2994]	2072
[3013]	2073	m.generateMesh("Q", maxArea = 2000.1 )
[2994]	2074
[3013]	2075	#m.export_mesh_file("from_test_mesh.tsh")
[3001]	2076	seg = m.getMeshSegments()
[3013]	2077	self.failUnless(4==len(seg),
	2078	'FAILED!')
	2079
	2080	vert = m.getMeshVertices()
	2081	self.failUnless(4==len(vert),
	2082	'FAILED!')
	2083
	2084	def test_duplicat_verts_are_removedII(self):
	2085
	2086
	2087	a = Vertex ( 0.0 ,0.0)
	2088	b = Vertex (0.0, 4.0)
	2089	c = Vertex (4.0,4.0)
	2090	d = Vertex (4.0,0.0)
	2091	e = Vertex (4.0,0.0) # duplicate point
	2092	f = Vertex (49.0,0.0) # unused point
	2093
	2094	s1 = Segment(a,b, tag = "50")
	2095	s2 = Segment(b,c, tag = "40")
	2096	s3 = Segment(c,d, tag = "30")
	2097	s4 = Segment(d,e, tag = "no where seg")
	2098	s5 = Segment(e,a, tag = "20")
	2099
[3001]	2100
[3013]	2101	m = Mesh(userVertices=[a,b,c,d,e,f],
	2102	userSegments=[s1,s2,s3,s4,s5])
	2103
	2104	seg = m.getUserSegments()
	2105	points = m.getUserVertices()
	2106	holes = m.getHoles()
	2107	regions = m.getRegions()
	2108	#fileName = tempfile.mktemp(".tsh")
	2109	#fileName = "badmesh.tsh"
	2110	#m.export_mesh_file(fileName)
	2111	#print "***************************fileName", fileName
	2112	#new_m = importMeshFromFile(fileName)
	2113	#os.remove(fileName)
[3001]	2114
[3013]	2115	m.generateMesh("Q", maxArea = 2000.1 )
	2116
	2117	#m.export_mesh_file("from_test_mesh.tsh")
	2118	seg = m.getMeshSegments()
	2119	self.failUnless(4==len(seg),
	2120	'FAILED!')
	2121
	2122	vert = m.getMeshVertices()
	2123	self.failUnless(4==len(vert),
	2124	'FAILED!')
[3177]	2125
	2126	def test_add_vertices(self):
	2127	points_ab = [[0.1,1],[0.4,.2],[7,5],[10,5]]
	2128	geo = Geo_reference(56,23,21)
	2129	points = geo.change_points_geo_ref(points_ab)
	2130	spat = Geospatial_data(points, geo_reference=geo)
[2994]	2131
[3177]	2132	geo_mesh = Geo_reference(56,100,200)
	2133	m = Mesh(geo_reference=geo_mesh)
	2134	m.add_vertices(spat)
	2135
	2136	vert = m.getUserVertices()
	2137	#print "vert",vert
	2138	self.failUnless(4==len(vert),
	2139	'FAILED!')
	2140	vert= m.get_user_vertices(absolute=True)
	2141	self.failUnless(vert==points_ab,
	2142	'FAILED!')
	2143
	2144
	2145	def test_get_user_vertices(self):
	2146	points_ab = [[0.1,1],[0.4,.2],[7,5],[10,5]]
	2147	geo = Geo_reference(56,23,21)
	2148	points = geo.change_points_geo_ref(points_ab)
	2149	spat = Geospatial_data(points, geo_reference=geo)
	2150
	2151	geo_mesh = Geo_reference(56,100,200)
	2152	m = Mesh(geo_reference=geo_mesh)
	2153	m.add_vertices(spat)
	2154
	2155	vert = m.getUserVertices()
	2156	#print "vert",vert
	2157	self.failUnless(4==len(vert),
	2158	'FAILED!')
	2159	vert= m.get_user_vertices(absolute=True)
	2160	self.failUnless(vert==points_ab,
	2161	'FAILED!')
	2162	vert= m.get_user_vertices(absolute=False)
	2163	points_new = m.geo_reference.get_absolute(vert)
	2164
	2165	self.failUnless(points_ab==points_new,
	2166	'FAILED!')
	2167
	2168
[1361]	2169	def list_comp(A,B):
	2170	yes = len(A)==len(B)
	2171	for item in A:
	2172	if not item in B:
	2173	yes = False
	2174	return yes
	2175
[2994]	2176
	2177
[349]	2178	#-------------------------------------------------------------
	2179	if __name__ == "__main__":
[3002]	2180	suite = unittest.makeSuite(meshTestCase,'test')
[3097]	2181	#suite = unittest.makeSuite(meshTestCase,'test_add_hole_from_polygon')
[702]	2182	runner = unittest.TextTestRunner() #verbosity=2)
[349]	2183	runner.run(suite)
	2184

Note: See TracBrowser for help on using the repository browser.

Download in other formats: