Changeset 2563 for inundation/fit_interpolate/benchmark_least_squares.py

Timestamp:

Mar 21, 2006, 10:58:32 AM (18 years ago)

Author:

duncan

Message:

get interpolate tests running in test_all

File:

• inundation/fit_interpolate/benchmark_least_squares.py (modified) (4 diffs)

inundation/fit_interpolate/benchmark_least_squares.py

@@ -22 +22 @@
 
 from pyvolution.least_squares import Interpolation
+from fit_interpolate.interpolate import Interpolate
 from pmesh.mesh import Mesh
 
@@ -57 +58 @@
               max_points_per_cell=4,
               is_fit=True,
+              use_least_squares=True,
               save=False):
         '''
@@ -66 +68 @@
         #print "max_points_per_cell", max_points_per_cell
 
-        # make a mesh
+        mesh_dict = self._build_regular_mesh_dict(maxArea=maxArea,
+                                                  save=save)
+        points_dict = self._build_points_dict(num_of_points=num_of_points)
+            
+        #Initial time and memory
+        t0 = time.time()
+        #m0 = None on windows
+        m0 = mem_usage()
+
+        if use_least_squares is True:
+            interp = Interpolation(mesh_dict['vertices'],
+                                   mesh_dict['triangles'],
+                                   points_dict['points'],
+                                   expand_search=True,
+                                   verbose = False,
+                                   max_points_per_cell = max_points_per_cell) 
+            if is_fit is True:
+                calc = interp.fit_points(points_dict['point_attributes'])
+                
+            else:
+                # run an interploate problem.
+                print "Interpolate!"
+                calc = interp.interpolate(mesh_dict['vertex_attributes'])
+        else:
+            # need to change to fit_interpolate code
+            interp = Interpolate(mesh_dict['vertices'],
+                                 mesh_dict['triangles'], 
+                                 max_vertices_per_cell = max_points_per_cell) 
+            if is_fit is True:
+                #calc = interp.fit_points(point_atts)
+                pass
+            else:
+                # run an interploate problem.
+                print "Interpolate!"
+                calc = interp.interpolate(mesh_dict['vertex_attributes']
+                                          ,points_dict['points']
+                                          ,start_blocking_len = 500000)
+            
+        time_taken_sec = (time.time()-t0)
+        m1 = mem_usage()
+        if m0 is None or m1 is None:
+            memory_used = None
+        else:
+            memory_used = (m1 - m0)
+        #print 'That took %.2f seconds' %time_taken_sec
+        return time_taken_sec, memory_used, len(mesh_dict['triangles'])
+
+    def _build_regular_mesh_dict(self,
+                                 maxArea=1000,
+                                 save=False):
+      # make a mesh
         # pretty regular size, with some segments thrown in. 
         m = Mesh()
@@ -104 +156 @@
             m.export_mesh_file("aaaa.tsh")
         mesh_dict =  m.Mesh2IOTriangulationDict()
-        #print "mesh_dict",mesh_dict
+
+        #Add vert attribute info to the mesh
+        mesh_dict['vertex_attributes'] = []
+        # There has to be a better way of doing this..
+        for vertex in mesh_dict['vertices']:
+            mesh_dict['vertex_attributes'].append([10.0])
+
+        return mesh_dict
+
+    def _build_points_dict(self, num_of_points=20000):
+        
+        points_dict = {}
         points = []
         point_atts = []
-        vertex_atts = []
 
-              
-            
         for point in range(num_of_points):
             points.append([random()*100, random()*100])
             point_atts.append(10.0)
 
-        # There has to be a better way of doing this..
-        for vertex in mesh_dict['vertices']:
-            vertex_atts.append(10.0)
-            
-        #Initial time and memory
-        t0 = time.time()
-        #m0 = None on windows
-        m0 = mem_usage()
+        points_dict['points'] = points
+        points_dict['point_attributes'] = point_atts
+        return points_dict
 
-        interp = Interpolation(mesh_dict['vertices'],
-                               mesh_dict['triangles'], points,
-                               alpha=0.2, expand_search=True,
-                               verbose = False,
-                               max_points_per_cell = 4)
-        if is_fit is True:
-            calc = interp.fit_points(point_atts)
 
-        else:
-            # run an interploate problem.
-            print "Interpolate!"
-            calc = interp.interpolate(vertex_atts)
-            
-        time_taken_sec = (time.time()-t0)
-        m1 = mem_usage()
-        if m0 is None or m1 is None:
-            memory_used = None
-        else:
-            memory_used = (m1 - m0)
-        #print 'That took %.2f seconds' %time_taken_sec
-        return time_taken_sec, memory_used, len(mesh_dict['triangles'])
+#-------------------------------------------------------------
+if __name__ == "__main__":
+        b = BenchmarkLeastSquares()
+        b._build_regular_mesh_dict()
+        b._build_points_dict()