Changeset 829

Timestamp:

Feb 2, 2005, 12:10:28 PM (20 years ago)

Author:

prow

Message:

Adding visualise/unvisualise. Adding files for gradient func

Location:

inundation/ga/storm_surge/pmesh

Files:

• compile.py (added)
• config.py (added)
• icons/Copy of meshGen.gif (deleted)
• icons/gradient_threshold.gif (added)
• icons/unvisualise.gif (added)
• icons/visualise.gif (added)
• mesh.py (modified) (2 diffs)
• pmesh.py (modified) (4 diffs)
• util_ext.c (added)
• util_ext.dll (added)
• util_ext.h (added)
• util_ext.o (added)

inundation/ga/storm_surge/pmesh/mesh.py

@@ -30 +30 @@
 SET_COLOUR='red'
 
+
+
+    
+def gradient_python(x0, y0, x1, y1, x2, y2, q0, q1, q2):
+    """
+    """
+    
+    det = (y2-y0)*(x1-x0) - (y1-y0)*(x2-x0)            
+    a = (y2-y0)*(q1-q0) - (y1-y0)*(q2-q0)
+    a /= det
+
+    b = (x1-x0)*(q2-q0) - (x2-x0)*(q1-q0)
+    b /= det            
+
+    return a, b
+
+##############################################
+#Initialise module
+
+import compile
+if compile.can_use_C_extension('util_ext.c'):
+    from util_ext import gradient, point_on_line 
+else:
+    gradient = gradient_python
 
 # 1st and third values must be the same
@@ -1737 +1761 @@
         return userVertices, userSegments
 
-    def threshold(self,setName,min=None,max=None):
-        """
-        threshold using d/A, not d
+    def threshold(self,setName,min=None,max=None,attribute_name = 'elevation'):
+        """
+        threshold using  d
         """
         triangles = self.sets[self.setID[setName]]
         A = []
+
+        if attribute_name in self.attributeTitles:
+            i = self.attributeTitles.index(attribute_name)
         if not max == None:
             for t in triangles:
-                if (min<self.av_att(t)<max):
+                if (min<self.av_att(t,i)<max):
                     A.append(t)
         else:
             for t in triangles:
-                if (min<self.av_att(t)):
+                if (min<self.av_att(t,i)):
                     A.append(t)
         self.sets[self.setID[setName]] = A
 
-
-    def av_att(self,triangle):
+    def general_threshold(self,setName,min=None,max=None,attribute_name = 'elevation',function = None):
+        """
+        threshold using  d
+        """
+        triangles = self.sets[self.setID[setName]]
+        A = []
+
+        if attribute_name in self.attributeTitles:
+            i = self.attributeTitles.index(attribute_name)
+        if not max == None:
+            for t in triangles:
+                if (min<function(t,i)<max):
+                    A.append(t)
+        else:
+            for t in triangles:
+                if (min<self.function(t,i)):
+                    A.append(t)
+        self.sets[self.setID[setName]] = A
+
+    def av_att(self,triangle,i):
     #evaluates the average attribute of the vertices of a triangle.
         V = triangle.getVertices()
-        a0 = (V[0].attributes[0])
-        a1 = (V[1].attributes[0])
-        a2 = (V[2].attributes[0])
+        a0 = (V[0].attributes[i])
+        a1 = (V[1].attributes[i])
+        a2 = (V[2].attributes[i])
         return (a0+a1+a2)/3
 
-    def Courant_threshold(self,setName,min=None,max=None):
-        """
-        threshold using d/A, not d
-        """
-        triangles = self.sets[self.setID[setName]]
-        A = []
-        if not max == None:
-            for t in triangles:
-                if (min<self.Courant_ratio(t)<max):
-                    A.append(t)
-        else:
-            for t in triangles:
-                if (min<self.av_att(t)):
-                    A.append(t)
-        self.sets[self.setID[setName]] = A
-
-
-
-    def Courant_ratio(self,triangle):
+    def Courant_ratio(self,triangle,index):
         """
         Not the true Courant ratio, just elevation on area
         """
-        e = self.av_att(triangle)
+        e = self.av_att(triangle,index)
         A = triangle.calcArea()
         return e/A
+
+    def Gradient(self,triangle,index):
+        V = triangle.vertices
+        x0, y0, x1, y1, x2, y2, q0, q1, q2 = V[0].x,V[0].y,V[1].x,V[1].y,V[2].x,V[2].y,V[0].attributes[index],V[1].attributes[index],V[2].attributes[index]
+        grad_x,grad_y = gradient(x0, y0, x1, y1, x2, y2, q0, q1, q2)
+        if ((grad_x**2)+(grad_y**2))**(0.5)<0:
+            print ((grad_x**2)+(grad_y**2))**(0.5)
+        return ((grad_x**2)+(grad_y**2))**(0.5)
+    
 
     def append_triangle(self,triangle):

inundation/ga/storm_surge/pmesh/pmesh.py

@@ -234 +234 @@
                                statushelp='' )
 
+    def createVisualiseIcons(self):
+        """
+        Add Edit buttons to the top of the GUI
+        """
+        ToolBarButton(self, self.toolbar, 'sep', 'sep.gif', width=10,
+                      state='disabled')
+        for key, func, balloon in [
+                ('visualise', self.visualise, 'Visualise mesh triangles'),
+                ('unvisualise', self.unvisualise, 'Do not visualise mesh triangles (for large meshes)')]:
+            ToolBarButton(self, self.toolbar, key, '%s.gif' %key,
+                          command=func, balloonhelp=balloon,
+                               statushelp='' )
 
 
@@ -351 +363 @@
         self.visualiseMesh(self.mesh)
 
+    def visualise(self,parent):
+        self.Visualise = True
+        self.visualiseMesh(self.mesh)
+
+    def unvisualise(self,parent):
+        self.Visualise = False
 
     def createMesh(self):
@@ -874 +892 @@
         visualise vertices, segments, triangulation, holes
         """
-        for triangle in mesh.getTriangulation():
-            self.serial +=1
-            self.uniqueID = 'M*%d' % self.serial
-            self.Triangles.visualise(triangle,
-                                    self.uniqueID,
-                                    self.canvas,
-                                    self.SCALE)
-
-        Triangles = mesh.sets[mesh.setID[self.selSet]]
-        for triangle in Triangles:
-            triangle.draw(self.canvas,1,
-                          scale = self.SCALE,
-                          colour = SET_COLOUR)
+        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)
 
         for segment in mesh.getUserSegments():
@@ -1259 +1279 @@
         self.createSetTools()
         self.createSetIcons()
+        self.createVisualiseIcons()
         #self.addVertsAndSegs() # !!!DSG start pmesh with a triangle
         self.selectFunc('pointer')
         self.currentPath = os.getcwd() 
+
+        self.Visualise = True
 
     def loadtestmesh(self,ofile):