Changeset 4901

Timestamp:

Jan 3, 2008, 9:58:32 PM (17 years ago)

Author:

duncan

Message:

Using a numeric array to store mesh triangulation info. The old way is also in place.

Location:

anuga_core/source/anuga

Files:

• abstract_2d_finite_volumes/pmesh2domain.py (modified) (1 diff)
• load_mesh/loadASCII.py (modified) (2 diffs)
• mesh_engine/mesh_engine.py (modified) (2 diffs)
• pmesh/graphical_mesh_generator.py (modified) (1 diff)
• pmesh/mesh.py (modified) (10 diffs)

anuga_core/source/anuga/abstract_2d_finite_volumes/pmesh2domain.py

@@ -190 +190 @@
     """
     tri_atts = mesh_dict['triangle_tags']
-    #print "tri_atts", tri_atts
     tagged_elements = {}
-    for tri_att_index in range(len(tri_atts)):
-        tagged_elements.setdefault(tri_atts[tri_att_index],[]).append(tri_att_index)
-    #print "DSG pm2do tagged_elements", tagged_elements
+    if tri_atts is None:
+       tagged_elements[''] = range(len(mesh_dict['triangles']))
+    else:
+        for tri_att_index in range(len(tri_atts)):
+            tagged_elements.setdefault(tri_atts[tri_att_index],
+                                       []).append(tri_att_index)
     return tagged_elements
 

anuga_core/source/anuga/load_mesh/loadASCII.py

@@ -21 +21 @@
     segment_tags : [tag,tag,...] list of strings
     triangles : [(v1,v2,v3), (v4,v5,v6),....] lists of points
-    triangle_tags: [s1,s2,...] A list of list of strings (probably not
-    neccecary.  a list of string should be ok)
+    triangle_tags: [s1,s2,...] A list of strings 
     triangle_neighbors: [[t1,t2,t3], [t4,t5,t6],..] lists of triangles
         
@@ -512 +511 @@
         # with triangle, and it seems to have the option of returning
         # more than one value for triangle attributex
-        if triangles_attributes == [] or triangles_attributes[index] == ['']:
+        if triangles_attributes == None or \
+               triangles_attributes == [] or \
+               triangles_attributes[index] == ['']:
             att = ""
         else:

anuga_core/source/anuga/mesh_engine/mesh_engine.py

@@ -148 +148 @@
     #print "mesh eng generatedtrianglelist", trianglelist
     #print "mesh eng mesh_dict['triangleattributelist'] ",mesh_dict['triangleattributelist']
-    #print "mesh eng mesh_dict['generatedtriangleattributelist'] ", mesh_dict['generatedtriangleattributelist']    
-    
+    #print "mesh eng mesh_dict['generatedtriangleattributelist'] ", mesh_dict['generatedtriangleattributelist']   
     if True: 
         mesh_dict['generatedtriangleattributelist'] = triangleattributelist
@@ -155 +154 @@
         if mesh_dict['generatedtriangleattributelist'].shape[1] == 0:
             mesh_dict['generatedtriangleattributelist'] = None
+            
         if trianglelist.shape[0] == 0:
             # There are no triangles.
             # this is used by urs_ungridded2sww
             raise NoTrianglesError
-    #print "mesh eng mesh_dict['generatedtriangleattributelist'] ", mesh_dict['generatedtriangleattributelist']    
+    #print "mesh eng mesh_dict['generatedtriangleattributelist'] ", mesh_dict['generatedtriangleattributelist']  
+    
+    # the structure of generatedtriangleattributelist is an list of
+    # list of integers.  It is transformed into a list of list of
+    # strings later on.  This is then inputted into an triangle
+    # object.  The triangle object outputs a list of strings.  Note
+    # the subtle change!  How should I handle this?  For my code, when
+    # the list of list of integers is transformed, transform it into a
+    # list of strings, not a list of list of strings.
     
     return mesh_dict

anuga_core/source/anuga/pmesh/graphical_mesh_generator.py

@@ -1083 +1083 @@
         """
         if self.Visualise:
-            for triangle in mesh.getTriangulation():
-                self.serial +=1
-                self.uniqueID = 'M*%d' % self.serial
-                self.Triangles.visualise(triangle,
-                                        self.uniqueID,
-                                        self.canvas,
-                                        self.SCALE)
-
-        if self.Visualise:
-            Triangles = mesh.sets[mesh.setID[self.selSet]]
-            for triangle in Triangles:
-                triangle.draw(self.canvas,1,
-                              scale = self.SCALE,
-                              colour = SET_COLOUR)
+            mesh.tri_mesh.draw_triangulation(self.canvas,
+                                             scale = self.SCALE)
 
         for segment in mesh.getUserSegments():

anuga_core/source/anuga/pmesh/mesh.py

@@ -520 +520 @@
                  vertices,
                  triangle_tags,
-                 triangle_neighbor,
+                 triangle_neighbors,
                  segment_tags,
                  ):
        
