def __init__(self, tbarmesh, xlo, xhi, ylo, yhi, boxwidth):
self.tbarmesh = tbarmesh
self.xpart = Partition1(xlo, xhi, int(math.ceil(
(xhi - xlo) / boxwidth)))
self.ypart = Partition1(ylo, yhi, int(math.ceil(
(yhi - ylo) / boxwidth)))
self.boxes = [[TriangleBox() for iy in range(self.ypart.nparts)]
for ix in range(self.xpart.nparts)]
def __init__(self, fname):
fin = open(fname)
probepts = [list(map(float, l.split()[:3])) for l in fin]
pxs = sorted(list(set(p[0] for p in probepts)))
pys = sorted(list(set(p[1] for p in probepts)))
parx = Partition1(pxs[0], pxs[-1], len(pxs) - 1)
pary = Partition1(pys[0], pys[-1], len(pys) - 1)
perrx = max(a - b for a, b in zip(parx.vs, pxs))
perry = max(a - b for a, b in zip(pary.vs, pys))
minz, maxz = min(p[2] for p in probepts), max(p[2] for p in probepts)
print("Minmax z", minz, maxz, "Error on probe partition evenness XY",
perrx, perry)
parx.vs = pxs
pary.vs = pys
self.probeptsmap = dict(((p[0], p[1]), p[2]) for p in probepts)
self.parx, self.pary = parx, pary
def BuildPixelGridStructures(self, optionwidthpixels, optionheightpixels):
# grids partitions defining the interval width of each pixel
self.xpixels = Partition1(self.xlo, self.xhi, optionwidthpixels)
if optionheightpixels == 0:
heightpixels = int(optionwidthpixels/(self.xhi - self.xlo)*(self.yhi - self.ylo) + 1)
newyhi = heightpixels*(self.xhi - self.xlo)/optionwidthpixels + self.ylo
if self.optionverbose:
print("Revising yhi from %.3f to %.3f to for a whole number of pixels" % (self.yhi, newyhi))
self.yhi = newyhi
else:
heightpixels = optionheightpixels
self.ypixels = Partition1(self.ylo, self.yhi, heightpixels)
xpixwid = self.xpixels.vs[1] - self.xpixels.vs[0]
ypixwid = self.ypixels.vs[1] - self.ypixels.vs[0]
if self.optionverbose:
print("numxpixels=%d each width=%.3f x0=%0.3f" % (self.xpixels.nparts, xpixwid, self.xpixels.vs[0]))
print("numypixels=%d each height=%.3f y0=%0.3f" % (self.ypixels.nparts, ypixwid, self.ypixels.vs[0]))
# partitions with interval boundaries down middle of each pixel with extra line each side for convenience
self.xpixmidsE = Partition1(self.xlo - xpixwid*0.5, self.xhi + xpixwid*0.5, self.xpixels.nparts + 1)
self.ypixmidsE = Partition1(self.ylo - ypixwid*0.5, self.yhi + ypixwid*0.5, self.ypixels.nparts + 1)
def MakeSlice(z):
rex = rd + 2.5
bm = barmesh.BarMesh()
bm.BuildRectBarMesh(Partition1(tbm.xlo-rex, tbm.xhi+rex, 45), Partition1(tbm.ylo-rex, tbm.yhi+rex, 37), z)
bms = barmeshcell.barmeshslicer(bm, iaballoffset, rd=rd, contourdotdiff=0.95, contourdelta=0.05, lamendgap=0.001)
bms.initializecutsanddistances()
currentcolour = -1
ncount = 0
while bms.barpolycuts:
currentcolour += 1
if currentcolour > bm.maxcellcolour:
currentcolour = 0
bms.splitbarpolyscolour(currentcolour)
ncount += 1
if ncount == 20:
print("breaking with", len(bms.barpolycuts))
break
#print([bc.GetCellMark().cellcolour for bc in bms.barpolycuts])
print("totaltime:", bms.totalproctime, "triangletime:", bms.trianglehacktime)
sendactivity("contours", contours=mainfunctions.BarMeshContoursF(bm, barmesh.PZ_BEYOND_R)[0])
fname = "/home/goatchurch/geom3d/barmesh/stlsamples/V29D_Fixed.stl"
bitmapx = 2500
bitmapy = 900
tstart = time.time()
def spinztox(t):
return (t[2], t[1], -t[0])
tbarmesh = TriangleBarMesh(fname, spinztox)
#sendactivity("clearalltriangles")
#sendactivity(codetriangles=tbarmesh.GetBarMeshTriangles())
trizcut = TriZCut(tbarmesh) # this is slow because it builds the boxing
ypixes = Partition1(tbarmesh.ylo - 0.2, tbarmesh.yhi + 0.2, bitmapy - 1)
zpix0 = tbarmesh.zlo - 0.1
zfactopix = ypixes.nparts / (ypixes.vs[-1] - ypixes.vs[0])
#zfactopix *= 0.5
# this is in Z (note rotation by spinztox)
# (here we can make a loop for each slice)
for ix in range(0, 51):
lx = ix / 50.0
xslice = Along(lx, tbarmesh.xlo, tbarmesh.xhi)
fname = "/home/goatchurch/geom3d/bitmapslices/whistle/slice%05d.png" % int(
xslice * 1000)
pngslice = PNGslice(fname, bitmapx, bitmapy)
for iy, y in enumerate(ypixes.vs):
ztcuts = trizcut.TriSurfCut(xslice, y)
iaballoffset = implicitareaballoffset.ImplicitAreaBallOffset(tbm)
imp.reload(barmesh)
imp.reload(triangleboxing)
imp.reload(mainfunctions)
imp.reload(barmeshcell)
sendactivity("clearalltriangles")
sendactivity("clearallcontours")
sendactivity("clearallpoints")
# initial rectbarmesh
rd = 1.5
rex = rd + 2.5
xpart = Partition1(tbm.xlo-rex, tbm.xhi+rex, 45)
ypart = Partition1(tbm.ylo-rex, tbm.yhi+rex, 37)
bm = barmesh.BarMesh()
bm.BuildRectBarMesh(xpart, ypart, z)
rd2 = max(xpart.vs[1]-xpart.vs[0], ypart.vs[1]-ypart.vs[0], rd*1.5) + 0.1
bms = barmeshcell.barmeshslicer(bm, iaballoffset, rd=rd, rd2=rd2, contourdotdiff=0.95, contourdelta=0.05, lamendgap=0.001)
bms.initializecutsanddistances()
bms.plotslicer(sendactivity)
sendactivity("points", points=bms.getbarendclos(bm.bars), materialnumber=2)
currentcolour = -1
transmaps = {"unit": lambda t: t, "swapyz": lambda t: (t[0], -t[2], t[1])}
tbm = TriangleBarMesh(options.stlfile, transmaps[options.transform])
if options.diskheight >= 0.0:
iaoffset = implicitareacyloffset.ImplicitAreaCylOffset(tbm)
else:
iaoffset = implicitareaballoffset.ImplicitAreaBallOffset(tbm)
# substitute in the numpy version. (with some accessor this could be used before construction of iaoffset)
from tribarmes import NTriangleBarMesh # could be in prep for any OpenCL stuff
if NTriangleBarMesh:
print("substituting NTriangleBarMesh!")
iaoffset.tbarmesh = NTriangleBarMesh(iaoffset.tbarmesh)
rex = options.rad + 2.5
xpart = Partition1(tbm.xlo - rex, tbm.xhi + rex, 145)
ypart = Partition1(tbm.ylo - rex, tbm.yhi + rex, 137)
zlevels = []
for i in range(0, options.nslices):
lam = (i + 0.5) / options.nslices
zlevels.append((tbm.zlo - options.rad) * (1 - lam) +
(tbm.zhi + options.rad) * lam)
fnameout = options.outputfile or (re.sub("\.stl$(?i)", "", options.stlfile) +
".tap")
ftapeout = open(fnameout, "w")
b2dcontournormals = False
sumtotalproctime = 0
for z in zlevels:
if options.diskheight >= 0.0: