[Bf-extensions-cvs] SVN commit: /data/svn/bf-extensions [2476] branches/geodesic_domes/vefm_259 .py: removed import sys and (some) clean up

Peter K.H. Gragert pkhgragert at gmail.com
Tue Oct 18 11:15:23 CEST 2011


Revision: 2476
          http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-extensions&revision=2476
Author:   pkhg
Date:     2011-10-18 09:15:23 +0000 (Tue, 18 Oct 2011)
Log Message:
-----------
removed import sys and (some) clean up

Modified Paths:
--------------
    branches/geodesic_domes/vefm_259.py

Modified: branches/geodesic_domes/vefm_259.py
===================================================================
--- branches/geodesic_domes/vefm_259.py	2011-10-18 09:14:46 UTC (rev 2475)
+++ branches/geodesic_domes/vefm_259.py	2011-10-18 09:15:23 UTC (rev 2476)
@@ -2,7 +2,6 @@
 import bpy
 import math
 from math import sqrt,acos,pi,sin,cos,atan,tan,fabs
-#from Blender import NMesh
 from mathutils import Vector
 #dbg = True
 sgn = lambda x : (x>0) - (x<0) #missing signum functin in Python
@@ -33,8 +32,8 @@
     m = bpy.data.meshes.new(name= selfobj.name)
     m.from_pydata(v, e, f )
     # useful for development when the mesh may be invalid.
-    m.validate(verbose=True)
-    add_object_data(bpy.context, m, operator=None)    
+    m.validate(verbose = True)
+    add_object_data(bpy.context, m, operator = None)    
 
 
 #extra test phase
@@ -44,7 +43,7 @@
 
 class vertex:
 
-    def __init__(self,vec=(0,0,0)): #x=0,y=0,z=0):        
+    def __init__(self,vec=(0,0,0)): #x = 0,y = 0,z = 0):        
         self.vector  = Vector(vec)
         self.x = vec[0]
         self.y = vec[1]
@@ -55,17 +54,11 @@
         self.edges = []
         self.faces = []
         self.boundary = 0
-#PKHG is ok  not needed anymore        if dbg:
-#            print("dbg: vertex generate with  length = ",self.length)
-        
 
     def findlength(self):
+         self.length = self.vector.length
 
-#        self.length=sqrt(self.x*self.x+self.y*self.y+self.z*self.z)
-        self.length = self.vector.length
-
     def normalize(self):
-
         self.findlength()
         if self.length > 0:
             tmp = 1.0/self.length
@@ -99,7 +92,7 @@
         self.tempedges = []
         self.tempfaces = []
         for i in range(len(self.edges)):
-            print("\n----------------------voor breakpunt pkhg in clockwise")
+            #print("\n----------------------voor breakpunt pkhg in clockwise")
             #breakpoint(locals(), self.index == 0)
             self.tempfaces.append(start)
             for corner in start.corners:
@@ -121,36 +114,20 @@
 
     def __add__(self,other):
         tmp = self.vector + other.vector
-        #x = self.x+other.x
-        #y = self.y+other.y
-        #z = self.z+other.z
-        #return vertex((x,y,z))
         return vertex(tmp)
 
     def __sub__(self,other):
         tmp = self.vector - other.vector
-        #x = self.x-other.x
-        #y = self.y-other.y
-        #z = self.z-other.z
-        #return vertex((x,y,z))
         return vertex(tmp)
 
     def __mul__(self,other):
-        #x = self.x*other
-        #y = self.y*other
-        #z = self.z*other
         tmp = self.vector * other
-        #return vertex((x,y,z))
         return vertex(tmp)
 
     def __truediv__(self,other):
         denom = 1.0/other
         tmp = self.vector * denom
         return (tmp)
-#        x = self.x*tmp#(1/other)
-#        y = self.y*tmp#(1/other)
-#        z = self.z*tmp#(1/other)
-#        return vertex((x,y,z))
 
     def negative(self):
         return vertex((-self.x,-self.y,-self.z))
@@ -169,6 +146,7 @@
 #        z = (self.v1.x*self.v2.y)-(self.v2.x*self.v1.y)
 #        return vertex(x,y,z)
         return vertex(tmp)
+
 class average:
     ##   Takes a list of vertices and returns the average. If two verts are passed, returns midpoint.
     def __init__(self,vertlist):
@@ -181,16 +159,16 @@
         divisor = 1.0 / len(self.vertlist)
         for vert in self.vertlist:
             tmp += vert.vector
-#           x=x+vert.x
-#           y=y+vert.y
-#           z=z+vert.z
+#           x = x+vert.x
+#           y = y+vert.y
+#           z = z+vert.z
         tmp *= divisor
 #       return vertex(x/divisor,y/divisor,z/divisor)
         #return vertex(tmp[0],tmp[1],tmp[2])
         return vertex(tmp)
 
 class edge:
-    def __init__(self,a=0,b=0):
+    def __init__(self,a = 0,b = 0):
         self.a = a
         self.b = b
         self.index = 0
@@ -212,19 +190,15 @@
         self.vectb = self.a - self.b
 
     def findlength(self):
-        #print("in edge findlength")
         self.vect.findlength()
         self.vectb.length = self.vect.length
 
     def findnormal(self):
                 
         if self.boundary:
-            self.normal = self.faces[0].normal    #average([self.a,self.b]).centroid()    
-            
+            self.normal = self.faces[0].normal    #average([self.a,self.b]).centroid()
         else:
