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))