-        self.triangles=ensure_numeric(triangles) 
-        self.triangle_neighbor=ensure_numeric(triangle_neighbor)
-        self.triangle_tags=triangle_tags
-        self.segments=ensure_numeric(segments) 
-        
-        self.segment_tags=segment_tags # string
-        self.vertices=ensure_numeric(vertices)
-
-        
+        self.triangles = ensure_numeric(triangles) 
+        self.triangle_neighbors = ensure_numeric(triangle_neighbors)
+        self.triangle_tags = triangle_tags # list of strings
+        self.segments = ensure_numeric(segments) 
+        
+        self.segment_tags = segment_tags # list of strings
+        self.vertices = ensure_numeric(vertices)
+
+       
+    def draw_triangulation(self, canvas, scale=1, xoffset=0, yoffset=0,
+             colour="green"):
+        """
+        Draw a triangle, returning the objectID
+        """
+        
+        # FIXME(DSG-DSG) This could be a data structure that is
+        # remembered and doesn't have any duplicates.
+        # but I wouldn't be able to use create_polygon.
+        # regard it as drawing a heap of segments
+        
+        for tri in self.triangles:
+            vertices = []
+            for v_index in range(3):
+                vertices.append(self.vertices[tri[v_index]])
+            
+            objectID = canvas.create_polygon(
+                scale*(vertices[1][0] + xoffset),
+                scale*-1*(vertices[1][1] + yoffset),
+                scale*(vertices[0][0] + xoffset),
+                scale*-1*(vertices[0][1] + yoffset),
+                scale*(vertices[2][0] + xoffset),
+                scale*-1*(vertices[2][1] + yoffset),
+                outline = colour,fill = ''
+                )
+ 
         
 class Mesh:
@@ -575 +601 @@
         self.meshVertices=[]
 
+        # Rigid
+        self.tri_mesh=None
+        
         self.setID={}
         #a dictionary of names.
@@ -1211 +1240 @@
         #print "generatedMesh",generatedMesh
         #print "##################"
-        
         self.setTriangulation(generatedMesh)
     
@@ -1564 +1592 @@
                     self.meshTriangles[index].setAttribute("")
                 else:
-                    self.meshTriangles[index].setAttribute(att[0])
+                    self.meshTriangles[index].setAttribute(att)
                 index += 1
             
@@ -1588 +1616 @@
                                                    ObjectNeighbor[2])
             index += 1
+        
+        # Setting up the rigid triangulation
+        self.tri_mesh = Rigid_triangulation(
+            genDict['generatedtrianglelist']
+            ,genDict['generatedsegmentlist']
+            ,genDict['generatedpointlist']
+            ,genDict['generatedtriangleattributelist']
+            ,genDict['generatedtriangleneighborlist']
+            ,genDict['generatedsegmentmarkerlist']
+            )
             
     def setMesh(self, genDict):
@@ -2206 +2244 @@
         meshDict['triangle_neighbors'] = triangle_neighbors
         
+        if self.tri_mesh is not None:
+            meshDict['triangles'] = self.tri_mesh.triangles
+            meshDict['triangle_tags'] = self.tri_mesh.triangle_tags
+            #print "mesh meshDict['triangle_tags']", meshDict['triangle_tags']
+            meshDict['triangle_neighbors'] = self.tri_mesh.triangle_neighbors
+        else:
+            meshDict['triangles'] = []
+            meshDict['triangle_tags'] = []
+            meshDict['triangle_neighbors'] = []
         #print "mesh.Mesh2IOTriangulationDict*)*)"
         #print meshDict
@@ -2288 +2335 @@
         """
         #Clear the current generated mesh values
-        self.meshTriangles=[]
-        self.attributeTitles=[]
-        self.meshSegments=[]
-        self.meshVertices=[]
-
+        self.meshTriangles = []
+        self.attributeTitles = []
+        self.meshSegments = []
+        self.meshVertices = []
+        self.tri_mesh = None
+        
         #print "mesh.setTriangulation@#@#@#"
         #print genDict
@@ -2353 +2401 @@
             index += 1
 
+        self.tri_mesh = Rigid_triangulation(
+            genDict['triangles']
+            ,genDict['segments']
+            ,genDict['vertices']
+            ,genDict['triangle_tags']
+            ,genDict['triangle_neighbors']
+            ,genDict['segment_tags']
+            )
 
     def IOOutline2Mesh(self, genDict):
@@ -3166 +3222 @@
         for i in xrange(len(region_list)):
             temp = region_list[i]
-            returned_region_list.append([convertint2string[int(temp[0])]])
+            returned_region_list.append(convertint2string[int(temp[0])])
     return returned_region_list
 
@@ -3932 +3988 @@
 # instead of functionName
 if __name__ == "__main__":
-    #from mesh import *
-    # THIS CAN BE DELETED
-    m = Mesh()
-    dict = importUngenerateFile("ungen_test.txt")
-    m.addVertsSegs(dict)
-    print m3
+    pass