-    
             self.normal = average([self.faces[0].normal,self.faces[1].normal]).centroid()
-        
         self.normal.normalize()
 #     def findother(self,vertindex):
 #
@@ -235,16 +209,17 @@
 #         else:
 #             return self.a
 ##        different classes for 3,4,> sides??
+
 class face:
     def __init__(self,vertices=[]):
 #PKHG ok good for tri's at least        print("\n ========= vefm L226======dbg face vertices = ",vertices)
-        self.vertices=vertices    ##   List of vertex instances.
+        self.vertices = vertices    ##   List of vertex instances.
         self.edges=[]            ##   Will be filled with the sides of the face.
-        self.boundary=0        ##   When set will have bool and id of edge concerned.
-        self.normal=0            ##   Face normal found through cross product.
+        self.boundary = 0        ##   When set will have bool and id of edge concerned.
+        self.normal = 0            ##   Face normal found through cross product.
         self.corners=[]
         self.spokes=[]            ##   Vectors of the bisecting angles from each corner to the centre + dotproduct.
-        self.index=0
+        self.index = 0
  
  #dotproduct is misleading name, it is the hook between two vectors!
     def dotproduct(self,v1,v2):
@@ -260,20 +235,20 @@
     #    print("v1 length",v1.length)
     #    print("v2 length",v2.length)
         dot=(v1.x*v2.x)+(v1.y*v2.y)+(v1.z*v2.z)
-        costheta=dot/(v1.length*v2.length)
+        costheta = dot/(v1.length*v2.length)
         pkhgtmp = v1.vector.dot(v2.vector)
         tmp = acos(costheta)
         return tmp
     
     def orderedges(self):
         temp=[]
-        finish=len(self.vertices)
+        finish = len(self.vertices)
         for i in range(finish):
-            current=self.vertices[i]
+            current = self.vertices[i]
             if i==finish-1:
-                next=self.vertices[0]
+                next = self.vertices[0]
             else:
-                next=self.vertices[i+1]
+                next = self.vertices[i+1]
             for edge in face.edges:
                 if edge.a==current and edge.b==next:
                     face.clockw.append(edge.vect)
@@ -292,13 +267,13 @@
                     face.clockw.append(edge.vectb)
                     face.aclockw.append(edge.vect)
                     temp.append(edge)
-            face.vertices=temp
+            face.vertices = temp
     
     
     def docorners(self):
         ##   This function identifies and stores the vectors coming from each vertex
         ##   allowing easier calculation of cross and dot products.
-        finish=len(self.vertices)
+        finish = len(self.vertices)
         '''
         which = None
         occur1 = None
@@ -316,15 +291,15 @@
             #self.edges.append(new_edge)
         '''
         for i in range(finish):
-            current=self.vertices[i]
+            current = self.vertices[i]
             if i==finish-1:
-                next=self.vertices[0]
+                next = self.vertices[0]
             else:
-                next=self.vertices[i+1]
+                next = self.vertices[i+1]
             if i==0:
-                previous=self.vertices[-1]
+                previous = self.vertices[-1]
             else:
-                previous=self.vertices[i-1]
+                previous = self.vertices[i-1]
             corner=[current]
             #corner = current
             rightedge = None
@@ -335,23 +310,21 @@
         #            return    
                 teller += 1                                                        
                 currentinfo = (current, edge.a, edge.b, edge.a is current, edge.b is current)
-                #breakpoint(locals())
                 if edge.a is current or edge.b is current:    ##  does this edge contain our current vert
                     if edge.a is current:
                         if edge.b is next:
-                            rightedge=edge
-                            rightvect=edge.vect
+                            rightedge = edge
+                            rightvect = edge.vect
                         if edge.b is previous:
-                            leftedge=edge
-                            leftvect=edge.vect
+                            leftedge = edge
+                            leftvect = edge.vect
                     elif edge.b is current:
                         if edge.a is next:
-                            rightedge=edge
-                            rightvect=edge.vectb
+                            rightedge = edge
+                            rightvect = edge.vectb
                         if edge.a is previous:
-                            leftedge=edge
-                            leftvect=edge.vectb
-            #breakpoint(locals())                
+                            leftedge = edge
+                            leftvect = edge.vectb
             corner.append(rightedge)
             corner.append(leftedge)
             print("corner stuff  vert",current.index)
@@ -360,53 +333,53 @@
             if leftedge:
                 print( "leftedge",leftedge.index)
             print("corner",corner)
-            dotty=self.dotproduct(rightvect,leftvect)
+            dotty = self.dotproduct(rightvect,leftvect)
             corner.append(dotty)
-    #        print("corner",corner)
             self.corners.append(corner)
      
      
     def findnormal(self):
-        one=self.corners[1][2]
-        two=self.corners[1][1]
+        one = self.corners[1][2]
+        two = self.corners[1][1]
         if one.a is self.corners[1][0]:
-            one=one.vect
+            one = one.vect
         elif one.b is self.corners[1][0]:
-            one=one.vectb
+            one = one.vectb
         if two.a is self.corners[1][0]:
-            two=two.vect
+            two = two.vect
         elif two.b is self.corners[1][0]:
-            two=two.vectb
+            two = two.vectb
     #    print("crossp 1",one,"crossp 2",two)
-        self.normal=crossp(one,two).docrossproduct()

@@ Diff output truncated at 10240 characters. @@


More information about the Bf-extensions-cvs mailing list