[Bf-extensions-cvs] SVN commit: /data/svn/bf-extensions [2442] branches/geodesic_domes/ geodesic_classes_259.py: geodesic_259 has been adjusted to do the interface with the gui
Peter K.H. Gragert
pkhgragert at gmail.com
Fri Oct 14 15:13:53 CEST 2011
Revision: 2442
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-extensions&revision=2442
Author: pkhg
Date: 2011-10-14 13:13:53 +0000 (Fri, 14 Oct 2011)
Log Message:
-----------
geodesic_259 has been adjusted to do the interface with the gui
so all the classes
mesh, vertex, etc. are now to be found in this file:
geodesic_classes_259.py
Added Paths:
-----------
branches/geodesic_domes/geodesic_classes_259.py
Added: branches/geodesic_domes/geodesic_classes_259.py
===================================================================
--- branches/geodesic_domes/geodesic_classes_259.py (rev 0)
+++ branches/geodesic_domes/geodesic_classes_259.py 2011-10-14 13:13:53 UTC (rev 2442)
@@ -0,0 +1,628 @@
+import sys
+#### TODO adjust the path for your PC
+sys.path.append("c:\\Users\\Peter\\25blender\\branches\\geodesic_domes")
+import forms_259
+from forms_259 import mesh
+import math
+from math import pi,acos,sin,cos,atan,tan,fabs
+import vefm_259
+from vefm_259 import *
+class geodesic(mesh):
+ def __init__(self,parameters):
+
+ mesh.__init__(self)
+ self.panels = []
+ self.vertsdone = []
+ self.skeleton = [] ## List of verts in the full skeleton edges.
+ self.vertskeleton = [] # config needs this member
+ self.edgeskeleton = [] # config needs this member
+ self.sphericalverts = []
+ self.a45 = pi * 0.25
+ self.a90 = pi * 0.5
+ self.a180 = pi
+ self.a270 = pi * 1.5
+ self.a360 = pi * 2
+#PKHG because of unittest approach for a while the following three lines commentd
+ #self.setparameters(parameters)
+ #self.makegeodesic()
+ #self.connectivity()
+
+ def setparameters(self,parameters):
+ self.frequency = parameters[0] ## How many subdivisions - up to 20.
+ self.eccentricity = parameters[1] ## Elliptical if >1.0.
+ self.squish = parameters[2] ## Flattened if < 1.0.
+ self.radius = parameters[3] ## Exactly what it says.
+ self.square = parameters[4] ## Controls amount of superellipse in X/Y plane.
+ self.squarez = parameters[5] ## Controls amount of superellipse in Z dimension.
+ self.cart = parameters[6] ## Cuts out sphericalisation step.
+ self.shape = parameters[7] ## Full sphere, dome, flatbase.
+ self.baselevel = parameters[8] ## Where the base is cut on a flatbase dome.
+ self.faceshape = parameters[9] ## Triangular, hexagonal, tri-hex.
+ self.dualflag = parameters[10]
+ self.rotxy = parameters[11]
+ self.rotz = parameters[12]
+ self.klass = parameters[13]
+ self.sform = parameters[14]
+ self.super = 0 ## Toggles superellipse.
+ if self.square != 2.0 or self.squarez != 2.0:
+ self.super = 1
+ self.odd = 0 ## Is the frequency odd. It matters for dome building.
+ if self.frequency % 2 != 0:
+ self.odd = 1
+
+ def makegeodesic(self):
+ self.vertedgefacedata() #PKHG only a pass 13okt11
+ self.config() ## Generate all the configuration information.
+ if self.klass:
+ self.class2()
+ if self.faceshape == 1:
+ self.hexify() ## Hexagonal faces
+ elif self.faceshape == 2:
+ self.starify() ## Hex and Triangle faces
+ if self.dualflag:
+ self.dual()
+ if not self.cart:
+ self.sphericalize() ## Convert x,y,z positions into spherical u,v.
+ self.sphere2cartesian() ## Convert spherical uv back into cartesian x,y,z for final shape.
+ for i in range(len( self.verts)):
+ self.verts[i].index = i
+ for edg in self.edges:
+ edg.findvect()
+
+ def vertedgefacedata(self):
+ pass
+
+ def config(self):
+ print("\n========dbg pkhg self.vertskeleton =",self.vertskeleton)
+ for i in range(len(self.vertskeleton)):
+ self.vertskeleton[i].index = i
+ for edges in self.edgeskeleton:
+ s = skeletonrow(self.frequency, edges, 0, self)
+ self.skeleton.append(s)
+ for i in range(len( self.verts)):
+ self.verts[i].index = i
+ for i in range(len(self.panelpoints)):
+ a = self.vertsdone[self.panelpoints[i][0]][1]
+ b = self.vertsdone[self.panelpoints[i][1]][1]
+ c = self.vertsdone[self.panelpoints[i][2]][1]
+ panpoints = [ self.verts[a],
+ self.verts[b],
+ self.verts[c]]
+
+ panedges = [ self.skeleton[self.paneledges[i][0]],
+ self.skeleton[self.paneledges[i][1]],
+ self.skeleton[self.paneledges[i][2]] ]
+
+ reverseflag = 0
+ for flag in self.reversepanel:
+ if flag == i:
+ reverseflag = 1
+ p = panel(panpoints, panedges, reverseflag, self)
+ self.panels.append(p)
+
+ def sphericalize(self):
+ if self.shape == 2:
+ self.cutbasecomp()
+ for vert in(self.verts):
+ x = vert.x
+ y = vert.y
+ z = vert.z
+ u = self.usphericalise(x,y,z)
+ v = self.vsphericalise(x,y,z)
+ self.sphericalverts.append([u,v])
+
+ def sphere2cartesian(self):
+ for i in range(len(self.verts)):
+ if self.cart:
+ x = self.verts[i].x * self.radius * self.eccentricity
+ y = self.verts[i].y * self.radius
+ z = self.verts[i].z * self.radius * self.squish
+ else:
+ u = self.sphericalverts[i][0]
+ v = self.sphericalverts[i][1]
+ if self.squish != 1.0 or self.eccentricity>1.0:
+ scalez = 1 / self.squish
+ v = self.ellipsecomp(scalez,v)
+ u = self.ellipsecomp(self.eccentricity,u)
+ if self.super:
+ r1 = self.superell(self.square,u,self.rotxy)
+ r2 = self.superell(self.squarez,v,self.rotz)
+ else:
+ r1 = 1.0
+ r2 = 1.0
+
+ # print "sform",self.sform," u",u," v",v
+ if self.sform[12]:
+
+ r1 = r1 * self.superform(self.sform[0],self.sform[1],self.sform[2],self.sform[3],self.sform[14] + u,self.sform[4],self.sform[5],self.sform[16] * v)
+ if self.sform[13]:
+
+ r2 = r2 * self.superform(self.sform[6],self.sform[7],self.sform[8],self.sform[9],self.sform[15] + v,self.sform[10],self.sform[11],self.sform[17] * v)
+ x,y,z = self.cartesian(u,v,r1,r2)
+ self.verts[i].x = x
+ self.verts[i].y = y
+ self.verts[i].z = z
+
+ def usphericalise(self,x,y,z):
+ if y == 0.0:
+ if x>0:
+ theta = 0.0
+ else:
+ theta = self.a180
+ elif x == 0.0:
+ if y>0:
+ theta = self.a90
+ else:
+ theta = self.a270
+
+ else:
+ theta = atan(y / x)
+ if x < 0.0 and y < 0.0:
+ theta = theta + self.a180
+ elif x < 0.0 and y>0.0:
+ theta = theta + self.a180
+ u = theta
+ return u
+
+ def vsphericalise(self,x,y,z) :
+ if z == 0.0:
+ phi = self.a90
+ else:
+ rho = sqrt(x ** 2 + y**2 + z**2)
+ phi = acos(z / rho)
+ v = phi
+ return v
+ def ellipsecomp(self,efactor,theta):
+ if theta == self.a90:
+ result = self.a90
+ elif theta == self.a270:
+ result = self.a270
+ else:
+
+ result = atan(tan(theta) / efactor**0.5)
+ if result>=0.0:
+ x = result
+ y = self.a180 + result
+ if fabs(x - theta) <= fabs(y - theta):
+ result = x
+ else:
+ result = y
+ else:
+ x = self.a180 + result
+ y = result
+
+ if fabs(x - theta) <= fabs(y - theta):
+ result = x
+ else:
+ result = y
+ return result
+ def cutbasecomp(self):
+ pass
+
+ def cartesian(self,u,v,r1,r2):
+ x = r1 * cos(u) * r2 * sin(v) * self.radius * self.eccentricity
+ y = r1 * sin(u) * r2 * sin(v) * self.radius
+ z = r2 * cos(v) * self.radius * self.squish
+ return x,y,z
+# def connectivity(self):
+#
+# self.dovertedge()
+# self.dovertface()
+# self.dofaceedge()
+class edgerow:
+ def __init__(self, count, anchor, leftindex, rightindex, stepvector, endflag, parentgeo):
+ self.points = []
+ self.edges = []
+ ## Make a row of evenly spaced points.
+ for i in range(count + 1):
+ if i == 0:
+ self.points.append(leftindex)
+ elif i == count and not endflag:
+ self.points.append(rightindex)
+ else:
+ newpoint = anchor + (stepvector * i)
+ vertcount = len(parentgeo.verts)
+ self.points.append(vertcount)
+ newpoint.index = vertcount
+ parentgeo.verts.append(newpoint)
+ for i in range(count):
+ a = parentgeo.verts[self.points[i]]
+ b = parentgeo.verts[self.points[i + 1]]
+ line = edge(a,b)
+ self.edges.append(len(parentgeo.edges))
+ parentgeo.edges.append(line)
+class skeletonrow:
+ def __init__(self, count, skeletonedge, shortflag, parentgeo):
+ self.points = []
+ self.edges = []
+ self.vect = skeletonedge.vect
+ self.step = skeletonedge.vect / float(count)
+ ## Make a row of evenly spaced points.
+ for i in range(count + 1):
+ vert1 = skeletonedge.a
+ vert2 = skeletonedge.b
+ if i == 0:
+ if parentgeo.vertsdone[vert1.index][0]:
+ self.points.append(parentgeo.vertsdone[vert1.index][1])
+ else:
+ newpoint = vertex((vert1.x, vert1.y, vert1.z))
+ vertcount = len(parentgeo.verts)
+ self.points.append(vertcount)
+ newpoint.index = vertcount
+ parentgeo.vertsdone[vert1.index] = [1,vertcount]
+ parentgeo.verts.append(newpoint)
+
+ elif i == count:
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-extensions-cvs
mailing list