def getAxis2AxisRotation(a0, a1): """Given 2 vectors return the rotation that is needed to transfer 1 into the other. """ # TODO: how to know which angle is taken (if you switch the axes, will you # still have to correct angle and axis?) vec3Type = type(GeomTypes.Vec3([0, 0, 0])) assert (type(a0) == vec3Type) and (type(a1) == vec3Type) if a0 == a1: # if both axis are in fact the same no roation is needed axis = GeomTypes.uz angle = 0 if a0 == -a1: # if one axis should be rotated in its opposite axis, handle # separately, since the cross product will not work. # rotate pi around any vector that makes a straight angle with a0 a2 = GeomTypes.Vec3([i + 0.5 for i in a1]) angle = math.pi axis = a2.cross(a0) else: a_0 = a0.normalize() a_1 = a1.normalize() n = a_0 * a_1 # because of floats there might be some rounding problems: n = min(n, 1.0) n = max(n, -1.0) angle = math.acos(n) axis = a_0.cross(a_1) return axis, angle
def __init__(this, *args, **kwargs): t1 = Rot(axis=vec(0, 0, 1), angle=GeomTypes.turn(0.2)) t2 = Rot(axis=vec(0, 0, 1), angle=GeomTypes.turn(0.4)) t3 = Rot(axis=vec(0, 0, 1), angle=GeomTypes.turn(0.6)) t4 = Rot(axis=vec(0, 0, 1), angle=GeomTypes.turn(0.8)) h0 = HalfTurn(vec(0, 1, tau)) Heptagons.EqlHeptagonShape.__init__( this, directIsometries=[ GeomTypes.E, t1, t2, t3, t4, h0, h0 * t1, h0 * t2, h0 * t3, h0 * t4, t1 * h0, t1 * h0 * t1, t1 * h0 * t2, t1 * h0 * t3, t1 * h0 * t4, t2 * h0, t2 * h0 * t1, t2 * h0 * t2, t2 * h0 * t3, t2 * h0 * t4, t3 * h0, t3 * h0 * t1, t3 * h0 * t2, t3 * h0 * t3, t3 * h0 * t4, t4 * h0, t4 * h0 * t1, t4 * h0 * t2, t4 * h0 * t3, t4 * h0 * t4 ], # abuse the opposite isometry (even though this is not an opposite # isometry really) But for historical reasons I used a half turn # here to prevent edges to be drawn twice. #oppositeIsometry = GeomTypes.I, oppositeIsometry=GeomTypes.Hx, name='EglHeptA5xI_GD') this.initArrs() this.setH(H0) this.setViewSettings(edgeR=0.01, vertexR=0.02)
def setVertexProperties(this, dictPar=None, **kwargs): """ Set the vertices and how/whether vertices are drawn in OpenGL. Accepted are the optional (keyword) parameters: - Vs, - radius, - color. - Ns. Either these parameters are specified as part of kwargs or as key value pairs in the dictionary dictPar. If they are not specified (or equal to None) they are not changed. See getVertexProperties for the explanation of the keywords. The output of getVertexProperties can be used as the dictPar parameter. This can be used to copy settings from one shape to another. If dictPar is used and kwargs, then only the dictPar will be used. """ if this.dbgTrace: print '%s.setVertexProperties(%s,..):' % (this.__class__, this.name) if dictPar != None or kwargs != {}: if dictPar != None: dict = dictPar else: dict = kwargs if 'Vs' in dict and dict['Vs'] != None: this.Vs = [GeomTypes.Vec4(v) for v in dict['Vs']] if 'Ns' in dict and dict['Ns'] != None: this.Ns = [GeomTypes.Vec4(n) for n in dict['Ns']] #assert len(this.Ns) == len(this.Vs) if 'radius' in dict and dict['radius'] != None: this.v.radius = dict['radius'] if 'color' in dict and dict['color'] != None: this.v.col = dict['color'] this.projectedTo3D = False
def __init__(this, *args, **kwargs): t1 = Rot(axis = vec(0, 0, 1), angle = GeomTypes.turn(0.2)) t2 = Rot(axis = vec(0, 0, 1), angle = GeomTypes.turn(0.4)) t3 = Rot(axis = vec(0, 0, 1), angle = GeomTypes.turn(0.6)) t4 = Rot(axis = vec(0, 0, 1), angle = GeomTypes.turn(0.8)) h0 = HalfTurn(vec(0, 1, tau)) Heptagons.EqlHeptagonShape.__init__(this, directIsometries = [ GeomTypes.E, t1, t2, t3, t4, h0, h0*t1, h0*t2, h0*t3, h0*t4, t1*h0, t1*h0*t1, t1*h0*t2, t1*h0*t3, t1*h0*t4, t2*h0, t2*h0*t1, t2*h0*t2, t2*h0*t3, t2*h0*t4, t3*h0, t3*h0*t1, t3*h0*t2, t3*h0*t3, t3*h0*t4, t4*h0, t4*h0*t1, t4*h0*t2, t4*h0*t3, t4*h0*t4 ], # abuse the opposite isometry (even though this is not an opposite # isometry really) But for historical reasons I used a half turn # here to prevent edges to be drawn twice. #oppositeIsometry = GeomTypes.I, oppositeIsometry = GeomTypes.Hx, name = 'EglHeptA5xI_GD' ) this.initArrs() this.setH(H0) this.setViewSettings(edgeR = 0.01, vertexR = 0.02)
def xy2SphereV(x, y, w, h, R2): x, y = x - width / 2, height / 2 - y l2 = x * x + y * y if l2 < R2: spherePos = GeomTypes.Vec3([x, y, math.sqrt(R2 - l2)]) elif l2 > R2: scale = math.sqrt(R2 / l2) spherePos = GeomTypes.Vec3([scale * x, scale * y, 0]) else: # probably never happens (floats) spherePos = GeomTypes.Vec3([x, y, 0]) return spherePos
def updateOrientation(this): v = this.showGui[this.__AxisGuiIndex].GetVertex() if v == GeomTypes.Vec3([0, 0, 0]): rot = GeomTypes.E this.statusText( 'Rotation axis is the null-vector: applying identity', LOG_INFO) else: rot = GeomTypes.Rot3(axis=v, angle=Geom3D.Deg2Rad * this.currentAngle) try: this.shape.setBaseOrientation(rot) except AttributeError: this.statusText( 'Apply symmetry first, before pulling the slide-bar', LOG_WARN)
def rotateInStdPlane(this, plane, angle, successive=False): """ Rotate in a plane defined by 2 coordinate axes. plane: one of Plane.XY, Plane.XZ, Plane.XW, Plane.YZ, Plane.YW, Plane.ZW angle: the angle in radials in counter-clockwise direction, while the Plane.PQ has a horizontal axis P pointing to the right and a vertical axis Q pointing up. successive: specify if this is applied on any previous transform, i.e. if this is not a new transforma. """ q0 = None if Axis.X & plane: q0 = Vec4([1, 0, 0, 0]) if Axis.Y & plane: if q0 == None: q0 = Vec4([0, 1, 0, 0]) else: q1 = Vec4([0, 1, 0, 0]) if Axis.Z & plane: if q0 == None: q0 = Vec4([0, 0, 1, 0]) else: q1 = Vec4([0, 0, 1, 0]) if Axis.W & plane: q1 = Vec4([0, 0, 0, 1]) r = GeomTypes.Rot4(axialPlane=(q0, q1), angle=angle) if not successive or this.rot4 == None: this.rot4 = r else: this.rot4 = r * this.rot4 this.projectedTo3D = False
def OnPaint(this, event): if this.dbgTrace: print 'Interactive3DCanvas.OnPaint(this,..):' def xy2SphereV(x, y, w, h, R2): x, y = x - width / 2, height / 2 - y l2 = x * x + y * y if l2 < R2: spherePos = GeomTypes.Vec3([x, y, math.sqrt(R2 - l2)]) elif l2 > R2: scale = math.sqrt(R2 / l2) spherePos = GeomTypes.Vec3([scale * x, scale * y, 0]) else: # probably never happens (floats) spherePos = GeomTypes.Vec3([x, y, 0]) return spherePos dc = wx.PaintDC(this) this.SetCurrent(this.context) if not this.init: this.initGl() this.init = True this.Moriginal = glGetDoublev(GL_MODELVIEW_MATRIX) glPushMatrix() this.onPaint() glPopMatrix() if this.xOrg != 0 or this.yOrg != 0: viewPort = glGetIntegerv(GL_VIEWPORT) height = viewPort[3] - viewPort[1] width = viewPort[2] - viewPort[0] D = min(width, height) R2 = float(D * D) / 4 R2 = this.rScale * this.rScale * R2 newSpherePos = xy2SphereV(this.x, this.y, width, height, R2) orgSphere = xy2SphereV(this.xOrg, this.yOrg, width, height, R2) ax, an = getAxis2AxisRotation(orgSphere, newSpherePos) this.movingRepos = GeomTypes.Rot3(axis=ax, angle=an) * this.modelRepos glLoadMatrixd(this.Moriginal) glScalef(this.currentScale, this.currentScale, this.currentScale) save, GeomTypes.eqFloatMargin = GeomTypes.eqFloatMargin, 1.0e-14 angle = Geom3D.Rad2Deg * this.movingRepos.angle() axis = this.movingRepos.axis() GeomTypes.eqFloatMargin = save #print 'rotate', angle, axis glRotatef(angle, axis[0], axis[1], axis[2]) if this.z != this.zBac: dZ = this.z - this.zBac # map [min, max] onto [0, 2] # dZ' = (2/(max-min)) dZ + 1 #pStr = '%f ->' % dZ dZ = dZ * this.zScaleFactor + 1.0 this.currentScale = dZ * this.currentScale #print '%s %f' % (pStr, dZ) glScalef(dZ, dZ, dZ) glFlush() this.SwapBuffers()
def onFloat(this, e): #ctrlId = e.GetId() vEvent = VectorUpdatedEvent(myEVT_VECTOR_UPDATED, this.GetId()) vEvent.SetEventObject(this) vEvent.SetVector( GeomTypes.Vec4([ this.__v[0].GetValue(), this.__v[1].GetValue(), this.__v[2].GetValue(), this.__v[3].GetValue() ])) this.__v[this.__ctrlIdIndex].GetEventHandler().ProcessEvent(vEvent)
def __init__(this, *args, **kwargs): this.atanHV2 = Geom3D.Rad2Deg * math.atan(1/V2) Heptagons.EqlHeptagonShape.__init__(this, directIsometries = [ GeomTypes.E, Rot(angle = GeomTypes.turn(0.25), axis = GeomTypes.uz), Rot(angle = GeomTypes.turn(0.50), axis = GeomTypes.uz), Rot(angle = GeomTypes.turn(0.75), axis = GeomTypes.uz) ], # abuse the opposite isometry (even though this is not an opposite # isometry really) But for historical reasons I used a half turn # here to prevent edges to be drawn twice. #oppositeIsometry = GeomTypes.I, oppositeIsometry = halfTurn, name = 'EglHeptS4xI' ) this.initArrs() this.setH(1.0) this.setViewSettings(edgeR = 0.02, vertexR = 0.04)
def GetSelected(this): """returns a symmetry instance""" sym = this.getSymmetryClass(applyOrder=False) setup = {} for i, gui in zip(range(len(this.oriGuis)), this.oriGuis): inputType = sym.initPars[i]['type'] if inputType == 'vec3': v = gui.GetVertex() if v != GeomTypes.Vec3([0, 0, 0]): setup[sym.initPars[i]['par']] = v elif inputType == 'int': v = gui.GetValue() setup[sym.initPars[i]['par']] = v #print 'GetSelected; setup:', setup #print 'class:', sym sym = sym(setup=setup) return sym
import Geom3D import GeomTypes import math Vs = [ GeomTypes.Vec3([ 1, 1, 1]), GeomTypes.Vec3([-1, 1, 1]), GeomTypes.Vec3([-1, -1, 1]), GeomTypes.Vec3([ 1, -1, 1]), GeomTypes.Vec3([ 1, 1, -1]), GeomTypes.Vec3([-1, 1, -1]), GeomTypes.Vec3([-1, -1, -1]), GeomTypes.Vec3([ 1, -1, -1]), GeomTypes.Vec3([ 1, 1, -2]), GeomTypes.Vec3([.5, 1, 1]), ] Fs = [ [0, 4, 8], # just a line [0, 9, 1, 2, 3],# first part on line, cannot be used to calc face normal [0, 3, 7, 4], [1, 0, 4, 5], [2, 1, 5, 6], [3, 2, 6, 7], [7, 6, 5, 4] ] shape = Geom3D.SimpleShape(Vs = Vs, Fs = Fs)
# along with this program; if not, # check at http://www.gnu.org/licenses/old-licenses/gpl-2.0.html # or write to the Free Software Foundation, #-------------------------------------------------------------------- import wx import math import rgb import Heptagons import GeomTypes import Geom3D import Scenes3D Title = 'Equilateral Heptagons Tetrahedron' vec = lambda x, y, z: GeomTypes.Vec3([x, y, z]) V2 = math.sqrt(2) hV2 = 1.0/V2 tV3 = 1.0/math.sqrt(3) class Shape(Heptagons.EqlHeptagonShape): def __init__(this): Heptagons.EqlHeptagonShape.__init__(this, directIsometries = [ GeomTypes.E, GeomTypes.Hx, GeomTypes.Hy, GeomTypes.Hz ], name = 'EglHeptS4A4'
import GeomTypes import Geom3D import isometry shape = Geom3D.IsometricShape( Vs = [ GeomTypes.Vec3([1.0, 1.0, 1.0]), GeomTypes.Vec3([-1.0, 1.0, 1.0]), GeomTypes.Vec3([-1.0, -1.0, 1.0]), GeomTypes.Vec3([1.0, -1.0, 1.0]), GeomTypes.Vec3([1.0, 1.0, -1.0]), GeomTypes.Vec3([-1.0, 1.0, -1.0]), GeomTypes.Vec3([-1.0, -1.0, -1.0]), GeomTypes.Vec3([1.0, -1.0, -1.0]) ], Fs = [ [0, 1, 2, 3], [0, 3, 7, 4], [1, 0, 4, 5], [2, 1, 5, 6], [3, 2, 6, 7], [7, 6, 5, 4] ], Es = [0, 1, 1, 2, 2, 3, 0, 3, 3, 7, 4, 7, 0, 4, 4, 5, 1, 5, 5, 6, 2, 6, 6, 7], colors = [ ([[0.99609400000000003, 0.83984400000000003, 0.0]], []), ([[0.13281200000000001, 0.54296900000000003, 0.13281200000000001]], []), ([[0.54296900000000003, 0.0, 0.0]], []), ([[0.0, 0.74609400000000003, 0.99609400000000003]], []), ([[0.54296900000000003, 0.0, 0.0]], []), ([[0.13281200000000001, 0.54296900000000003, 0.13281200000000001]], []), ([[0.0, 0.74609400000000003, 0.99609400000000003]], []),
import GeomTypes import Geom3D import isometry shape = Geom3D.CompoundShape(simpleShapes=[ Geom3D.SimpleShape(Vs=[ GeomTypes.Vec3([1.0, 1.0, 1.0]), GeomTypes.Vec3([-1.0, 1.0, 1.0]), GeomTypes.Vec3([-1.0, -1.0, 1.0]), GeomTypes.Vec3([1.0, -1.0, 1.0]), GeomTypes.Vec3([1.0, 1.0, -1.0]), GeomTypes.Vec3([-1.0, 1.0, -1.0]), GeomTypes.Vec3([-1.0, -1.0, -1.0]), GeomTypes.Vec3([1.0, -1.0, -1.0]), GeomTypes.Vec3([1.0, 1.0, -2.0]), GeomTypes.Vec3([0.5, 1.0, 1.0]) ], Fs=[[0, 1, 2, 3], [0, 3, 7, 4], [1, 0, 4, 5], [2, 1, 5, 6], [3, 2, 6, 7], [7, 6, 5, 4]], Es=[], colors=([[0.99609400000000003, 0.0, 0.0]], [0, 0, 0, 0, 0, 0]), name="SimpleShape"), Geom3D.SimpleShape(Vs=[ GeomTypes.Vec3([0.0, 0.0, 2.0]), GeomTypes.Vec3([2.0, 0.0, 0.0]), GeomTypes.Vec3([0.0, 2.0, 0.0]), GeomTypes.Vec3([-2.0, 0.0, 0.0]), GeomTypes.Vec3([0.0, -2.0, 0.0]), GeomTypes.Vec3([0.0, 0.0, 2.0]) ], Fs=[[0, 1, 2], [0, 2, 3], [0, 3, 4], [0, 4, 1],
def glDrawSingleRemoveUnscaledEdges(this): isScaledDown = not Geom3D.eq(this.c.scale, 1.0, margin=0.001) if not this.projectedTo3D: # print 'reprojecting...' try: del this.cell except AttributeError: pass Ns3D = [] if this.rot4 != None: Vs4D = [this.rot4 * v for v in this.Vs] # TODO fix Ns.. if needed.. # if this.Ns != []:cleanUp # Ns4D = [this.rot4*n for n in this.Ns] else: Vs4D = [v for v in this.Vs] Vs3D = this.projectVsTo3D(Vs4D) #for i in range(0, len(this.Es), 2): # v0 = Vs4D[this.Es[i]] # v1 = Vs4D[this.Es[i+1]] # print 'delta v:', v0 - v1 # print 'Edge [%d, %d]; len:' % (this.Es[i], this.Es[i+1]), (v1-v0).length() #if this.Ns != []: # Ns3D = this.projectVsTo3D(Ns4D) # Now project all to one 3D shape. 1 3D shape is chosen, instean of # projecting each cell to one shape because of different reasons: # - when drawing transparent faces all the opaqe fae should be # drawn first. # - if drawing the cells per shape, the glVertexPointer should be # called for each cell. (Currently SimpleShape will not call this # function unless the vertices have been changed... shapeVs = [] shapeEs = [] shapeFs = [] shapeColIndices = [] if this.c.draw: shapeCols = this.c.col[0] else: shapeCols = this.f.col[0] if this.removeTransparency: shapeCols = [c[0:3] for c in shapeCols] if this.e.draw and (not isScaledDown or this.e.showUnscaled): shapeVs = Vs3D shapeEs = this.Es # Add a shape with faces for each cell for i in xrange(len(this.Cs)): # use a copy, since we will filter (v indices will change): cellFs = [f[:] for f in this.Cs[i]] if this.c.draw: shapeColIndices.extend([this.c.col[1][i] for f in cellFs]) else: shapeColIndices.extend(this.f.col[1][i]) # Now cleanup Vs3D # TODO # if this.e.draw and (not isScaledDown or this.e.showUnscaled): # Then shapeVs = Vs3D already, and the code below is all # unecessary. cellVs = Vs3D[:] nrUsed = glue.cleanUpVsFs(cellVs, cellFs) # Now attaching to current Vs, will change index: offset = len(shapeVs) cellFs = [[vIndex + offset for vIndex in f] for f in cellFs] # Now scale from gravitation centre: if isScaledDown: g = GeomTypes.Vec3([0, 0, 0]) sum = 0 for vIndex in range(len(cellVs)): g = g + nrUsed[vIndex] * GeomTypes.Vec3(cellVs[vIndex]) sum = sum + nrUsed[vIndex] if sum != 0: g = g / sum #print this.name, 'g:', g cellVs = [ this.c.scale * (GeomTypes.Vec3(v) - g) + g for v in cellVs ] shapeVs.extend(cellVs) shapeFs.extend(cellFs) # for shapeColIndices.extend() see above this.cell = Geom3D.SimpleShape( shapeVs, shapeFs, shapeEs, [], # Vs , Fs, Es, Ns (shapeCols, shapeColIndices), name='%s_projection' % (this.name)) this.cell.setVertexProperties(radius=this.v.radius, color=this.v.col) this.cell.setEdgeProperties(radius=this.e.radius, color=this.e.col, drawEdges=this.e.draw) this.cell.setFaceProperties(drawFaces=this.f.draw) this.cell.glInitialised = True # done as first step in this func this.projectedTo3D = True this.updateTransparency = False if this.e.draw and isScaledDown: this.cell.recreateEdges() # Don't use, out of performance issues: # cellEs = this.cell.getEdgeProperties()['Es'] # -------------------------- # Bad performance during scaling: # cellEs = this.cell.getEdgeProperties()['Es'] # this.cell.recreateEdges() # cellEs.extend(this.cell.getEdgeProperties()['Es']) # -------end bad perf--------- cellEs = this.cell.Es if this.e.showUnscaled: cellEs.extend(this.Es) this.cell.setEdgeProperties(Es=cellEs) if this.updateTransparency: cellCols = this.cell.getFaceProperties()['colors'] if this.removeTransparency: shapeCols = [c[0:3] for c in cellCols[0]] else: if this.c.draw: shapeCols = this.c.col[0] else: shapeCols = this.f.col[0] cellCols = (shapeCols, cellCols[1]) this.cell.setFaceProperties(colors=cellCols) this.updateTransparency = False
def setV(this): Vt = [0, this.top, 0] Vb = [0, -this.tail, 0] Vl = [-this.side, 0, 0] Vr = [this.side, 0, 0] tuple = Heptagons.Kite2Hept(Vl, Vt, Vr, Vb) if tuple == None: return h0, h1, h2, h3, h4, h5, h6 = tuple[0] # # 3 0' # # # 6' 1' # # # 2 + 0 # # 5' 2' # # # # 4' 3' # # # 1 # this.kiteVs = [ GeomTypes.Vec3([Vr[0], Vr[1], Vr[2]]), GeomTypes.Vec3([Vb[0], Vb[1], Vb[2]]), GeomTypes.Vec3([Vl[0], Vl[1], Vl[2]]), GeomTypes.Vec3([Vt[0], Vt[1], Vt[2]]) ] d = 1e-4 this.heptaVs = [ GeomTypes.Vec3([Vt[0], Vt[1], Vt[2] + d]), GeomTypes.Vec3([h1[0], h1[1], h1[2] + d]), GeomTypes.Vec3([h2[0], h2[1], h2[2] + d]), GeomTypes.Vec3([h3[0], h3[1], h3[2] + d]), GeomTypes.Vec3([h4[0], h4[1], h4[2] + d]), GeomTypes.Vec3([h5[0], h5[1], h5[2] + d]), GeomTypes.Vec3([h6[0], h6[1], h6[2] + d]) ] # try to set the vertices array. # the failure occurs at init since showKite and showHepta don't exist try: Vs = [] print 'this.showKite', this.showKite, 'this.showHepta', this.showHepta if this.showKite: Vs.extend(this.kiteVs) if this.showHepta: Vs.extend(this.heptaVs) for v in Vs: print v print '===============' this.setVertexProperties(Vs=Vs) except AttributeError: pass
T64: '64 Triangles', } def Vlen(v0, v1): x = v1[0] - v0[0] y = v1[1] - v0[1] z = v1[2] - v0[2] return (math.sqrt(x * x + y * y + z * z)) # get the col faces array by using a similar shape here, so it is calculated # only once useIsom = isometry.A4() egShape = Geom3D.IsometricShape(Vs=[ GeomTypes.Vec3([0, 0, 1]), GeomTypes.Vec3([0, 1, 1]), GeomTypes.Vec3([1, 1, 1]) ], Fs=[[0, 1, 2]], directIsometries=useIsom, unfoldOrbit=True) #colStabiliser = isometry.C2(setup = {'axis': [0.0, 1.0, 0.0]}) #colStabiliser = isometry.C2(setup = {'axis': [0.0, 0.0, 1.0]}) useSimpleColours = False colStabiliser = isometry.C2(setup={'axis': [1.0, 0.0, 0.0]}) colQuotientSet = useIsom / colStabiliser if useSimpleColours: useRgbCols = [ rgb.gray95, rgb.gray80,
def __init__(this, v0, v1, v2): this.v = [GeomTypes.Vec3(v0), GeomTypes.Vec3(v1), GeomTypes.Vec3(v2)] this.N = None
def GetValue(this): return GeomTypes.Vec4([ this.__v[0].GetValue(), this.__v[1].GetValue(), this.__v[2].GetValue(), this.__v[3].GetValue() ])
import GeomTypes import Geom3D import isometry shape = Geom3D.IsometricShape( Vs=[ GeomTypes.Vec3([1.0, 1.0, 1.0]), GeomTypes.Vec3([-1.0, 1.0, 1.0]), GeomTypes.Vec3([-1.0, -1.0, 1.0]), GeomTypes.Vec3([1.0, -1.0, 1.0]), GeomTypes.Vec3([1.0, 1.0, -1.0]), GeomTypes.Vec3([-1.0, 1.0, -1.0]), GeomTypes.Vec3([-1.0, -1.0, -1.0]), GeomTypes.Vec3([1.0, -1.0, -1.0]), ], Fs=[ [0, 1, 2, 3], [0, 3, 7, 4], [1, 0, 4, 5], [2, 1, 5, 6], [3, 2, 6, 7], [7, 6, 5, 4], ], Es=[ 0, 1, 1, 2, 2, 3, 0, 3, 3, 7, 4, 7, 0, 4, 4, 5, 1, 5, 5, 6, 2, 6, 6, 7 ], colors=[ ([[0.99609400000000003, 0.83984400000000003, 0.0]], []), ([[0.13281200000000001, 0.54296900000000003, 0.13281200000000001]], []), ([[0.54296900000000003, 0.0, 0.0]], []), ([[0.0, 0.74609400000000003, 0.99609400000000003]], []),
def Vlen(v0, v1): x = v1[0] - v0[0] y = v1[1] - v0[1] z = v1[2] - v0[2] return (math.sqrt(x * x + y * y + z * z)) V2 = math.sqrt(2) V3 = math.sqrt(3) V5 = math.sqrt(5) tau = (1.0 + V5) / 2 tau2 = tau + 1 dtau = 1.0 / tau isomA5 = isometry.A5() o5axis = GeomTypes.Vec([1, 0, tau]) o5fld = Rot(axis=o5axis, angle=GeomTypes.turn(1.0 / 5)) _o5fld = Rot(axis=o5axis, angle=GeomTypes.turn(-1.0 / 5)) isomO5 = isometry.C5(setup={'axis': o5axis}) o3axis = GeomTypes.Vec([0, dtau, tau]) o3fld = Rot(axis=o3axis, angle=GeomTypes.tTurn) isomO3 = isometry.C3(setup={'axis': o3axis}) # get the col faces array by using a similar shape here, so it is calculated # only once colStabilisers = [ isometry.A4(setup={ 'o2axis0': [1.0, 0.0, 0.0], 'o2axis1': [0.0, 0.0, 1.0], }),
def Vlen(v0, v1): x = v1[0] - v0[0] y = v1[1] - v0[1] z = v1[2] - v0[2] return (math.sqrt(x*x + y*y + z*z)) V2 = math.sqrt(2) V3 = math.sqrt(3) V5 = math.sqrt(5) tau = (1.0 + V5)/2 tau2 = tau + 1 dtau = 1.0/tau isomA5 = isometry.A5() o5axis = GeomTypes.Vec([1, 0, tau]) o5fld = Rot(axis = o5axis, angle = GeomTypes.turn(1.0/5)) _o5fld = Rot(axis = o5axis, angle = GeomTypes.turn(-1.0/5)) isomO5 = isometry.C5(setup = {'axis': o5axis}) o3axis = GeomTypes.Vec([0, dtau, tau]) o3fld = Rot(axis = o3axis, angle = GeomTypes.tTurn) isomO3 = isometry.C3(setup = {'axis': o3axis}) # get the col faces array by using a similar shape here, so it is calculated # only once colStabilisers = [ isometry.A4(setup = { 'o2axis0': [1.0, 0.0, 0.0], 'o2axis1': [0.0, 0.0, 1.0], }), isometry.A4(setup = {
only_hepts: 'Just Heptagons', } pos_angle_refl_2 = math.pi/2 def Vlen(v0, v1): x = v1[0] - v0[0] y = v1[1] - v0[1] z = v1[2] - v0[2] return (math.sqrt(x*x + y*y + z*z)) V2 = math.sqrt(2) V3 = math.sqrt(3) hV2 = V2/2 o4_fld_0 = GeomTypes.Vec3([1, 0, 0]) o4_fld_1 = GeomTypes.Vec3([0, 1, 1]) isomS4 = isometry.S4(setup = {'o4axis0': o4_fld_0, 'o4axis1': o4_fld_1}) o4fld = Rot(axis = o4_fld_1, angle = GeomTypes.qTurn) isomO4 = isometry.C4(setup = {'axis': o4_fld_1}) o3axis = GeomTypes.Vec3([1/V3, 0, V2/V3]) o3fld = Rot(axis = o3axis, angle = GeomTypes.tTurn) isomO3 = isometry.C3(setup = {'axis': o3axis}) # get the col faces array by using a similar shape here, so it is calculated # only once colStabilisers = [ isometry.D2(setup = { 'axis_n': [0.0, 0.0, 1.0], 'axis_2': [1.0, 0.0, 0.0],
def GetVertex(this): return GeomTypes.Vec3([ this.__v[0].GetValue(), this.__v[1].GetValue(), this.__v[2].GetValue(), ])
def setV(this): # input this.h St = this.h / (Dtau2 * V3 * this.h - 3) #print 's', St # # 0 # __..--'-_ # 3 -'' . _"- 1 # \ _-' # \ _-' # \-' # 2 # # z y # ^ 7\ # |/ # ---> x # # # The kite above is a 5th of the top face of dodecahedron # standing on 1 face, 2 is a vertex, 1 and 3, centres of two edges # and 0 a face centre. # Vs = [ vec(0.0, 0.0, this.h), # 0 Rl, vec(0.0, -Dtau2 * St, St), vec(-Rl[0], Rl[1], Rl[2]) # 3 ] # add heptagons H = HalfTurn(Vs[3]) this.errorStr = '' if not this.heptPosAlt: Ns = Vs heptN = Heptagons.Kite2Hept(Vs[3], Vs[0], Vs[1], Vs[2]) if heptN == None: this.errorStr = 'No valid equilateral heptagon for this position' return Mr = Rot(axis=GeomTypes.Vec3(Vs[2]), angle=GeomTypes.turn(0.2)) # p is a corner of the pentagon inside the pentagram # p is rotated 1/5th turn to form a triangle # together with 2 corners of the pentagram: # 5 of these triangles will cover the pentagram. # this is easier than finding the centre of the pentagram. v3 = heptN[0][3] v4 = heptN[0][4] p = v3 + (v4 - v3) / tau v = Mr * p if this.triangleAlt: vt = heptN[0][6] xtraEdgeIndex = 15 else: vt = heptN[0][5] xtraEdgeIndex = 14 # A part that will form the regular pentagrams (with overlaps). RegularTrianglePartV = [ heptN[0][3], heptN[0][4], vec(v[0], v[1], v[2]), ] RegularTrianglePartN = Vs[2] # vt is the vertex that will be projected by a half turn on the # third vertex of the isosceles triangle. IsoscelesTriangleV = [heptN[0][5], heptN[0][6], vt] else: heptN = Heptagons.Kite2Hept(Vs[1], Vs[2], Vs[3], Vs[0]) if heptN == None: this.errorStr = 'No valid equilateral heptagon for this position' return if this.triangleAlt: vt = heptN[0][1] xtraEdgeIndex = 14 else: vt = heptN[0][2] xtraEdgeIndex = 15 # One third of regular triangle. RegularTrianglePartV = [ heptN[0][3], heptN[0][4], vec(0, 0, heptN[0][3][2]), ] RegularTrianglePartN = RegularTrianglePartV[2] # vt is the vertex that will be projected by a half turn on the # third vertex of the isosceles triangle. IsoscelesTriangleV = [heptN[0][1], heptN[0][2], vt] if heptN == None: this.errorStr = 'No valid equilateral heptagon for this position' return else: this.errorStr = '' vt = H * vt # rotate vt by a half turn, IsoscelesTriangleV NOT auto updated. IsoscelesTriangleV[2] = vt Vs.extend(heptN[0]) # V4 - V10, the heptagon Vs.extend(RegularTrianglePartV) # V11 - V13 Vs.extend(IsoscelesTriangleV) # V14 - V16 #for V in Vs: print V #h = heptN[1] #Ns = [[-h[0], -h[1], -h[2]] for i in range(11)] Ns = [heptN[1] for i in range(11)] Ns.extend([RegularTrianglePartN for i in range(3)]) IsoscelesTriangleN = Geom3D.Triangle(IsoscelesTriangleV[0], IsoscelesTriangleV[1], IsoscelesTriangleV[2]).normal() Ns.extend([IsoscelesTriangleN for i in range(3)]) this.xtraEs = [] if this.addXtraEdge: this.xtraEs = [xtraEdgeIndex, 16] #this.showBaseOnly = True this.setBaseVertexProperties(Vs=Vs, Ns=Ns) Fs = [] Es = [] colIds = [] if this.showKite: Fs.extend(this.kiteFs) Es.extend(this.kiteEs) colIds.extend(this.kiteColIds) if this.showHepta: Fs.extend(this.heptFs) Es.extend(this.heptEs) colIds.extend(this.heptColIds) if this.showXtra: Fs.extend(this.xtraFs) Es.extend(this.xtraEs) colIds.extend(this.xtraColIds) this.setBaseEdgeProperties(Es=Es) this.setBaseFaceProperties(Fs=Fs, colors=(this.theColors, colIds)) this.Vs = Vs
def setV(this): # input this.h St = this.h / (2*math.sqrt(2*Cq)*this.h - Cq) # # 2 # __..--'-_ # 1 -'' . _"- 3 # \ _-' # \ _-' # \-' # 0 # # z y # ^ 7\ # |/ # ---> x # # # The kite above is a 5th of the top face of dodecahedron # standing on 1 face, 2 is a vertex, 1 and 3, centres of two edges # and 0 a face centre. # Vs = [ vec(0.0, 0.0, this.h), # 0 Rl, vec(0.0, St, St/2), vec(-Rl[0], Rl[1], Rl[2]) # 3 ] # add heptagons H = HalfTurn(Vs[3]) this.errorStr = '' if this.heptPosAlt: Ns = Vs heptN = Heptagons.Kite2Hept(Vs[3], Vs[0], Vs[1], Vs[2]) if heptN == None: this.errorStr = 'No valid equilateral heptagon for this position' return Mr = Rot(axis = GeomTypes.Vec3(Vs[2]), angle = GeomTypes.turn(0.2)) # p is a corner of the pentagon inside the pentagram # p is rotated 1/5th turn to form a triangle # together with 2 corners of the pentagram: # 5 of these triangles will cover the pentagram. # this is easier than finding the centre of the pentagram. v3 = heptN[0][3] v4 = heptN[0][4] p = v3 + (v4 - v3)/tau v = Mr*p if this.triangleAlt: vt = heptN[0][6] xtraEdgeIndex = 15 else: vt = heptN[0][5] xtraEdgeIndex = 14 #print v # A part that will form the regular pentagrams (with overlaps). RegularTrianglePartV = [ heptN[0][3], heptN[0][4], vec(v[0], v[1], v[2]), ] RegularTrianglePartN = Vs[2] # vt is the vertex that will be projected by a half turn on the # third vertex of the isosceles triangle. IsoscelesTriangleV = [ heptN[0][5], heptN[0][6], vt ] else: heptN = Heptagons.Kite2Hept(Vs[1], Vs[2], Vs[3], Vs[0]) if heptN == None: this.errorStr = 'No valid equilateral heptagon for this position' return if this.triangleAlt: vt = heptN[0][1] xtraEdgeIndex = 14 else: vt = heptN[0][2] xtraEdgeIndex = 15 # One third of regular pentagon. RegularTrianglePartV = [ heptN[0][3], heptN[0][4], vec(0, 0, heptN[0][3][2]), ] RegularTrianglePartN = RegularTrianglePartV[2] # vt is the vertex that will be projected by a half turn on the # third vertex of the isosceles triangle. IsoscelesTriangleV = [ heptN[0][1], heptN[0][2], vt ] if heptN == None: this.errorStr = 'No valid equilateral heptagon for this position' return else: this.errorStr = '' # rotate vt by a half turn, IsoscelesTriangleV NOT auto updated. vt = H * vt IsoscelesTriangleV[2] = vt Vs.extend(heptN[0]) # V4 - V10 Vs.extend(RegularTrianglePartV) # V11 - V13 Vs.extend(IsoscelesTriangleV) # V14 - V16 #for V in Vs: print V Ns = [heptN[1] for i in range(11)] Ns.extend([RegularTrianglePartN for i in range(3)]) IsoscelesTriangleN = Geom3D.Triangle( IsoscelesTriangleV[0], IsoscelesTriangleV[1], IsoscelesTriangleV[2] ).normal() Ns.extend([IsoscelesTriangleN for i in range(3)]) this.xtraEs = [] if this.addXtraEdge: this.xtraEs = [xtraEdgeIndex, 16] #this.showBaseOnly = True this.setBaseVertexProperties(Vs = Vs, Ns = Ns) Fs = [] Es = [] colIds = [] if this.showKite: Fs.extend(this.kiteFs) Es.extend(this.kiteEs) colIds.extend(this.kiteColIds) if this.showHepta: Fs.extend(this.heptFs) Es.extend(this.heptEs) colIds.extend(this.heptColIds) if this.showXtra: Fs.extend(this.xtraFs) Es.extend(this.xtraEs) colIds.extend(this.xtraColIds) this.setBaseEdgeProperties(Es = Es) this.setBaseFaceProperties(Fs = Fs, colors = (this.theColors, colIds)) this.Vs = Vs
def getVector(this, i): return GeomTypes.Vec3([ this.__v[i][0].GetValue(), this.__v[i][1].GetValue(), this.__v[i][2].GetValue(), ])
import Geom3D import GeomTypes import math Vs = [ GeomTypes.Vec3([ 1, 1, 1]), GeomTypes.Vec3([-1, 1, 1]), GeomTypes.Vec3([-1, -1, 1]), GeomTypes.Vec3([ 1, -1, 1]), GeomTypes.Vec3([ 1, 1, -1]), GeomTypes.Vec3([-1, 1, -1]), GeomTypes.Vec3([-1, -1, -1]), GeomTypes.Vec3([ 1, -1, -1]), GeomTypes.Vec3([ 1, 1, -2]), GeomTypes.Vec3([.5, 1, 1]), ] Fs = [ [0, 1, 2, 3], [0, 3, 7, 4], [1, 0, 4, 5], [2, 1, 5, 6], [3, 2, 6, 7], [7, 6, 5, 4] ] shape0 = Geom3D.SimpleShape(Vs = Vs, Fs = Fs) Vs = [ GeomTypes.Vec3([ 0, 0, 2]), GeomTypes.Vec3([ 2, 0, 0]),
import GeomTypes import Geom3D import isometry shape = Geom3D.SimpleShape(Vs=[ GeomTypes.Vec3([1.0, 1.0, 1.0]), GeomTypes.Vec3([-1.0, 1.0, 1.0]), GeomTypes.Vec3([-1.0, -1.0, 1.0]), GeomTypes.Vec3([1.0, -1.0, 1.0]), GeomTypes.Vec3([1.0, 1.0, -1.0]), GeomTypes.Vec3([-1.0, 1.0, -1.0]), GeomTypes.Vec3([-1.0, -1.0, -1.0]), GeomTypes.Vec3([1.0, -1.0, -1.0]), GeomTypes.Vec3([1.0, 1.0, -2.0]), GeomTypes.Vec3([0.5, 1.0, 1.0]) ], Fs=[[0, 4, 8], [0, 9, 1, 2, 3], [0, 3, 7, 4], [1, 0, 4, 5], [2, 1, 5, 6], [3, 2, 6, 7], [7, 6, 5, 4]], Es=[], colors=([[0.99609400000000003, 0.0, 0.0]], [0, 0, 0, 0, 0, 0, 0]), name="SimpleShape")