def test_plant(self): i = 3 p,d = vec3(0,0,0),vec3(0,1,0) axiom = 'X' rules = dict([('X','F]{{X}[X}[F{[FX}]X'),('F','FF')]) params = dict(dazimuthal = gtl.rad(25)) realize(i,p,d,axiom,rules,**params)
def aaatest(self): #i = 5 i = 6 p,d = vec3(0,0,0),vec3(0,1,0) axiom = 'X' rules = dict([('X','{[[X}{]X}F]X'),('F','FA'),('A','F')]) #rules = dict([('X','F{[X}{]X}FX'),('F','FF')]) #axiom = 'F' #rules = dict([('F','F{[F}F{]F}F')]) params = dict(dazimuthal = gtl.rad(25.7),drho = 20) pg = dpg.planargraph() for piece in lsy.lgen(p,d,axiom,rules,i,**params): if isinstance(piece,tuple): p1,p2 = piece v1,v2 = pg.fp(p1,10),pg.fp(p2,10) e12 = pg.fe(v1,v2) elif isinstance(piece,vec3):pass py = pym.pgtopy(pg,1)[0] py = pym.bisectb(py) py = pym.smoothxy(py,0.5,2) #py = pym.aggregate(py,2) #ax = pg.plotxy(l = 20) ax = dtl.plot_axes_xy(20) ax = dtl.plot_polygon_xy(py,ax,lw = 3) plt.show()
def quad(self): self.v1 = self.avert(vec3(-1,-1,-1)) self.v2 = self.avert(vec3( 1,-1,-1)) self.v3 = self.avert(vec3( 1, 1,-1)) self.v4 = self.avert(vec3(-1, 1,-1)) self.f1 = self.mesh.aface(self.v1,self.v2,self.v3) self.f2 = self.mesh.aface(self.v1,self.v3,self.v4)
def test_grass(self): i = 5 p,d = vec3(0,0,0),vec3(0,1,0) axiom = 'F' rules = dict([('F','F{[F}F{]F}F')]) params = dict(dazimuthal = gtl.rad(25.7)) realize(i,p,d,axiom,rules,**params)
def test_dragoncurve(self): i = 9 p,d = vec3(0,0,0),vec3(0,1,0) axiom = 'FX' rules = dict([('X','X[YF['),('Y',']FX]Y')]) params = dict(dazimuthal = gtl.rad(90)) realize(i,p,d,axiom,rules,**params)
def subdiv(self,mesh,subdivbnd = True,smooth = True,lockf = None): if lockf is None:lockf = lambda p : False newvs = [] oldvs = list(mesh.ve_rings.keys()) oldes = list(mesh.ef_rings.keys()) for f in list(mesh.fs_mats.keys()): v,w,x = f mp = vec3(0,0,0).com(self.gvps(mesh,f)) px,nx,ux = self.avert(mp) u = mesh.avert(px,nx,ux) newvs.append(u) mesh.sface(u,v,w,x) for u,v in oldes:mesh.fedge(u,v) if smooth: dels = [] for v in oldvs: p = self.pset.ps[v[0]] vns = mesh.mask(0,v,None,None) pns = self.pset.gps((v[0] for v in vns)) alpha = mesh.alphan(len(pns)) sdel = p.tov(vec3(0,0,0).com(pns)).uscl(alpha) dels.append((p,sdel)) for sd in dels: if not lockf(sd[0]): sd[0].trn(sd[1]) if subdivbnd:self.subdivbnd(mesh,smooth,lockf) return newvs
def test_slerp(self): a1,v1 = dpr.PI4,vec3(0,0,1) a2,v2 = dpr.PI,vec3(0,0,1) q1,q2 = quat(1,0,0,0).av(0,v1),quat(1,1,1,0).av(a1,v1) q3 = quat(0,1,0,0).av(a2,v2) self.assertEqual(q1.slerp(q3,0.25),q2) self.assertFalse(q1.slerp(q3,0.25) is q1)
def test_mul(self): a1,v1 = dpr.PI4,vec3(0,0,1) a2,v2 = dpr.threePI4,vec3(0,0,1) q1,q2 = quat(1,0,0,0).av(a1,v1),quat(1,1,1,0).av(a2,v1) q3 = quat(0,1,0,0).av(a1+a2,v2) self.assertTrue(q1.mul(q2) == q3) self.assertFalse(q1.mul(q2) is q1)
def test_rot(self): a1,v1 = dpr.PI4,vec3(0,0,1) a2,v2 = dpr.PI2,vec3(0,0,1) q1,q2 = quat(1,0,0,0).av(a1,v1),quat(1,1,1,0).av(a1,v1) q3 = quat(0,1,0,0).av(a2,v2) self.assertTrue(q1.rot(q2) == q3) self.assertTrue(q1.rot(q2) is q1)
def test_inv(self): a1,v1 = dpr.PI4,vec3(0,0,1) a2,v2 = dpr.threePI4,vec3(0,0,1) q1,q2 = quat(1,0,0,0).av(a1,v1),quat(1,1,1,0).av(a2,v2) self.assertEqual(q1.cp().cnj(),q1.inv()) self.assertEqual(q2.cp().cnj(),q2.inv()) self.assertFalse(q1.inv() is q1)
def test_pythagorastree(self): i = 5 p,d = vec3(0,0,0),vec3(1,0,0) axiom = 'Q' rules = dict([('F','FF'),('Q','F{[Q}]Q')]) params = dict(dazimuthal = numpy.pi/12) realize(i,p,d,axiom,rules,**params)
def test_aface(self): self.v1 = self.avert(vec3(-1,-1,-1)) self.v2 = self.avert(vec3( 1,-1,-1)) self.v3 = self.avert(vec3( 1, 1,-1)) self.v4 = self.avert(vec3(-1, 1,-1)) fx = self.mesh.aface(self.v1,self.v2,self.v3) self.assert_counts(4,3,1)
def test_nrm(self): v1,v2,v3 = vec3(1,0,0),vec3(1,2,5),vec3(10,20,50) self.assertTrue(v1.nrm() == v1) self.assertTrue(v1.nrm() is v1) self.assertTrue(v2.nrm() == v3.nrm()) self.assertFalse(v2.nrm() is v3.nrm()) self.assertFalse(v2.nrm() == v1.nrm())
def test_flp(self): v1,v2 = vec3(-1,-2,-5),vec3(1,2,5) self.assertTrue(v1.flp() == v1) self.assertFalse(v1.cp() == v1.flp()) self.assertTrue(v1.flp() is v1) self.assertFalse(v1.flp() is v2) self.assertTrue(v1.flp() == v2)
def mr(rg,fp,ix): i = rg.vs[ix] ip = i[1]['p'] es = rg.rings[i[0]] oes = rg.orings[i[0]] oec = len(oes) if oec == 0: di = ip.tov(vec3(0,0,0).com(fp)) p2 = ip.cp().trn(di) #p2 = wfp(fp,ip,p2) res = rg.mev(ix,{'p':p2,'l':0},{}) elif oec == 1: op = rg.vs[oes[0]][1]['p'] a = random.choice((-1,1))*numpy.pi/2.0 q = quat(1,0,0,0).av(a,vec3(0,0,1)) p2 = ip.cp().trn(op.tov(ip).rot(q)) p2 = wfp(fp,ip,p2) res = rg.mev(ix,{'p':p2,'l':0},{}) else: for x in range(1,len(oes)): oeas = rg.ea(i[0],oes[x-1],oes[x]) print('oeoeoe',oeas) #rg.vs[oes[0]][1]['p'] #i2,r1 = rg.mev(i1,{'p':p2,'l':0},{}) pdb.set_trace() return res
def atest_tripoly(self): eb = (vec3(-2,-2,0),vec3(2,-2,0),vec3(2,2,0),vec3(-2,2,0)) ibs = () hmin,ref,smo = 1,False,False self.mesh.tripoly(eb,ibs,hmin,ref,smo) pdb.set_trace()
def test_disjoint(self): pset = pointset() self.assertTrue(pset.disjoint(self.pset)) pset.ap(vec3(3,0,0)) self.assertTrue(pset.disjoint(self.pset)) pset.ap(vec3(0,0,0)) self.assertFalse(pset.disjoint(self.pset))
def chunk(b,epsilon,lscl = 1.0,j1 = None,j2 = None,edge = False): if j1 is None:j1 = random.randint(0,len(b)-1) if j2 is None:j2 = j1-1 l = b[j1].d(b[j2])*lscl t = random.uniform(0,2.0*numpy.pi) n = random.randint(3,8) if edge: stamp = b[j1].mid(b[j2]).pring(l/2.0,n) else: stamp = vec3( random.randint(int(l/4),int(l)), random.randint(int(l/4),int(l)), 0).com(b).pring(l/2.0,n) q = quat(1,0,0,0).av(t,vec3(0,0,1)) q.rotps(stamp) if pym.binbxy(stamp,b): return stamp elif pym.bintbxy(b,stamp,col = False,ie = False): nbs = pym.ebixy(b,stamp,epsilon) nbas = [pym.bareaxy(nb) for nb in nbs] nb = nbs[nbas.index(max(nbas))] nb = pym.aggregate(nb,1) if pym.bvalidxy(nb) > 0: return nb else: ax = dtl.plot_axes_xy(200) ax = dtl.plot_polygon_xy(b,ax,col = 'r',lw = 2) ax = dtl.plot_polygon_xy(stamp,ax,col = 'b',lw = 2) plt.show() raise ValueError
def test_axialtree(self): i = 5 p,d = vec3(0,0,0),vec3(0,1,0) axiom = 'X' rules = dict([('X','F{[X}{]X}FX'),('F','FF')]) params = dict(dazimuthal = gtl.rad(25.7)) realize(i,p,d,axiom,rules,**params)
def plotxy(self,fp = None,ax = None): if ax is None:ax = dtl.plot_axes_xy(50) for rmv in self.vs: if rmv is None:continue if rmv[2]['level'] > 0:continue bcol = 'b' if rmv[2]['shaft'] else None rconbs = 0.5 if pym.bccw(rmv[2]['bound']) else -0.5 rconb = pym.contract(rmv[2]['bound'],rconbs) ax = dtl.plot_polygon_xy(rconb,ax,lw = 4,col = bcol) rc = vec3(0,0,0).com(rmv[2]['bound']) rs = str(rmv[0])+','+str(rmv[1]) ax = dtl.plot_point_xy(rc,dtl.plot_point_xy_annotate(rc,ax,rs)) if rmv[1]: for re in rmv[1]: if self.vs[re] is None:continue rt = (rc,vec3(0,0,0).com(self.vs[re][2]['bound'])) ax = dtl.plot_edges_xy(rt,ax,col = 'g') for exit in rmv[2]['exits']: if exit is True: exitp = rc ax = dtl.plot_point_xy(exitp, dtl.plot_point_xy_annotate(exitp,ax,'exit')) else: ax = dtl.plot_point_xy(exit, dtl.plot_point_xy_annotate(exit,ax,'exit')) if not fp is None: ax = dtl.plot_polygon_xy(fp,ax,lw = 2,col = 'r') return ax
def test_sang(self): p1,p2,p3,p4 = vec3(1,1,0),vec3(0,1,0),vec3(0,-1,0),vec3(0,0,1) pn = vec3(0,0,1) self.assertEqual(dpr.isnear(p1.sang(p2,pn), dpr.PI4),1) self.assertEqual(dpr.isnear(p2.sang(p1,pn), dpr.PI4),0) self.assertEqual(dpr.isnear(p2.sang(p1,pn),-dpr.PI4),1) self.assertEqual(dpr.isnear(p2.sang(p3,pn), dpr.PI ),1) self.assertEqual(dpr.isnear(p3.sang(p1,pn),dpr.threePI4),1)
def test_lerp(self): v1,v2 = vec3(0,2,0),vec3(-1,0,1) v3,v4 = vec3(-0.75,0.5,0.75),vec3(0,2,0) self.assertEqual(v1.lerp(v2,0.75),v3) self.assertFalse(v1.lerp(v2,0) is v1) self.assertEqual(v1.lerp(v2,0),v1) self.assertFalse(v1.lerp(v2,1) is v2) self.assertEqual(v1.lerp(v2,1),v2)
def test_spline(self): e = vec3(10,10,1) t1,t2 = vec3(1,0,0),vec3(0,-1,0) pline = self.origin.spline(e,t1,t2,5) ax = dtl.plot_axes(10) ax = dtl.plot_edges(pline,ax,lw = 3,col = 'b') plt.show()
def test_lerp(self): v1, v2 = vec3(0, 2, 0), vec3(-1, 0, 1) v3, v4 = vec3(-0.75, 0.5, 0.75), vec3(0, 2, 0) self.assertEqual(v1.lerp(v2, 0.75), v3) self.assertFalse(v1.lerp(v2, 0) is v1) self.assertEqual(v1.lerp(v2, 0), v1) self.assertFalse(v1.lerp(v2, 1) is v2) self.assertEqual(v1.lerp(v2, 1), v2)
def avert(self,p = None,n = None,u = None): if p is None:p = vec3(0,0,0) if n is None:n = vec3(0,0,1) if u is None:u = self.defuv(p,n) px = self.pset.ap(p) nx = self.nset.ap(n) ux = self.uset.ap(u) return px,nx,ux
def ptob(b,p): x,y,z = vec3(1,0,0),vec3(0,1,0),vec3(0,0,1) bpx,bpy,bpz = x.prjps(b),y.prjps(b),z.prjps(b) bp = vec3( bpx[0]+p.x*(bpx[1]-bpx[0]), bpy[0]+p.y*(bpy[1]-bpy[0]), bpz[0]+p.z*(bpz[1]-bpz[0])) return bp
def test_inneighborhood(self): v1,v2,v3,v4 = vec3(1,1,0),vec3(1,2,0),vec3(1,2,1),vec3(1,1,1) self.assertEqual(v1.inneighborhood(v2,1.00),0) self.assertEqual(v1.inneighborhood(v2,1.01),1) self.assertEqual(v1.inneighborhood(v3,1.00),0) self.assertEqual(v1.inneighborhood(v3,1.01),0) self.assertEqual(v1.inneighborhood(v4,1.00),0) self.assertEqual(v1.inneighborhood(v4,1.01),1)
def atest_binbxy(self): b1 = vec3(0, 0, 0).pring(8, 8) b2 = vec3(0, 0, 0).pring(4, 8) b3 = vec3(8, 0, 0).pring(8, 8) b4 = vec3(16, 0, 0).pring(8, 8) self.assertFalse(pym.binbxy(b1, b2)) self.assertTrue(pym.binbxy(b2, b1)) self.assertFalse(pym.binbxy(b1, b3)) self.assertFalse(pym.binbxy(b1, b4))
def test_cp(self): r1 = ray3(vec3(1, 1, 2), vec3(0, 1, 0)) r2 = ray3(vec3(1, 1, 2), vec3(0, 1, 0)) self.assertTrue(r1 is r1) self.assertFalse(r1 is r1.cp()) self.assertTrue(r1 == r1.cp()) self.assertFalse(r1 is r2) self.assertFalse(r1 is r2.cp()) self.assertTrue(r1 == r2.cp())
def test_dot(self): a1,v1 = dpr.PI4,vec3(0,0,1) a2,v2 = dpr.PI2,vec3(0,1,0) q1,q2 = quat(1,0,0,0).av(a1,v1),quat(1,1,1,0).av(a1,v1) q3 = quat(0,1,0,0).av(a2,v2) q4 = quat(0,1,0,0).av(0,v1) self.assertTrue(dpr.isnear(q1.dot(q2),q1.mag2())) self.assertFalse(dpr.isnear(q1.dot(q3),0)) self.assertTrue(dpr.isnear(q3.dot(q4),q3.w))
def atest_split(self): fp = dbl.block('H', 10, 25, 25) rg = ptg.partitiongraph() bs = pym.bsegsxy(fp[0], vec3(0, -100, 0), vec3(0, 100, 0)) b = fp[0] i1 = rg.av(b=[b, []], p=vec3(0, 0, 0).com(b), l=0) i2 = rg.sv(0, bs[0], bs[1]) rg.plotxy() plt.show()
def test_aps(self): np1 = vec3(0, 4, 0) np2 = vec3(2, -1, 3.2) nps = [np1, np2] nxs = self.pset.aps(nps) for x in range(len(nxs)): nx = nxs[x] self.assertEqual(self.pset.ps[nx], nps[x]) self.assertTrue(self.pset.ps[nx] is nps[x])
def test_fps(self): fp1 = vec3(1, 1, 0) fp2 = vec3(2, 1, 0) x, y = self.pset.fps([fp1, fp2]) self.assertEqual(x, 2) self.assertEqual(y, -1) self.assertFalse(self.pset.ps[x] is fp1) self.assertEqual(self.pset.ps[x], fp1) self.assertFalse(fp2 in self.pset.ps)
def quad(self): gmesh = self.mod.agfxmesh() self.v1 = gmesh.avert(*self.mod.avert(vec3(-1, -1, -1))) self.v2 = gmesh.avert(*self.mod.avert(vec3(1, -1, -1))) self.v3 = gmesh.avert(*self.mod.avert(vec3(1, 1, -1))) self.v4 = gmesh.avert(*self.mod.avert(vec3(-1, 1, -1))) self.f1 = gmesh.aface(self.v1, self.v2, self.v3) self.f2 = gmesh.aface(self.v1, self.v3, self.v4) return gmesh
def test_inneighborhood(self): v1, v2, v3, v4 = vec3(1, 1, 0), vec3(1, 2, 0), vec3(1, 2, 1), vec3(1, 1, 1) self.assertEqual(v1.inneighborhood(v2, 1.00), 0) self.assertEqual(v1.inneighborhood(v2, 1.01), 1) self.assertEqual(v1.inneighborhood(v3, 1.00), 0) self.assertEqual(v1.inneighborhood(v3, 1.01), 0) self.assertEqual(v1.inneighborhood(v4, 1.00), 0) self.assertEqual(v1.inneighborhood(v4, 1.01), 1)
def test_sface(self): self.quad() sv1 = self.avert(vec3(0.5, -0.5, -1)) sv2 = self.avert(vec3(0.5, -0.5, -1)) self.assert_counts(6, 6, 2) self.mesh.sface(sv1, self.v1, self.v2, self.v3) self.assert_counts(6, 12, 4) self.mesh.sface(sv2, self.v1, self.v3, self.v4) self.assert_counts(6, 18, 6)
def atest_split(self): fp = dbl.block('H',10,25,25) rg = ptg.partitiongraph() bs = pym.bsegsxy(fp[0],vec3(0,-100,0),vec3(0,100,0)) b = fp[0] i1 = rg.av(b = [b,[]],p = vec3(0,0,0).com(b),l = 0) i2 = rg.sv(0,bs[0],bs[1]) rg.plotxy() plt.show()
def test_sang(self): p1, p2, p3, p4 = vec3(1, 1, 0), vec3(0, 1, 0), vec3(0, -1, 0), vec3(0, 0, 1) pn = vec3(0, 0, 1) self.assertEqual(dpr.isnear(p1.sang(p2, pn), dpr.PI4), 1) self.assertEqual(dpr.isnear(p2.sang(p1, pn), dpr.PI4), 0) self.assertEqual(dpr.isnear(p2.sang(p1, pn), -dpr.PI4), 1) self.assertEqual(dpr.isnear(p2.sang(p3, pn), dpr.PI), 1) self.assertEqual(dpr.isnear(p3.sang(p1, pn), dpr.threePI4), 1)
def tfp(self, p, fp): bprjx = vec3(1, 0, 0).prjps(fp) bprjy = vec3(0, 1, 0).prjps(fp) bprjz = vec3(0, 0, 1).prjps(fp) bprjz = bprjz[0], bprjz[0] + self.height lp = vec3(bprjx[0] + p.x * (bprjx[1] - bprjx[0]), bprjy[0] + p.y * (bprjy[1] - bprjy[0]), bprjz[0] + p.z * (bprjz[1] - bprjz[0])) return lp
def test_dxy(self): v1,v2,v3,v4 = vec3(1,1,0),vec3(1,1,2),vec3(1,2,1),vec3(1,2,4) self.assertTrue(dpr.isnear(v1.dxy(v1),0)) self.assertTrue(dpr.isnear(v1.dxy(v2),0)) self.assertTrue(dpr.isnear(v1.dxy(v3),1)) self.assertTrue(dpr.isnear(v1.dxy(v4),1)) self.assertTrue(dpr.isnear(v2.dxy(v3),1)) self.assertTrue(dpr.isnear(v2.dxy(v4),1)) self.assertTrue(dpr.isnear(v3.dxy(v4),0))
def test_angxy(self): v1,v2,v3,v4 = vec3(1,1,2),vec3(-1,1,-1),vec3(-1,0,0),vec3(1,1,1) self.assertTrue(dpr.isnear(v1.angxy(v1),0)) self.assertTrue(dpr.isnear(v1.angxy(v2),dpr.PI2)) self.assertTrue(dpr.isnear(v2.angxy(v1),dpr.PI2)) self.assertTrue(dpr.isnear(v1.angxy(v3),3*dpr.PI4)) self.assertTrue(dpr.isnear(v3.angxy(v1),3*dpr.PI4)) self.assertTrue(dpr.isnear(v1.angxy(v4),0)) self.assertTrue(dpr.isnear(v4.angxy(v1),0))
def test_sface(self): self.quad() sv1 = self.avert(vec3(0.5,-0.5,-1)) sv2 = self.avert(vec3(0.5,-0.5,-1)) self.assert_counts(6,6,2) self.mesh.sface(sv1,self.v1,self.v2,self.v3) self.assert_counts(6,12,4) self.mesh.sface(sv2,self.v1,self.v3,self.v4) self.assert_counts(6,18,6)
def test_dxy(self): v1, v2, v3, v4 = vec3(1, 1, 0), vec3(1, 1, 2), vec3(1, 2, 1), vec3(1, 2, 4) self.assertTrue(dpr.isnear(v1.dxy(v1), 0)) self.assertTrue(dpr.isnear(v1.dxy(v2), 0)) self.assertTrue(dpr.isnear(v1.dxy(v3), 1)) self.assertTrue(dpr.isnear(v1.dxy(v4), 1)) self.assertTrue(dpr.isnear(v2.dxy(v3), 1)) self.assertTrue(dpr.isnear(v2.dxy(v4), 1)) self.assertTrue(dpr.isnear(v3.dxy(v4), 0))
def test_ap(self): pset = pointset() np = vec3(0, 4, 0) x = pset.ap(np) self.assertEqual(pset.ps[x], np) self.assertTrue(pset.ps[x] is np) np = vec3(2, -1, 3.2) x = pset.ap(np) self.assertEqual(pset.ps[x], np) self.assertTrue(pset.ps[x] is np)
def test_nps(self): np1 = vec3(1, 1, 0) np2 = vec3(0, 1, 2) x, y = self.pset.nps([np1, np2]) self.assertEqual(x, 2) self.assertEqual(y, 8) self.assertFalse(self.pset.ps[x] is np1) self.assertEqual(self.pset.ps[x], np1) self.assertTrue(self.pset.ps[y] is np2) self.assertEqual(self.pset.ps[y], np2)
def test_fp(self): fp = vec3(1, 1, 0) x = self.pset.fp(fp) self.assertEqual(x, 2) self.assertFalse(self.pset.ps[x] is fp) self.assertEqual(self.pset.ps[x], fp) fp = vec3(2, 1, 0) x = self.pset.fp(fp) self.assertEqual(x, -1) self.assertFalse(fp in self.pset.ps)
def branch(self, s, e, l, ml, mw): m = dmo.model() gm = m.atricube('generic') m.trn(vec3(0, 0, 1)) p = s.MARK[1].cp() tn = s.MARK[1].tov(e.MARK[1]) q = quat(0, 0, 0, 0).uu(vec3(0, 0, 1), tn) w = 0.1 * max((mw - (l / ml)**(0.25)), 0.2) s = vec3(w, w, 0.5 * tn.mag()) sgv = self.amodel(p, q, s, m, None)
def atest_polygon(self): def pl(): ax = dtl.plot_axes_xy(50) ax = dtl.plot_polygon_full_xy(py, ax, lw=2, col='b') plt.show() rg = pgr.planargraph() i1 = rg.av(p=vec3(10, -5, 0), l=0) i2 = rg.av(p=vec3(10, 5, 0), l=0) i3 = rg.av(p=vec3(-10, 5, 0), l=0) i4 = rg.av(p=vec3(-10, -5, 0), l=0) r1 = rg.ae(i1, i2) r2 = rg.ae(i2, i3) r3 = rg.ae(i3, i4) r4 = rg.ae(i4, i1) i5 = rg.av(p=vec3(2, -10, 0), l=0) r5, r6 = rg.se(i1, i4, i5) i6 = rg.av(p=vec3(-2, 10, 0), l=0) r7, r8 = rg.se(i2, i3, i6) r9 = rg.ae(i5, i6) i7, r10 = rg.mev(i1, {'p': vec3(12, -20, 0), 'l': 0}, {}) i8, r11 = rg.mev(i3, {'p': vec3(-5, 0, 0), 'l': 0}, {}) i9, r12 = rg.mev(i7, {'p': vec3(14, -28, 0), 'l': 0}, {}) py = pym.pgtopy(rg, 2) pl()
def pcb(self, ax): print('plot callback!', len([r for r in self.lsykws['rules'] if not r is None])) #self.lsykws['iterations'] -= 1 self.lsykws['polar'] = gtl.rad(self.lsykws['polar']) self.lsykws['azimuthal'] = gtl.rad(self.lsykws['azimuthal']) self.lsys = lsy.lsystem(**self.lsykws) self.lsys._realize(vec3(0, 0, 0), vec3(0, 0, 1), ax) self.lsykws['polar'] = gtl.deg(self.lsykws['polar']) self.lsykws['azimuthal'] = gtl.deg(self.lsykws['azimuthal']) return ax
def test_gps(self): gps = self.pset.gps((1, 3, 4)) self.assertEqual(gps[0], vec3(1, 0, 0)) self.assertEqual(gps[0], self.pset.ps[1]) self.assertTrue(gps[0] is self.pset.ps[1]) self.assertEqual(gps[1], vec3(1, 1, 1)) self.assertEqual(gps[1], self.pset.ps[3]) self.assertTrue(gps[1] is self.pset.ps[3]) self.assertEqual(gps[2], vec3(0, 1, 1)) self.assertEqual(gps[2], self.pset.ps[4]) self.assertTrue(gps[2] is self.pset.ps[4])
def test_np(self): np = vec3(1, 1, 0) x = self.pset.np(np) self.assertEqual(x, 2) self.assertFalse(self.pset.ps[x] is np) self.assertEqual(self.pset.ps[x], np) np = vec3(0, 1, 2) x = self.pset.np(np) self.assertEqual(x, 8) self.assertTrue(self.pset.ps[x] is np) self.assertEqual(self.pset.ps[x], np)
def test_angxy(self): v1, v2, v3, v4 = vec3(1, 1, 2), vec3(-1, 1, -1), vec3(-1, 0, 0), vec3(1, 1, 1) self.assertTrue(dpr.isnear(v1.angxy(v1), 0)) self.assertTrue(dpr.isnear(v1.angxy(v2), dpr.PI2)) self.assertTrue(dpr.isnear(v2.angxy(v1), dpr.PI2)) self.assertTrue(dpr.isnear(v1.angxy(v3), 3 * dpr.PI4)) self.assertTrue(dpr.isnear(v3.angxy(v1), 3 * dpr.PI4)) self.assertTrue(dpr.isnear(v1.angxy(v4), 0)) self.assertTrue(dpr.isnear(v4.angxy(v1), 0))
def leaf(self, s, e): m = dmo.model() gm = m.atricube('generic') p = s.MARK[1].cp() tn = s.MARK[1].tov(e.MARK[1]) q = quat(0, 0, 0, 0).uu(vec3(0, 0, 1), tn) #w = 0.1*max((mw-(l/ml)**(0.25)),0.2) #s = vec3(w,w,0.5*tn.mag()) #q = quat(0,0,0,0).av(0.0,vec3(0,0,1)) s = vec3(0.2, 0.2, 0.5 * tn.mag()) m.trn(vec3(0, 0, 1)) sgv = self.amodel(p, q, s, m, None)
def plot(self,ax = None,l = 300,s = (vec3(-10000,0,0),vec3(10000,0,0))): if ax is None:ax = dtl.plot_axes(l) def pv(v,ax): dtl.plot_polygon(v.loop,ax,lw = 2) vp = v.loop[0] for c in self.below(v): cp = c.loop[0] dtl.plot_points((vp,cp),ax) dtl.plot_edges((vp,cp),ax,lw = 3,col = 'b') pv(c,ax) pv(self.root,ax) return ax
def atest_break(self): fp = dbl.block('H', 10, 25, 25) v1 = {'b': fp, 'p': vec3(0, 0, 0).com(fp[0]), 'l': 0} rg = ptg.partitiongraph() ip = vec3(0.5, 0.5, 0) i1 = rg.av(**v1) i2 = rg.bv(0, ip, vec3(1, 0, 0)) i3 = rg.bv(0, ip, vec3(0, 1, 0)) i4 = rg.bv(1, ip, vec3(0, 1, 0)) rg.vves() rg.plotxy() plt.show()
def test_intrixy(self): a = vec3(-93.6169662475586, 46.23309326171875, 0.0) b = vec3(28.083663940429688, 48.28422546386719, 0.0) c = vec3(25.696874618530273, 48.28422546386719, 0.0) p = vec3(-93.34214782714844, 43.73178482055664, 0.0) i = p.intrixy(a, b, c) self.assertFalse(i) ax = dtl.plot_axes_xy(100) ax = dtl.plot_points_xy((a, b, c, p), ax) ax = dtl.plot_polygon_xy((a, b, c), ax, lw=2, col='g') plt.show()
def test_isnearxy(self): v1, v2, v3, v4 = vec3(1, 1, 0), vec3(1.1, 1, 0.1), vec3(1, 1, 1), vec3(1.000001, 1, 1) self.assertEqual(v1.isnearxy(v1), 1) self.assertEqual(v3.isnearxy(v3), 1) self.assertEqual(v1.isnearxy(v2), 0) self.assertEqual(v2.isnearxy(v1), 0) self.assertEqual(v1.isnearxy(v3), 1) self.assertEqual(v2.isnearxy(v3), 0) self.assertEqual(v2.isnearxy(v4), 0) self.assertEqual(v3.isnearxy(v4), 1)
def atest_contract(self): def pl(b): ax = dtl.plot_axes_xy(300) ax = dtl.plot_polygon_xy(b, ax) plt.show() b = pym.ebuxy( vec3(0, 100, 0).sq(500, 200), vec3(100, 0, 0).sq(200, 500))[0] b = pym.bisectb(b) b = pym.bisectb(b) b = pym.smoothxy(b, 0.2) b = pym.contract(b, 25)
def test_uu(self): u1,u2,u3 = vec3(1,0,0),vec3(0,-1,0),vec3(0,0,1) q1,q2 = quat(0,0,0,0).uu(u1,u2),quat(0,0,0,0).uu(u1,u3) q3,q4 = quat(0,0,0,0).uu(u2,u3),quat(0,0,0,0).uu(u3,u2) self.assertTrue(q1.w > 0.1) self.assertTrue(dpr.isnear(q1.x,0)) self.assertTrue(dpr.isnear(q1.y,0)) self.assertTrue(q1.z < -0.1) self.assertTrue(q2.w > 0.1) self.assertTrue(dpr.isnear(q2.x,0)) self.assertTrue(q2.y < -0.1) self.assertTrue(dpr.isnear(q2.z,0)) self.assertTrue(q3 == q4.cnj())
def test_ang(self): v1, v2, v3, v4 = vec3(1, 1, 0), vec3(-1, 1, 0), vec3(-1, 0, 0), vec3(1, 1, 1) self.assertTrue(dpr.isnear(v1.ang(v1), 0)) self.assertTrue(dpr.isnear(v1.ang(v2), dpr.PI2)) self.assertTrue(dpr.isnear(v2.ang(v1), dpr.PI2)) self.assertTrue(dpr.isnear(v1.ang(v3), 3 * dpr.PI4)) self.assertTrue(dpr.isnear(v3.ang(v1), 3 * dpr.PI4)) self.assertTrue( dpr.isnear(v1.ang(v4), numpy.arctan(1.0 / math.sqrt(2)))) self.assertTrue( dpr.isnear(v4.ang(v1), numpy.arctan(1.0 / math.sqrt(2)))) v1.ang(vec3(0, 0, 0))