def wall(p1, p2, wh1, wh2, ww, doors=(), windows=()):
l = dpv.distance(p1, p2)
a = dpr.angle_from_xaxis_xy(dpv.v1_v2(p1, p2))
ww2 = ww / 2.0
bnd = [
dpv.vector(ww2, 0, 0),
dpv.vector(l - ww2, 0, 0),
dpv.vector(l - ww2, wh2, 0),
dpv.vector(ww2, wh1, 0)
]
for d in doors:
dhp = doorhole(l, *d)
for x in range(len(dhp) - 1, -1, -1):
bnd.insert(1, dhp[x])
wholes = [tuple(windowhole(l, *w)) for w in windows]
extras = []
for d in doors:
dpolys = doorframe(l, *d)
for dp in dpolys:
extras.append(dp)
for w in windows:
wpolys = windowframe(l, *w)
for wp in wpolys:
extras.append(wp)
x = dpv.z().scale_u(ww2)
main0 = (tuple(bnd), tuple(wholes))
main1 = dpr.translate_polygon(dpr.copy_polygon(main0), x)
dpr.translate_polygon(main0, x.flip())
wallgons = (main0, main1) + tuple(extras)
#wallgons = (main1,)+tuple(extras)
for wgon in wallgons:
dpr.rotate_x_polygon(wgon, dpr.PI / 2.0)
dpr.rotate_z_polygon(wgon, a)
dpr.translate_polygon(wgon, p1)
return wallgons
def road(start = None,end = None,tip = None,tail = None):
if start is None:start = dpv.zero()
if end is None:end = dpv.vector(100,100,-10)
if tip is None:tip = dpv.vector(0,1,0)
if tail is None:tail = dpv.vector(0,1,0)
rd = dr.road(start,end,tip,tail)
return rd
def profile_triangulation():
import dilap.mesh.piecewisecomplex as pwc
ps1 = tuple(dpr.point_ring(100, 32))
ps2 = tuple(dpr.point_ring(20, 8))
ps3 = tuple(dpr.point_ring(100, 64))
ps4 = tuple([p.copy() for p in ps2])
q = dpq.q_from_av(numpy.pi / 2.0, dpv.xhat)
for p in ps1:
p.rotate(q)
for p in ps2:
p.rotate(q)
dpv.translate_coords(list(ps1), dpv.vector(0, 100, 0))
dpv.translate_coords(list(ps2), dpv.vector(0, 100, 0))
dpv.translate_coords(list(ps3), dpv.vector(0, 0, -100))
dpv.translate_coords(list(ps4), dpv.vector(0, 0, -100))
polygons = ((ps1, (ps2, )), (ps3, ()))
#polygons = ((ps3,(ps4,)),)
#polygons = ((ps3,()),)
plc = pwc.piecewise_linear_complex()
plc.add_polygons(*polygons)
dprf.profile_function(plc.triangulate)
#dprf.profile_function(plc.triangulate_xy)
ax = plc.plot()
plt.show()
def wall(p1,p2,wh1,wh2,ww,doors = (),windows = ()):
l = dpv.distance(p1,p2)
a = dpr.angle_from_xaxis_xy(dpv.v1_v2(p1,p2))
ww2 = ww/2.0
bnd = [
dpv.vector( ww2, 0,0),dpv.vector(l-ww2, 0,0),
dpv.vector(l-ww2,wh2,0),dpv.vector( ww2,wh1,0)]
for d in doors:
dhp = doorhole(l,*d)
for x in range(len(dhp)-1,-1,-1):
bnd.insert(1,dhp[x])
wholes = [tuple(windowhole(l,*w)) for w in windows]
extras = []
for d in doors:
dpolys = doorframe(l,*d)
for dp in dpolys:extras.append(dp)
for w in windows:
wpolys = windowframe(l,*w)
for wp in wpolys:extras.append(wp)
x = dpv.z().scale_u(ww2)
main0 = (tuple(bnd),tuple(wholes))
main1 = dpr.translate_polygon(dpr.copy_polygon(main0),x)
dpr.translate_polygon(main0,x.flip())
wallgons = (main0,main1)+tuple(extras)
#wallgons = (main1,)+tuple(extras)
for wgon in wallgons:
dpr.rotate_x_polygon(wgon,dpr.PI/2.0)
dpr.rotate_z_polygon(wgon,a)
dpr.translate_polygon(wgon,p1)
return wallgons
def opass():
g = graph()
bnd = dpr.square(100,100)
oprgn1 = grg.overpass(bnd)
oprgn1._graph(g)
bnd = dpr.square(100,100,dpv.vector(500,0,0),dpr.rad(75))
oprgn2 = grg.overpass(bnd)
oprgn2._graph(g)
bnd = dpr.square(100,100,dpv.vector(250,200,0),dpr.rad(35))
oprgn3 = grg.overpass(bnd)
oprgn3._graph(g)
oprgn1._connect(oprgn2,g)
oprgn2._connect(oprgn3,g)
oprgn3._connect(oprgn1,g)
g._update()
ax = dtl.plot_axes()
ax = oprgn1.plot(ax)
ax = oprgn2.plot(ax)
ax = oprgn3.plot(ax)
ax = g.plot(ax)
ax.set_zlim([0,40])
plt.show()
return g
def some_input():
ls = [5, 10, 15]
ws = [2, 4, 6, 8]
base = dpv.vector(50, 50, 0)
fixed_pts = []
for sq in range(5):
pt = base.copy().translate_x(sq * 25).translate_y(sq * 10)
l, w = rm.choice(ls), rm.choice(ws)
corners = mpu.make_corners(pt, l, w, 0)
fixed_pts.extend(corners)
hole_corners = [pt.copy() for pt in fixed_pts]
region_pts = []
for lpt in range(5):
pt = dpv.zero().translate_x(lpt * 100).translate_y(
(4 * lpt - lpt**2) * 100)
region_pts.append(pt)
region_pts.append(dpv.vector(200, -100, 0))
for rpt in region_pts:
print(rpt)
target_polygon_edge_length = 10
target_primitive_edge_length = 200
theinput = {
'fixed_pts': fixed_pts,
'hole_pts': hole_corners,
'region_pts': region_pts,
'polygon_edge_length': target_polygon_edge_length,
'primitive_edge_length': target_primitive_edge_length,
}
return theinput
def profile_triangulation():
import dilap.mesh.piecewisecomplex as pwc
ps1 = tuple(dpr.point_ring(100,32))
ps2 = tuple(dpr.point_ring(20,8))
ps3 = tuple(dpr.point_ring(100,64))
ps4 = tuple([p.copy() for p in ps2])
q = dpq.q_from_av(numpy.pi/2.0,dpv.xhat)
for p in ps1:p.rotate(q)
for p in ps2:p.rotate(q)
dpv.translate_coords(list(ps1),dpv.vector(0,100,0))
dpv.translate_coords(list(ps2),dpv.vector(0,100,0))
dpv.translate_coords(list(ps3),dpv.vector(0,0,-100))
dpv.translate_coords(list(ps4),dpv.vector(0,0,-100))
polygons = ((ps1,(ps2,)),(ps3,()))
#polygons = ((ps3,(ps4,)),)
#polygons = ((ps3,()),)
plc = pwc.piecewise_linear_complex()
plc.add_polygons(*polygons)
dprf.profile_function(plc.triangulate)
#dprf.profile_function(plc.triangulate_xy)
ax = plc.plot()
plt.show()
def some_input():
ls = [5, 10, 15]
ws = [2, 4, 6, 8]
base = dpv.vector(50,50,0)
fixed_pts = []
for sq in range(5):
pt = base.copy().translate_x(sq*25).translate_y(sq*10)
l,w = rm.choice(ls),rm.choice(ws)
corners = mpu.make_corners(pt,l,w,0)
fixed_pts.extend(corners)
hole_corners = [pt.copy() for pt in fixed_pts]
region_pts = []
for lpt in range(5):
pt = dpv.zero().translate_x(lpt*100).translate_y((4*lpt-lpt**2)*100)
region_pts.append(pt)
region_pts.append(dpv.vector(200,-100,0))
for rpt in region_pts:print(rpt)
target_polygon_edge_length = 10
target_primitive_edge_length = 200
theinput = {
'fixed_pts':fixed_pts,
'hole_pts':hole_corners,
'region_pts':region_pts,
'polygon_edge_length':target_polygon_edge_length,
'primitive_edge_length':target_primitive_edge_length,
}
return theinput
def road(start=None, end=None, tip=None, tail=None):
if start is None: start = dpv.zero()
if end is None: end = dpv.vector(100, 100, -10)
if tip is None: tip = dpv.vector(0, 1, 0)
if tail is None: tail = dpv.vector(0, 1, 0)
rd = dr.road(start, end, tip, tail)
return rd
def corners(l,w,p = None,phi = None):
l2,w2 = l/2.0,w/2.0
cs = [
dpv.vector(-l2,-w2,0),dpv.vector( l2,-w2,0),
dpv.vector( l2, w2,0),dpv.vector(-l2, w2,0)]
if not phi is None:dpv.rotate_z_coords(cs,phi)
if not p is None:dpv.translate_coords(cs,p)
return cs
def windowhole(l, wlw, ww, wh, wz, lp):
whole = [
dpv.vector(-ww / 2.0, wz, 0),
dpv.vector(-ww / 2.0, wh + wz, 0),
dpv.vector(ww / 2.0, wh + wz, 0),
dpv.vector(ww / 2.0, wz, 0)
]
dpv.translate_coords_x(whole, l * lp)
return whole
def doorhole(l, wlw, dw, dh, lp):
dhole = [
dpv.vector(-dw / 2.0, 0, 0),
dpv.vector(-dw / 2.0, dh, 0),
dpv.vector(dw / 2.0, dh, 0),
dpv.vector(dw / 2.0, 0, 0)
]
dpv.translate_coords_x(dhole, l * lp)
return dhole
def _curve(self,**kwargs):
if 'curve' in kwargs.keys() and kwargs['curve']:
self.curve = kwargs['curve']
else:
self.curve = [dpv.zero(),
dpv.zero().translate_z(5),
dpv.zero().translate_z(5).translate_y(5),
dpv.zero().translate_z(5).translate_y(5).translate(dpv.vector(1,1,2)),
dpv.zero().translate_z(5).translate_y(5).translate(dpv.vector(1,1,2)).translate_x(4),
dpv.zero().translate_z(5).translate_y(5).translate(dpv.vector(1,1,2)).translate_x(4).translate_z(-2)]
def model(self):
mpolys = []
plc1 = dtl.box(15,15,10)
#plc2 = dtl.box(5,4,4).translate(dpv.vector(4,0,0))
plc2 = dtl.box(14,14,6).translate(dpv.vector(0,0,5))
plc3 = dtl.box(12,14,6).translate(dpv.vector(0,5,5))
#plc2 = dtl.box(8,3,2).translate(dpv.vector(0,0,1))
#plc2 = dtl.icosphere(2,1)
#plc2.translate(dpv.vector(0,0,5.0))
'''#
print('union input')
ax = dtl.plot_axes()
ax = plc1.plot(ax)
ax = plc2.plot(ax)
plt.show()
'''#
#plc4 = pwc.union(plc1,plc2)
plc5 = pwc.union(plc1,plc3)
#plc3 = pwc.difference(plc1,plc2)
#plc3 = pwc.intersection(plc1,plc2)
#plc2 = dtl.box(20,12,5).translate(dpv.vector(0,10,46.5))
#plc3 = pwc.difference(plc1,plc2)
print('union output')
ax = plc5.plot()
plt.show()
'''#
plc2 = dtl.box(10,10,6).translate(dpv.vector(5,0,6))
plc3 = pwc.union(plc3,plc2)
print('union output')
ax = dtl.plot_axes()
ax = plc3.plot(ax)
plt.show()
'''#
pys = []
for px in range(plc5.polygoncount):
pys.append(plc5.get_polygon_points(px))
mpolys = pys
#mpolys.extend(self.model_rooms())
#mpolys.extend(self.model_walls())
#mpolys.extend(self.model_corners())
#mpolys.extend(self.model_roof())
#mpolys = dtl.merge_polygons(mpolys)
return mpolys
def model(self):
mpolys = []
plc1 = dtl.box(15, 15, 10)
#plc2 = dtl.box(5,4,4).translate(dpv.vector(4,0,0))
plc2 = dtl.box(14, 14, 6).translate(dpv.vector(0, 0, 5))
plc3 = dtl.box(12, 14, 6).translate(dpv.vector(0, 5, 5))
#plc2 = dtl.box(8,3,2).translate(dpv.vector(0,0,1))
#plc2 = dtl.icosphere(2,1)
#plc2.translate(dpv.vector(0,0,5.0))
'''#
print('union input')
ax = dtl.plot_axes()
ax = plc1.plot(ax)
ax = plc2.plot(ax)
plt.show()
'''#
#plc4 = pwc.union(plc1,plc2)
plc5 = pwc.union(plc1, plc3)
#plc3 = pwc.difference(plc1,plc2)
#plc3 = pwc.intersection(plc1,plc2)
#plc2 = dtl.box(20,12,5).translate(dpv.vector(0,10,46.5))
#plc3 = pwc.difference(plc1,plc2)
print('union output')
ax = plc5.plot()
plt.show()
'''#
plc2 = dtl.box(10,10,6).translate(dpv.vector(5,0,6))
plc3 = pwc.union(plc3,plc2)
print('union output')
ax = dtl.plot_axes()
ax = plc3.plot(ax)
plt.show()
'''#
pys = []
for px in range(plc5.polygoncount):
pys.append(plc5.get_polygon_points(px))
mpolys = pys
#mpolys.extend(self.model_rooms())
#mpolys.extend(self.model_walls())
#mpolys.extend(self.model_corners())
#mpolys.extend(self.model_roof())
#mpolys = dtl.merge_polygons(mpolys)
return mpolys
def blueprint(self):
root = (tuple(b.copy() for b in self.boundary),())
rmprints = self.block(root)
self.geom.points.add_point(dpv.vector(0,0,0))
self.geom.points.add_point(dpv.vector(0,0,10))
entry = self.rgraph.add_node(0)
room1 = self.rgraph.add_node(1)
self.rgraph.add_edge(0,1)
entry.room = room(boundary = rmprints[0])
room1.room = room(boundary = rmprints[1])
def blueprint(self):
root = (tuple(b.copy() for b in self.boundary), ())
rmprints = self.block(root)
self.geom.points.add_point(dpv.vector(0, 0, 0))
self.geom.points.add_point(dpv.vector(0, 0, 10))
entry = self.rgraph.add_node(0)
room1 = self.rgraph.add_node(1)
self.rgraph.add_edge(0, 1)
entry.room = room(boundary=rmprints[0])
room1.room = room(boundary=rmprints[1])
def _curve(self, **kwargs):
if 'curve' in kwargs.keys() and kwargs['curve']:
self.curve = kwargs['curve']
else:
self.curve = [
dpv.zero(),
dpv.zero().translate_z(5),
dpv.zero().translate_z(5).translate_y(5),
dpv.zero().translate_z(5).translate_y(5).translate(
dpv.vector(1, 1, 2)),
dpv.zero().translate_z(5).translate_y(5).translate(
dpv.vector(1, 1, 2)).translate_x(4),
dpv.zero().translate_z(5).translate_y(5).translate(
dpv.vector(1, 1, 2)).translate_x(4).translate_z(-2)
]
def generate(self, worn=0):
polygon = (tuple(x.copy() for x in self.boundary), ())
plc = pwc.piecewise_linear_complex()
plc.add_polygons(polygon)
plc.extrude_polygon(0, dpv.vector(0, 0, 10))
plc.triangulate()
#plc.plot()
#plt.show()
pelt = plc.pelt()
node = self._node_wrap(pelt)
self._nodes_to_graph(node)
return self
self.fplan.plan()
for x in range(self.stories):
self.fplan.plan_specific(x)
self.fplan.sgraph.nodes = []
# need to get bboxes for the floorplan?
self.fplan.generate(self.wheights[x], worn)
if x == 0: self.generate_stoop(worn)
self.generate_story(x, worn)
for s in self.fplan.generate_shafts(worn):
self._consume(s)
self._consume(self.fplan.generate_roof(worn))
return self
def csgtest():
plc1 = dtl.box(5,5,5)
#plc2 = dtl.icosphere(2,1)
plc2 = dtl.box(5,3,4).translate(dpv.vector(2,2,-0.5))
#plc2 = dtl.box(5,2,2).translate(dpv.vector(0,0,1.5))
#plc2 = dtl.box(5,2,2).translate(dpv.vector(0,0,1.5))
#plc2.translate(dpv.vector(0,0,5.0))
#plc2.translate(dpv.vector(0,0,-3.0))
#plc2.rotate(dpq.q_from_av(dpr.PI/6.0,dpv.x()))
#plc2.translate(dpv.vector(0,0, 3.0))
#plc1.triangulate()
#plc2.triangulate()
print('union input')
ax = dtl.plot_axes()
ax = plc1.plot(ax)
ax = plc2.plot(ax)
plt.show()
plc3 = pwc.union(plc1,plc2)
#plc3 = pwc.intersection(plc1,plc2)
#plc3 = pwc.difference(plc1,plc2)
print('union output')
ax = dtl.plot_axes()
ax = plc3.plot(ax)
plt.show()
def csgtest():
plc1 = dtl.box(5, 5, 5)
#plc2 = dtl.icosphere(2,1)
plc2 = dtl.box(5, 3, 4).translate(dpv.vector(2, 2, -0.5))
#plc2 = dtl.box(5,2,2).translate(dpv.vector(0,0,1.5))
#plc2 = dtl.box(5,2,2).translate(dpv.vector(0,0,1.5))
#plc2.translate(dpv.vector(0,0,5.0))
#plc2.translate(dpv.vector(0,0,-3.0))
#plc2.rotate(dpq.q_from_av(dpr.PI/6.0,dpv.x()))
#plc2.translate(dpv.vector(0,0, 3.0))
#plc1.triangulate()
#plc2.triangulate()
print('union input')
ax = dtl.plot_axes()
ax = plc1.plot(ax)
ax = plc2.plot(ax)
plt.show()
plc3 = pwc.union(plc1, plc2)
#plc3 = pwc.intersection(plc1,plc2)
#plc3 = pwc.difference(plc1,plc2)
print('union output')
ax = dtl.plot_axes()
ax = plc3.plot(ax)
plt.show()
def mev(self,v,e = None,a = None):
dp = dpv.vector(0,0,0)
np = self.owner.geom.points.ps[v.index].copy().translate(dp)
nx = self.owner.geom.new_point(np)
newnode = self.add_node(nx)
newedge = self.add_edge(v,newnode)
return newedge,newnode
def cover(self,plc):
c01 = dpv.vector(-50,-50,-50)
c02 = dpv.vector( 0, 50,-50)
c03 = dpv.vector( 50,-50,-50)
c04 = dpv.vector( 0, 0, 50)
c0psx = self.points.add_points(c01,c02,c03,c04)
self.add_tetrahedron(*c0psx)
ax = plc.plot()
self.plot(ax)
plt.show()
ghost1 = (c0psx[2],c0psx[1],c0psx[0])
self.add_ghost_tetrahedron(*ghost1)
ghost2 = (c0psx[3],c0psx[2],c0psx[0])
self.add_ghost_tetrahedron(*ghost2)
ghost3 = (c0psx[1],c0psx[2],c0psx[3])
self.add_ghost_tetrahedron(*ghost3)
ghost4 = (c0psx[0],c0psx[1],c0psx[3])
self.add_ghost_tetrahedron(*ghost4)
for plcx in range(plc.points.pcnt):
plcp = plc.points.ps[plcx].copy()
tloc = self.point_location(plcp)
if tloc is None:
print('shit')
pdb.set_trace()
else:
nv = self.points.add_point(plcp)
self.insert_vertex(nv,*self.tetrahedrons[tloc])
print('inserted vertex',nv-4)
ax = plc.plot()
self.plot(ax)
plt.show()
for cx in c0psx:
for tx in range(self.tetracnt):
tet = self.tetrahedrons[tx]
if tet is None:continue
if cx in tet:self.delete_tetrahedron(*tet)
self.plot()
plt.show()
pdb.set_trace()
def create_bbox(self,roomplan):
x,y = roomplan[1]['x'],roomplan[1]['y']
l,w = roomplan[1]['l']-0.01,roomplan[1]['w']-0.01
cns = dpr.square(l,w,dpv.vector(x,y,0))
xpj = dpv.project_coords(cns,dpv.x())
ypj = dpv.project_coords(cns,dpv.y())
zpj = dpv.project_coords(cns,dpv.z())
bb = dbb.bbox(xpj,ypj,zpj)
roomplan[1]['bbox'] = bb
def create_bbox(self, roomplan):
x, y = roomplan[1]['x'], roomplan[1]['y']
l, w = roomplan[1]['l'] - 0.01, roomplan[1]['w'] - 0.01
cns = dpr.square(l, w, dpv.vector(x, y, 0))
xpj = dpv.project_coords(cns, dpv.x())
ypj = dpv.project_coords(cns, dpv.y())
zpj = dpv.project_coords(cns, dpv.z())
bb = dbb.bbox(xpj, ypj, zpj)
roomplan[1]['bbox'] = bb
def generate_uturn(self,level):
l,w,fh,wh,ch = self._params(level)
p1h = fh;p1l = l;p1w = 3.0
p1x = 0.0;p1y = (p1w - w)/2.0;p1z = 0
pform1 = dcu.cube().translate_z(0.5)
pform1.scale(dpv.vector(p1l,p1w,p1h))
pform1.translate(dpv.vector(p1x,p1y,p1z))
pform1._project_uv_flat()
p2h = ch;p2l = l;p2w = 3.0
p2x = 0.0;p2y = (p2w - w)/2.0;p2z = wh - ch
pform2 = dcu.cube().translate_z(0.5)
pform2.scale(dpv.vector(p2l,p2w,p2h))
pform2.translate(dpv.vector(p2x,p2y,p2z))
pform2._project_uv_flat()
gap = l/4.0
s = int(wh)
rw = 2.0*gap
rl = w - 2.0*p1w
diff = wh/2.0
rwoffx = l/2.0 - rw/2.0
rwoffy = rl/2.0
sheight = diff/s
p3h = 2.0*sheight;p3l = l;p3w = 3.0
p3x = 0.0;p3y = (w - p3w)/2.0;p3z = diff
#p3x = 0.0;p3y = (w - p3w)/2.0;p3z = diff-sheight
# this next line is suspect
pform3 = dcu.cube().translate_z(0.25)
pform3.scale(dpv.vector(p3l,p3w,p3h))
pform3.translate(dpv.vector(p3x,p3y,p3z))
pform3._project_uv_flat()
extra = dcu.cube().translate_z(0.5)
extra.scale(dpv.vector(gap,rl,wh))
extra.translate(dpv.vector(0,0,0))
extra._project_uv_flat()
sopts1 = {'steps':s,'l':rl,'w':rw,'h':diff}
sopts2 = {'steps':s,'l':rl,'w':rw,'h':diff}
lside = ds.stairs(**sopts1)
rside = ds.stairs(**sopts2)
lside.rotate_z(dpr.PI).translate_y(rl).translate_z(diff)
#lside.translate_x(-rwoffx).translate_y(-rwoffy).translate_z(fh-sheight)
#rside.translate_x( rwoffx).translate_y(-rwoffy).translate_z(fh-sheight)
lside.translate_x(-rwoffx).translate_y(-rwoffy).translate_z(fh)
rside.translate_x( rwoffx).translate_y(-rwoffy).translate_z(fh)
lside._project_uv_flat()
rside._project_uv_flat()
if level == self.stories - 1:final = dmo.combine([pform1,extra])
else:final = dmo.combine([pform1,pform2,pform3,lside,rside,extra])
return self._node_wrap(final)
def face_away(self,side):
rp = side[1]['room']
intpt = dpv.vector(rp[1]['x'],rp[1]['y'],0.0)
midpt = dpv.midpoint(*side[0])
tangt = dpv.v1_v2(*side[0]).normalize()
norml = tangt.copy().rotate_z(dpr.rad(90)).normalize()
tstpt = midpt.copy().translate(norml)
side[1]['normal'] = norml
if dpv.distance(intpt,midpt) > dpv.distance(intpt,tstpt):
side[1]['normal'].flip()
def face_away(self, side):
rp = side[1]['room']
intpt = dpv.vector(rp[1]['x'], rp[1]['y'], 0.0)
midpt = dpv.midpoint(*side[0])
tangt = dpv.v1_v2(*side[0]).normalize()
norml = tangt.copy().rotate_z(dpr.rad(90)).normalize()
tstpt = midpt.copy().translate(norml)
side[1]['normal'] = norml
if dpv.distance(intpt, midpt) > dpv.distance(intpt, tstpt):
side[1]['normal'].flip()
def btest():
br = brep()
nbp = dpv.vector(1,1,0)
br.new_body(nbp).mev(0)
#br.fun()
br.plot()
plt.show()
def wall_verts(self,rmargs):
rmkws = rmargs[1]
cs = dpr.square(rmkws['l'],rmkws['w'],
dpv.vector(rmkws['x'],rmkws['y'],0.0))
pairs = []
for cdx in range(1,len(cs)):
c1,c2 = cs[cdx-1].copy(),cs[cdx].copy()
pairs.append((c1,c2))
c1,c2 = cs[-1].copy(),cs[0].copy()
pairs.append((c1,c2))
return pairs
def add_node(self,ndkey,**kwargs):
if ndkey in self.nodes_lookup:
nd = self.nodes[self.nodes_lookup[ndkey]]
if not nd is None:return nd.index
nx,ny,nz = ndkey
newnode = self.nodeclass(self.nodecount,
dpv.vector(nx,ny,nz),**kwargs)
self.nodes.append(newnode)
self.nodes_lookup[newnode.key()] = newnode.index
self.nodecount += 1
return newnode.index
def _add_node(self,ndkey):
if ndkey in self.nodes_lookup:
nd = self.nodes[self.nodes_lookup[ndkey]]
if not nd is None:return nd.index
nx,ny,nl = ndkey
newnode = gnd.node(dpv.vector(nx,ny,20*nl),layer = nl)
newnode.index = self.nodecount
self.nodes.append(newnode)
self.nodes_lookup[ndkey] = newnode.index
self.nodecount += 1
return newnode.index
def wall_verts(self, rmargs):
rmkws = rmargs[1]
cs = dpr.square(rmkws['l'], rmkws['w'],
dpv.vector(rmkws['x'], rmkws['y'], 0.0))
pairs = []
for cdx in range(1, len(cs)):
c1, c2 = cs[cdx - 1].copy(), cs[cdx].copy()
pairs.append((c1, c2))
c1, c2 = cs[-1].copy(), cs[0].copy()
pairs.append((c1, c2))
return pairs
def should_shaft(self,plans,rmplan):
rps,eps,ips,sps = plans
sdist = 1000.0
rpos = dpv.vector(rmplan[1]['x'],rmplan[1]['y'],0)
for sp in sps:
spos = sp[1]['p']
sd = dpv.distance(spos,rpos)
if sd < sdist:sdist = sd
splan = None
newl,neww = rmplan[1]['l'],rmplan[1]['w']
if sdist > self.min_shaft_distance and newl >= 16 and neww >= 18:
shx,shy = rmplan[1]['x'],rmplan[1]['y']
shl = 8
shw = 10
sps = dpv.vector(shx,shy,0)
gap = (dpv.zero(),shl,shw)
rmplan[1]['shafted'] = True
rmplan[1]['fgap'] = gap
rmplan[1]['cgap'] = gap
splan = ((),{'p':sps,'l':gap[1],'w':gap[2]})
return splan
def _connect_edges(self,o,sedgex,oedgex,g,**kwargs):
splugs,oplugs = self._plugsonedge(sedgex),o._plugsonedge(oedgex)
spgcnt,opgcnt = len(splugs),len(oplugs)
spkeys = self._plugkeys()
subspkeys = [spkeys[splugs[x]] for x in range(spgcnt)]
opkeys = o._plugkeys()
subopkeys = [opkeys[oplugs[x]] for x in range(opgcnt)]
b1,b2 = self._tangent(o).rotate_z(dpr.rad(90)).normalize(),dpv.zhat.copy()
sps = dpv.projected_order([dpv.vector(*spk) for spk in subspkeys],b1,b2)
ops = dpv.projected_order([dpv.vector(*opk) for opk in subopkeys],b1,b2)
if spgcnt == opgcnt:pgpairs = [(x,y) for x,y in zip(sps,ops)]
else:
print('plug ambiguity!!!')
pdb.set_trace()
for pgpair in pgpairs:
pkey1,pkey2 = spkeys[splugs[pgpair[0]]],opkeys[oplugs[pgpair[1]]]
g._add_edge(pkey1,pkey2,**kwargs)
print('added edge',pkey1,pkey2)
def should_shaft(self, plans, rmplan):
rps, eps, ips, sps = plans
sdist = 1000.0
rpos = dpv.vector(rmplan[1]['x'], rmplan[1]['y'], 0)
for sp in sps:
spos = sp[1]['p']
sd = dpv.distance(spos, rpos)
if sd < sdist: sdist = sd
splan = None
newl, neww = rmplan[1]['l'], rmplan[1]['w']
if sdist > self.min_shaft_distance and newl >= 16 and neww >= 18:
shx, shy = rmplan[1]['x'], rmplan[1]['y']
shl = 8
shw = 10
sps = dpv.vector(shx, shy, 0)
gap = (dpv.zero(), shl, shw)
rmplan[1]['shafted'] = True
rmplan[1]['fgap'] = gap
rmplan[1]['cgap'] = gap
splan = ((), {'p': sps, 'l': gap[1], 'w': gap[2]})
return splan
def fun(self):
self.add_face(
dpv.vector( 0, 0,0),dpv.vector(10, 0,0),
dpv.vector(10,10,0),dpv.vector( 0,10,0))
self.add_face(
dpv.vector(10, 0,0),dpv.vector(20, 0,0),
dpv.vector(20,10,0),dpv.vector(10,10,0))
self.geom.points.ps[1].translate_z(10)
self.geom.points.ps[2].translate_z(10)
self.split_edge(2)
self.geom.points.ps[6].translate_z(2)
return
def _point(self, v):
vmag = v.magnitude()
if vmag > 0.000000001:
r = self.width
else:
mr = self.radius - self.width
r = random.random() * mr
t = random.random() * 2 * numpy.pi
x = r * numpy.cos(t)
y = r * numpy.sin(t)
p = dpv.vector(x, y, 0)
p.translate(v)
return p
def _add_node(self, ndkey, **kwargs):
if ndkey in self.nodes_lookup:
nd = self.nodes[self.nodes_lookup[ndkey]]
if not nd is None: return nd.index
nx, ny, nl = ndkey
nz = 0.0
newnode = self.nodeclass(dpv.vector(nx, ny, nz), layer=nl, **kwargs)
newnode.index = self.nodecount
self.nodes.append(newnode)
self.nodes_lookup[ndkey] = newnode.index
self.nodecount += 1
self._apply_node_layer(newnode.index)
return newnode.index
def planes_intersection(pn1, p01, pn2, p02):
u = pn1.cross(pn2)
ax = u.x if u.x >= 0 else -u.x
ay = u.y if u.y >= 0 else -u.y
az = u.z if u.z >= 0 else -u.z
# pn1 and pn2 are near parallel
if ((ax + ay + az) < 0.0001):
v = p02 - p01
if dpr.isnear(dpv.dot(pn1, v), 0): return
else: return
# pn1 and pn2 intersect in a line
# first determine max abs coordinate of cross product
if (ax > ay):
if (ax > az): maxc = 1
else: maxc = 3
else:
if (ay > az): maxc = 2
else: maxc = 3
# next, to get a point on the intersect line
# zero the max coord, and solve for the other two
d1 = -dpv.dot(pn1, p01)
d2 = -dpv.dot(pn2, p02)
# select max coordinate
if maxc == 1: # intersect with x=0
y = (d2 * pn1.z - d1 * pn2.z) / u.x
z = (d1 * pn2.y - d2 * pn1.y) / u.x
ip = dpv.vector(0, y, z)
elif maxc == 2: # intersect with y=0
x = (d1 * pn2.z - d2 * pn1.z) / u.y
z = (d2 * pn1.x - d1 * pn2.x) / u.y
ip = dpv.vector(x, 0, z)
elif maxc == 3: # intersect with z=0
x = (d2 * pn1.y - d1 * pn2.y) / u.z
y = (d1 * pn2.x - d2 * pn1.x) / u.z
ip = dpv.vector(x, y, 0)
return ip, ip + u
def planes_intersection(pn1,p01,pn2,p02):
u = pn1.cross(pn2)
ax = u.x if u.x >= 0 else -u.x
ay = u.y if u.y >= 0 else -u.y
az = u.z if u.z >= 0 else -u.z
# pn1 and pn2 are near parallel
if ((ax+ay+az) < 0.0001):
v = p02 - p01
if dpr.isnear(dpv.dot(pn1,v),0):return
else:return
# pn1 and pn2 intersect in a line
# first determine max abs coordinate of cross product
if (ax > ay):
if (ax > az):maxc = 1
else:maxc = 3
else:
if (ay > az):maxc = 2
else:maxc = 3
# next, to get a point on the intersect line
# zero the max coord, and solve for the other two
d1 = -dpv.dot(pn1,p01)
d2 = -dpv.dot(pn2,p02)
# select max coordinate
if maxc == 1: # intersect with x=0
y = (d2*pn1.z - d1*pn2.z) / u.x
z = (d1*pn2.y - d2*pn1.y) / u.x
ip = dpv.vector(0,y,z)
elif maxc == 2: # intersect with y=0
x = (d1*pn2.z - d2*pn1.z) / u.y
z = (d2*pn1.x - d1*pn2.x) / u.y
ip = dpv.vector(x,0,z)
elif maxc == 3: # intersect with z=0
x = (d2*pn1.y - d1*pn2.y) / u.z
y = (d1*pn2.x - d2*pn1.x) / u.z
ip = dpv.vector(x,y,0)
return ip,ip + u
def _graph_boundary(self,g):
pgkeys = self._plugkeys()
bpkeys = []
bpcnt = len(self.boundary)
for bpx in range(bpcnt):
bp = self.boundary[bpx]
bpkeys.append((bp.x,bp.y,0))
epxs = self._plugsonedge(bpx,layer = 0)
bplugs = [dpv.vector(*pgkeys[x]) for x in epxs]
if bplugs:
poepxs = dpv.proximity_order_xy(bp,bplugs)
for poepx in poepxs:bpkeys.append(pgkeys[epxs[poepx]])
bpkeys.append(bpkeys[0])
g._add_edges(bpkeys,interpolated = False)
return g
def model(self):
p = dpv.zero()
d = dpv.z()
#ltree(-1)._realize(p,d)
total = dmo.model()
#tps = [(x,y) for x in range(3) for y in range(3)]
tps = [(x,y) for x in range(1) for y in range(1)]
for i,xy in enumerate(tps):
x,y = xy
kws = {'seed':i}
self.ltree._realize(p,d)
lmod = self.model
lmod.translate(dpv.vector(10*x,10*y,0))
total._consume(lmod)
return total
def model(self):
p = dpv.zero()
d = dpv.z()
#ltree(-1)._realize(p,d)
total = dmo.model()
#tps = [(x,y) for x in range(3) for y in range(3)]
tps = [(x, y) for x in range(1) for y in range(1)]
for i, xy in enumerate(tps):
x, y = xy
kws = {'seed': i}
self.ltree._realize(p, d)
lmod = self.model
lmod.translate(dpv.vector(10 * x, 10 * y, 0))
total._consume(lmod)
return total
def _connect_edges(self, o, sedgex, oedgex, g, **kwargs):
splugs, oplugs = self._plugsonedge(sedgex), o._plugsonedge(oedgex)
spgcnt, opgcnt = len(splugs), len(oplugs)
spkeys = self._plugkeys()
subspkeys = [spkeys[splugs[x]] for x in range(spgcnt)]
opkeys = o._plugkeys()
subopkeys = [opkeys[oplugs[x]] for x in range(opgcnt)]
b1, b2 = self._tangent(o).rotate_z(
dpr.rad(90)).normalize(), dpv.zhat.copy()
sps = dpv.projected_order([dpv.vector(*spk) for spk in subspkeys], b1,
b2)
ops = dpv.projected_order([dpv.vector(*opk) for opk in subopkeys], b1,
b2)
if spgcnt == opgcnt: pgpairs = [(x, y) for x, y in zip(sps, ops)]
else:
print('plug ambiguity!!!')
pdb.set_trace()
for pgpair in pgpairs:
pkey1, pkey2 = spkeys[splugs[pgpair[0]]], opkeys[oplugs[pgpair[1]]]
g._add_edge(pkey1, pkey2, **kwargs)
print('added edge', pkey1, pkey2)
def _graph_boundary(self, g):
pgkeys = self._plugkeys()
bpkeys = []
bpcnt = len(self.boundary)
for bpx in range(bpcnt):
bp = self.boundary[bpx]
bpkeys.append((bp.x, bp.y, 0))
epxs = self._plugsonedge(bpx, layer=0)
bplugs = [dpv.vector(*pgkeys[x]) for x in epxs]
if bplugs:
poepxs = dpv.proximity_order_xy(bp, bplugs)
for poepx in poepxs:
bpkeys.append(pgkeys[epxs[poepx]])
bpkeys.append(bpkeys[0])
g._add_edges(bpkeys, interpolated=False)
return g
def _spikes_nudge(self,graph,target):
ws = []
angles = []
tkeys = list(self.targetring.keys())
for tk in tkeys:
ekey = (self.key(),graph.nodes[tk].key())
edx = graph.edges_lookup[ekey]
ws.append(1.0 if graph.edges[edx].interpolated else 0.0)
angles.append(self.targetring[tk])
iangles = nudge(angles,ws,target = target)
nr = self._node_radius(graph)
for tk,na in zip(tkeys,iangles):
self.ring[tk] = na
#spike = dpv.xhat.copy().rotate_z(dpr.rad(na)).scale_u(8)
spike = dpv.vector(1,0,0).rotate_z(dpr.rad(na)).scale_u(nr)
self.spikes[tk] = spike
def _geo_from_profile(self,line,l,w,h,steps,stepheight,steplength):
topleft = [pt.copy().translate_x(-w/2.0) for pt in line]
topright = [pt.copy().translate_x(w/2.0) for pt in line]
bottom = dpr.point_line(dpv.zero(),dpv.vector(0,l,h),steps)
for bdx in range(steps):
bottom.insert(2*bdx+1,bottom[2*bdx+1].copy())
dpv.translate_coords_z(bottom[1:],-stepheight)
bottomleft = [pt.copy().translate_x(-w/2.0) for pt in bottom]
bottomright = [pt.copy().translate_x(w/2.0) for pt in bottom]
nfs = []
nfs.extend(self._bridge(topleft,topright))
nfs.extend(self._bridge(bottomleft,topleft))
nfs.extend(self._bridge(topright,bottomright))
nfs.extend(self._bridge(bottomright,bottomleft))
nfs.extend(self._quad(
topleft[-1],topright[-1],
bottomright[-1],bottomleft[-1]))
def box(l = 1,w = 1,h = 2):
import dilap.mesh.piecewisecomplex as pwc
plc = pwc.piecewise_linear_complex()
pts = []
pts.append(dpv.vector( 0, 0, 0))
pts.append(dpv.vector( l, 0, 0))
pts.append(dpv.vector( l, w, 0))
pts.append(dpv.vector( 0, w, 0))
pts.append(dpv.vector( 0, 0, h))
pts.append(dpv.vector( l, 0, h))
pts.append(dpv.vector( l, w, h))
pts.append(dpv.vector( 0, w, h))
dpv.translate_coords(pts,dpv.vector(-0.5*l,-0.5*w,0.0))
polygons = ((3,2,1,0),(4,5,6,7),(0,1,5,4),(1,2,6,5),(2,3,7,6),(3,0,4,7))
polygons = tuple((tuple(pts[x].copy() for x in p),()) for p in polygons)
plc.add_polygons(*polygons)
#dprf.profile_function(plc.triangulate)
#ax = plc.plot()
#plt.show()
return plc
def smatter():
g = graph()
g._node(node(dpv.vector(0,0,0)))
for x in range(100):
ndx = rm.choice(range(g.nodecount))
rcnt = len(g.nodes[ndx].ring)
if rcnt == 0:
ndd = dpv.xhat.copy()
ndd.rotate_z(dpr.rad(rm.choice(range(360))))
ndd.scale_u(rm.choice([100,200,300]))
elif rcnt == 1:
ndir = next(iter(g.nodes[ndx].ring.values()))
nda = ndir+180 if ndir < 180 else ndir - 180
ndd = dpv.xhat.copy().rotate_z(dpr.rad(nda))
ndd.scale_u(rm.choice([100,200,300]))
elif rcnt == 2:
r1,r2 = tuple(g.nodes[ndx].ring.values())
mpt = (r1+r2)/2.0
nda = mpt+180 if mpt < 180 else mpt - 180
ndd = dpv.xhat.copy().rotate_z(dpr.rad(nda))
ndd.scale_u(rm.choice([100,200,300]))
elif rcnt == 3:
t1,t2,t3 = tuple(g.nodes[ndx].ring.values())
d1,d2,d3 = adist(t1,t2),adist(t2,t3),adist(t3,t1)
if d1 > d2 and d1 > d3:nda = (t1+t2)/2.0
elif d2 > d1 and d2 > d3:nda = (t2+t3)/2.0
elif d3 > d1 and d3 > d2:nda = (t3+t1)/2.0
ndd = dpv.xhat.copy().rotate_z(dpr.rad(nda))
ndd.scale_u(rm.choice([100,200,300]))
elif rcnt == 4:
print('this node cannot be more connected!',ndx)
#g._extrude_safe(ndx,ndd)
g._extrude(ndx,ndd)
#g._update()
#ax = g.plot_xy()
#ax.set_aspect('equal')
#plt.show()
return g
def test():
import dilap.construct as dlc
p = dpv.zero()
d = dpv.z()
#pythagoras_tree()._realize(p,d)
#dragon_curve()._realize(p,d)
total = dmo.model()
#for l in range(5):tree(l)._realize(p,d)
ltree(-1)._realize(p,d)
tps = [(x,y) for x in range(3) for y in range(3)]
for i,xy in enumerate(tps):
x,y = xy
kws = {'seed':i}
lmod = ltree(-1,**kws)._realize(p,d).model
lmod.translate(dpv.vector(10*x,10*y,0))
total._consume(lmod)
dlc.build(total)
def cgstest():
p1 = (tuple(dpr.square(5,5)),())
p2 = (tuple(dpr.square(4,4,dpv.vector(0,0,0))),())
#p2 = (tuple(dpr.square(5,4,dpv.vector(4,0,0))),())
#p3 = (tuple(dpr.square(5,3,dpv.vector(8,0,0))),())
#dpr.rotate_polygon(p1,dpq.q_from_av(dpr.PI/2.0,dpv.x()))
#dpr.rotate_polygon(p2,dpq.q_from_av(dpr.PI/2.0,dpv.x()))
#dpr.rotate_polygon(p3,dpq.q_from_av(dpr.PI/2.0,dpv.x()))
ptest = polygon_union(p1,p2)
#ptest = polygon_union(ptest,p3)
#ptest = polygon_intersection(p1,p2)
#ptest = polygon_difference(p1,p2)
#ptest = merge_polygons([p1,p2,p3])
ax = plot_axes()
#for seg in p1segs:ax = plot_edges_xy(seg,ax)
#for seg in p2segs:ax = plot_edges_xy(seg,ax)
#plot_polygon_full(p1,ax)
#plot_polygon_full(p2,ax)
plot_polygon_full(ptest,ax)
#for pt in ptest:plot_polygon_full(pt,ax,lw = 4.0)
plt.show()
if ptest is None:print('unacceptable union')
else:
print('soo whats happeningjj?')
ax = plot_axes()
#for seg in p1segs:ax = plot_edges_xy(seg,ax)
#for seg in p2segs:ax = plot_edges_xy(seg,ax)
plot_polygon_full(p1,ax)
plot_polygon_full(p2,ax)
plot_polygon_full(ptest,ax,lw = 4.0)
#for pt in ptest:plot_polygon_full(pt,ax,lw = 4.0)
plt.show()
def icosphere(r = 1,n = 1):
import dilap.mesh.piecewisecomplex as pwc
plc = pwc.piecewise_linear_complex()
# create 12 vertices of a icosahedron
t = (1.0+math.sqrt(5.0))/2.0
pts = []
pts.append(dpv.vector(-1, t, 0))
pts.append(dpv.vector( 1, t, 0))
pts.append(dpv.vector(-1,-t, 0))
pts.append(dpv.vector( 1,-t, 0))
pts.append(dpv.vector( 0,-1, t))
pts.append(dpv.vector( 0, 1, t))
pts.append(dpv.vector( 0,-1,-t))
pts.append(dpv.vector( 0, 1,-t))
pts.append(dpv.vector( t, 0,-1))
pts.append(dpv.vector( t, 0, 1))
pts.append(dpv.vector(-t, 0,-1))
pts.append(dpv.vector(-t, 0, 1))
dpv.translate_coords(pts,dpv.center_of_mass(pts).flip())
triangles = []
# 5 faces around point 0
triangles.append((0,11,5))
triangles.append((0,5,1))
triangles.append((0,1,7))
triangles.append((0,7,10))
triangles.append((0,10,11))
# 5 adjacent faces
triangles.append((1,5,9))
triangles.append((5,11,4))
triangles.append((11,10,2))
triangles.append((10,7,6))
triangles.append((7,1,8))
# 5 faces around point 3
triangles.append((3,9,4))
triangles.append((3,4,2))
triangles.append((3,2,6))
triangles.append((3,6,8))
triangles.append((3,8,9))
# 5 adjacent faces
triangles.append((4,9,5))
triangles.append((2,4,11))
triangles.append((6,2,10))
triangles.append((8,6,7))
triangles.append((9,8,1))
def esplit(lk,u,v):
k = (u,v)
if not k in lk:
pts.append(dpv.midpoint(pts[u],pts[v]))
lk[k] = len(pts)-1
return lk[k]
def tsplit(lk,u,v,w):
m1 = esplit(lk,u,v)
m2 = esplit(lk,v,w)
m3 = esplit(lk,w,u)
return (m1,m3,u),(m2,m1,v),(m3,m2,w),(m1,m2,m3)
def split(itris):
otris = []
nwpts = {}
for t in itris:otris.extend(tsplit(nwpts,*t))
return otris
for nx in range(n):triangles = split(triangles)
for p in pts:p.normalize().scale_u(r)
polygons = tuple((tuple(pts[x].copy() for x in t),()) for t in triangles)
plc.add_polygons(*polygons)
#dprf.profile_function(plc.triangulate)
#plc.simplices = [(pts[u],pts[v],pts[w]) for u,v,w in triangles]
#plc.ghostbnds = []
#ax = plc.plot()
#plt.show()
return plc
def facade():
import dilap.mesh.piecewisecomplex as pwc
rim = [
dpv.vector(0,0,0),dpv.vector(15,0,0),
dpv.vector(15,0,4),dpv.vector(0,0,4)]
door = [
dpv.vector(-1,0,0.2),dpv.vector(1,0,0.2),
dpv.vector(1,0,3),dpv.vector(-1,0,3)]
dpv.translate_coords(door,dpv.vector(10,0,0))
wspline = dpv.vector_spline(
dpv.vector(2,0,3),dpv.vector(1.8,0,3.2),
dpv.vector(-1.8,0,3.2),dpv.vector(-2,0,3),10)
window = [
dpv.vector(-2,0,0.5),dpv.vector(2,0,0.5),
dpv.vector(2,0,3)]+wspline+[dpv.vector(-2,0,3)]
dpv.translate_coords(window,dpv.vector(5,0,0))
beam = [
dpv.vector(1,0,1),dpv.vector(2,0,1),
dpv.vector(2,0,9),dpv.vector(1,0,9)]
#fac = (rim,(door,window,beam)),(beam,())
fac = (rim,(door,window,beam)),
plc = pwc.piecewise_linear_complex()
plc.add_polygons(*fac)
#plc.translate_polygon(2,dpv.vector(0,0,10))
#plc.extrude_polygon(1,dpv.vector(0,1,0))
plc.triangulate()
#ax = plc.plot_xy()
#ax = plc.plot()
#plt.show()
return plc
def roof():
import dilap.mesh.piecewisecomplex as pwc
plc = pwc.piecewise_linear_complex()
h = 5
ebnd = (
dpv.vector(0,0,0),dpv.vector(10,0,0),
dpv.vector(10,10,0),dpv.vector(20,10,0),
dpv.vector(20,20,0),dpv.vector(0,20,0))
ibnd = (
dpv.vector(2,2,h),dpv.vector(8,2,h),
dpv.vector(8,12,h),dpv.vector(18,12,h),
dpv.vector(18,18,h),dpv.vector(2,18,h))
polygons = ((ebnd,(ibnd,)),)
plc.add_polygons(*polygons)
dprf.profile_function(plc.triangulate)
ax = plc.plot()
plt.show()
return plc
