def cutting_tool(diameter, corner_radius, length):
cutter = ocl.CylCutter(1.0, length) # dummy cutter
if corner_radius == 0.0:
cutter = ocl.CylCutter(diameter, length)
elif corner_radius > diameter / 2 - 0.000000001:
cutter = ocl.BallCutter(diameter, length)
else:
cutter = ocl.BullCutter(diameter, corner_radius, length)
return (cutter)
def OCLDefinition(self, surface):
import ocl
if self.type == TOOL_TYPE_BALLENDMILL:
return ocl.BallCutter(self.diameter + surface.material_allowance * 2, 1000)
elif self.type == TOOL_TYPE_CHAMFER or self.type == TOOL_TYPE_ENGRAVER:
return ocl.CylConeCutter(self.flat_radius * 2 + surface.material_allowance, self.diameter + surface.material_allowance * 2, self.cutting_edge_angle * math.pi/360)
else:
if self.corner_radius > 0.000000001:
return ocl.BullCutter(self.diameter + surface.material_allowance * 2, self.corner_radius, 1000)
else:
return ocl.CylCutter(self.diameter + surface.material_allowance * 2, 1000)
def ocl_sample(operation, chunks):
oclSTL = get_oclSTL(operation)
op_cutter_type = operation.cutter_type
op_cutter_diameter = operation.cutter_diameter
op_minz = operation.minz
if op_cutter_type == "VCARVE":
op_cutter_tip_angle = operation['cutter_tip_angle']
cutter = None
cutter_length = 5
if op_cutter_type == 'END':
cutter = ocl.CylCutter(
(op_cutter_diameter + operation.skin * 2) * 1000, cutter_length)
elif op_cutter_type == 'BALLNOSE':
cutter = ocl.BallCutter(
(op_cutter_diameter + operation.skin * 2) * 1000, cutter_length)
elif op_cutter_type == 'VCARVE':
cutter = ocl.ConeCutter(
(op_cutter_diameter + operation.skin * 2) * 1000,
op_cutter_tip_angle, cutter_length)
elif op_cutter_type == 'BALLCONE':
angle = math.degrees(
math.atan((op_cutter_diameter / 2) - operation.ball_radius) /
(operation.ball_cone_flute - operation.ball_radius))
print("BallCone angle:" + str(angle))
cutter = ocl.BallConeCutter(
(operation.ball_radius + operation.skin) * 2000,
(op_cutter_diameter + operation.skin * 2) * 1000,
math.radians(angle))
elif op_cutter_type == 'BULLNOSE':
cutter = ocl.BullCutter(
(op_cutter_diameter + operation.skin * 2) * 1000,
operaton.bull_corner_radius * 1000, cutter_length)
else:
print("Cutter unsupported: {0}\n".format(op_cutter_type))
quit()
bdc = ocl.BatchDropCutter()
bdc.setSTL(oclSTL)
bdc.setCutter(cutter)
for chunk in chunks:
for coord in chunk.points:
bdc.appendPoint(
ocl.CLPoint(coord[0] * 1000, coord[1] * 1000, op_minz * 1000))
bdc.run()
cl_points = bdc.getCLPoints()
return cl_points
def oclGetWaterline(operation, chunks):
layers = oclWaterlineLayerHeights(operation)
oclSTL = get_oclSTL(operation)
cutter_props = operation.getOpCuttingTool()
op_cutter_type = cutter_props.cutter_type
op_cutter_diameter = cutter_props.cutter_diameter
op_minz = operation.minz
if op_cutter_type == "VCARVE":
op_cutter_tip_angle = cutter_props.cutter_tip_angle
cutter = None
cutter_length = 150 #TODO: automatically determine necessary cutter length depending on object size
if op_cutter_type == 'END':
cutter = ocl.CylCutter(
(op_cutter_diameter + operation.skin * 2) * 1000, cutter_length)
elif op_cutter_type == 'BALLNOSE':
cutter = ocl.BallCutter(
(op_cutter_diameter + operation.skin * 2) * 1000, cutter_length)
elif op_cutter_type == 'VCARVE':
cutter = ocl.ConeCutter(
(op_cutter_diameter + operation.skin * 2) * 1000,
op_cutter_tip_angle, cutter_length)
else:
print("Cutter unsupported: {0}\n".format(op_cutter_type))
quit()
waterline = ocl.Waterline()
waterline.setSTL(oclSTL)
waterline.setCutter(cutter)
waterline.setSampling(0.1) #TODO: add sampling setting to UI
for height in layers:
print(str(height) + '\n')
waterline.reset()
waterline.setZ(height * OCL_SCALE)
waterline.run2()
wl_loops = waterline.getLoops()
for l in wl_loops:
chunks.append(camPathChunk(inpoints=[]))
for p in l:
chunks[-1].points.append(
(p.x / OCL_SCALE, p.y / OCL_SCALE, p.z / OCL_SCALE))
chunks[-1].append(chunks[-1].points[0])
chunks[-1].closed = True
chunks[-1].poly = sgeometry.Polygon(chunks[-1].points)
def ocl_sample(operation, chunks):
oclSTL = get_oclSTL(operation)
op_cutter_type = operation.cutter_type
op_cutter_diameter = operation.cutter_diameter
op_minz = operation.minz
op_cutter_tip_angle = math.radians(operation.cutter_tip_angle)/2
if op_cutter_type == "VCARVE":
cutter_length = (op_cutter_diameter/math.tan(op_cutter_tip_angle))/2
else:
cutter_length = 10
cutter = None
if op_cutter_type == 'END':
cutter = ocl.CylCutter((op_cutter_diameter + operation.skin * 2) * 1000, cutter_length)
elif op_cutter_type == 'BALLNOSE':
cutter = ocl.BallCutter((op_cutter_diameter + operation.skin * 2) * 1000, cutter_length)
elif op_cutter_type == 'VCARVE':
cutter = ocl.ConeCutter((op_cutter_diameter + operation.skin * 2) * 1000, op_cutter_tip_angle, cutter_length)
elif op_cutter_type =='CYLCONE':
cutter = ocl.CylConeCutter((operation.cylcone_diameter/2+operation.skin)*2000,(op_cutter_diameter + operation.skin * 2) * 1000, op_cutter_tip_angle)
elif op_cutter_type == 'BALLCONE':
cutter = ocl.BallConeCutter((operation.ball_radius + operation.skin) * 2000,
(op_cutter_diameter + operation.skin * 2) * 1000, op_cutter_tip_angle)
elif op_cutter_type =='BULLNOSE':
cutter = ocl.BullCutter((op_cutter_diameter + operation.skin * 2) * 1000,operation.bull_corner_radius*1000, cutter_length)
else:
print("Cutter unsupported: {0}\n".format(op_cutter_type))
quit()
bdc = ocl.BatchDropCutter()
bdc.setSTL(oclSTL)
bdc.setCutter(cutter)
for chunk in chunks:
for coord in chunk.points:
bdc.appendPoint(ocl.CLPoint(coord[0] * 1000, coord[1] * 1000, op_minz * 1000))
bdc.run()
cl_points = bdc.getCLPoints()
return cl_points
def waterline_time(zheights, diam, length, s, sampling):
t_total = time.time()
for zh in zheights:
cutter = ocl.BallCutter(diam, length)
wl = ocl.Waterline()
wl.setSTL(s)
wl.setCutter(cutter)
wl.setZ(zh)
wl.setSampling(sampling)
wl.setThreads(1)
wl.run()
cutter_loops = wl.getLoops()
for l in cutter_loops:
loops.append(l)
timeTotal = time.time() - t_total
print " ALL Waterlines done in ", timeTotal, " s"
return timeTotal
def ocl_sample(operation, chunks):
oclSTL = get_oclSTL(operation)
cutter_props = operation.getOpCuttingTool()
op_cutter_type = cutter_props.cutter_type
op_cutter_diameter = cutter_props.cutter_diameter
op_minz = operation.minz
if op_cutter_type == "VCARVE":
op_cutter_tip_angle = cutter_props.cutter_tip_angle
cutter = None
cutter_length = 5
if op_cutter_type == 'END':
cutter = ocl.CylCutter(
(op_cutter_diameter + operation.skin * 2) * 1000, cutter_length)
elif op_cutter_type == 'BALLNOSE':
cutter = ocl.BallCutter(
(op_cutter_diameter + operation.skin * 2) * 1000, cutter_length)
elif op_cutter_type == 'VCARVE':
cutter = ocl.ConeCutter(
(op_cutter_diameter + operation.skin * 2) * 1000,
op_cutter_tip_angle, cutter_length)
else:
print("Cutter unsupported: {0}\n".format(op_cutter_type))
quit()
# add BullCutter
bdc = ocl.BatchDropCutter()
bdc.setSTL(oclSTL)
bdc.setCutter(cutter)
for chunk in chunks:
for coord in chunk.points:
bdc.appendPoint(
ocl.CLPoint(coord[0] * 1000, coord[1] * 1000, op_minz * 1000))
bdc.run()
cl_points = bdc.getCLPoints()
return cl_points
def main():
print ocl.revision()
myscreen = camvtk.VTKScreen()
myscreen.camera.SetPosition(-8, -4, 25)
myscreen.camera.SetFocalPoint(4.5, 6, 0)
# axis arrows
camvtk.drawArrows(myscreen, center=(-1, -1, 0))
camvtk.drawOCLtext(myscreen)
octtext = camvtk.Text()
octtext.SetPos((70, myscreen.height - 600))
myscreen.addActor(octtext)
cltext = camvtk.Text()
cltext.SetPos((70, myscreen.height - 100))
myscreen.addActor(cltext)
stl = camvtk.STLSurf("../../stl/gnu_tux_mod.stl")
#myscreen.addActor(stl)
#stl.SetWireframe()
stl.SetColor((0.5, 0.5, 0.5))
polydata = stl.src.GetOutput()
s = ocl.STLSurf()
camvtk.vtkPolyData2OCLSTL(polydata, s)
print "STL surface read,", s.size(), "triangles"
#angle = math.pi/4
radius = 0.4
length = 10
cutter = ocl.BallCutter(2 * radius, length)
#cutter = ocl.CylCutter(2*radius, length)
# generate CL-points
minx = 0
dx = 0.1 / 0.2
maxx = 9
miny = 0
dy = cutter.getRadius() / 1.5
maxy = 12
z = -1
# this generates a list of CL-points in a grid
clpoints = pyocl.CLPointGrid(minx, dx, maxx, miny, dy, maxy, z)
# batchdropcutter
bdc = ocl.BatchDropCutter()
bdc.bucketSize = 10
bdc.setSTL(s)
bdc.setCutter(cutter)
#bdc.setThreads(1) # explicitly setting one thread is better for debugging
for p in clpoints:
bdc.appendPoint(p)
t_before = time.time()
bdc.run()
t_after = time.time()
calctime = t_after - t_before
print " BDC4 done in ", calctime, " s"
dropcutter_time = calctime
clpoints = bdc.getCLPoints()
#camvtk.drawCLPointCloud(myscreen, clpoints)
print " clpts= ", len(clpoints)
myscreen.render()
#myscreen.iren.Start()
#exit()
s = ocl.BallCutterVolume()
#s = ocl.CylCutterVolume()
#s.center = ocl.Point(-2.50,-0.6,0)
s.radius = cutter.getRadius()
s.length = cutter.getLength()
# screenshot writer
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(myscreen.renWin)
lwr = vtk.vtkPNGWriter()
lwr.SetInput(w2if.GetOutput())
cp = ocl.Point(5, 5, -6) # center of octree
#depths = [3, 4, 5, 6, 7, 8]
max_depth = 7
root_scale = 10
t = ocl.Octree(root_scale, max_depth, cp)
t.init(5)
n = 0 # the frame number
stockbox = ocl.PlaneVolume(1, 0, 0.1)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(0, 0, 8.9)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(1, 1, 0.1)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(0, 1, 11.9)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(1, 2, -0.5)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(0, 2, 3)
t.diff_negative(stockbox)
mc = ocl.MarchingCubes()
print "stock mc()...",
tris = mc.mc_tree(t) # t.mc_triangles()
print " mc() got ", len(tris), " triangles"
mc_surf = camvtk.STLSurf(triangleList=tris, color=camvtk.red)
mc_surf.SetColor(camvtk.cyan)
print "stock STLSurf()...",
myscreen.addActor(mc_surf)
print "done."
myscreen.render()
#myscreen.iren.Start()
#exit()
myscreen.removeActor(mc_surf)
renderinterleave = 10
step_time = 0
while (n < len(clpoints)):
cl = ocl.Point(clpoints[n].x, clpoints[n].y, clpoints[n].z)
s.setPos(cl)
#myscreen.addActor( camvtk.Point( center=(cl.x,cl.y,cl.z), color=camvtk.yellow))
print n, ": diff...",
t_before = time.time()
t.diff_negative(s)
t_after = time.time()
build_time = t_after - t_before
#print "done in ", build_time," s"
step_time = step_time + build_time
n = n + 1
if ((n % renderinterleave) == 0):
infotext = "Octree max_depth=%i \nCL-point %i of %i \ndiff()-time: %f ms/CL-point" % (
max_depth, n, len(clpoints),
1e3 * step_time / renderinterleave)
octtext.SetText(infotext)
postext = "X: %f\nY: %f\nZ: %f" % (cl.x, cl.y, cl.z)
cltext.SetText(postext)
cactors = camvtk.drawBallCutter(myscreen, cutter, cl)
print cactors
t_before = time.time()
print "mc()...",
tris = mc.mc_tree(t) #.mc_triangles()
t_after = time.time()
mc_time = t_after - t_before
print "done in ", mc_time, " s"
print " mc() got ", len(tris), " triangles"
mc_surf = camvtk.STLSurf(triangleList=tris, color=camvtk.red)
#mc_surf.SetWireframe()
mc_surf.SetColor(camvtk.cyan)
print " STLSurf()...",
myscreen.addActor(mc_surf)
print "done."
print " render()...",
myscreen.render()
myscreen.camera.Azimuth(0.5)
lwr.SetFileName("frames/cutsim_d9_frame" + ('%06d' % n) + ".png")
w2if.Modified()
lwr.Write()
print "done."
myscreen.removeActor(mc_surf)
for c in cactors:
myscreen.removeActor(c)
step_time = 0
#lwr.SetFileName("frames/mc8_frame"+ ('%06d' % n)+".png")
#myscreen.camera.Azimuth( 2 )
#myscreen.render()
#w2if.Modified()
#lwr.Write()
#mc_surf.SetWireframe()
#print "sleep...",
#time.sleep(1.02)
#print "done."
# move forward
#theta = n*dtheta
#sp1 = ocl.Point(s.center)
#s.center = ocl.Point( 1.7*math.cos(theta),1.3*math.sin(theta),thetalift*theta)
#sp2 = ocl.Point(s.center)
#print "line from ",sp1," to ",sp2
#if n is not nmax:
# myscreen.addActor( camvtk.Line( p1=(sp1.x,sp1.y,sp1.z),p2=(sp2.x,sp2.y,sp2.z), color=camvtk.red ) )
#print "center moved to", s.center
print " clpts= ", len(clpoints)
print "All done."
myscreen.iren.Start()
def main():
print(ocl.revision())
myscreen = camvtk.VTKScreen()
myscreen.camera.SetPosition(-8, -4, 25)
myscreen.camera.SetFocalPoint(4.5, 6, 0)
# axis arrows
camvtk.drawArrows(myscreen, center=(-1, -1, 0))
camvtk.drawOCLtext(myscreen)
octtext = camvtk.Text()
octtext.SetPos((70, myscreen.height - 600))
myscreen.addActor(octtext)
cltext = camvtk.Text()
cltext.SetPos((70, myscreen.height - 100))
myscreen.addActor(cltext)
stl = camvtk.STLSurf("../../stl/gnu_tux_mod.stl")
#myscreen.addActor(stl)
#stl.SetWireframe()
stl.SetColor((0.5, 0.5, 0.5))
polydata = stl.src.GetOutput()
s = ocl.STLSurf()
camvtk.vtkPolyData2OCLSTL(polydata, s)
print("STL surface read,", s.size(), "triangles")
#angle = math.pi/4
radius = 0.4
length = 5
cutter = ocl.BallCutter(2 * radius, length)
#cutter = ocl.CylCutter(2*radius, length)
# generate CL-points
minx = 0
dx = 0.1 / 0.4
maxx = 9
miny = 0
dy = cutter.getRadius() / 1.5
maxy = 12
z = -1
# this generates a list of CL-points in a grid
clpoints = pyocl.CLPointGrid(minx, dx, maxx, miny, dy, maxy, z)
# batchdropcutter
bdc = ocl.BatchDropCutter()
bdc.bucketSize = 7
bdc.setSTL(s)
bdc.setCutter(cutter)
#bdc.setThreads(1) # explicitly setting one thread is better for debugging
for p in clpoints:
bdc.appendPoint(p)
t_before = time.time()
bdc.run()
t_after = time.time()
calctime = t_after - t_before
print(" BDC4 done in ", calctime, " s")
dropcutter_time = calctime
clpoints = bdc.getCLPoints()
#camvtk.drawCLPointCloud(myscreen, clpoints)
print(" clpts= ", len(clpoints))
myscreen.render()
#myscreen.iren.Start()
#exit()
s = ocl.BallCutterVolume()
#s = ocl.CylCutterVolume()
#s.center = ocl.Point(-2.50,-0.6,0)
s.radius = cutter.getRadius()
s.length = cutter.getLength()
# screenshot writer
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(myscreen.renWin)
lwr = vtk.vtkPNGWriter()
lwr.SetInput(w2if.GetOutput())
cp = ocl.Point(5, 5, -3) # center of octree
#depths = [3, 4, 5, 6, 7, 8]
max_depth = 7
root_scale = 7
t = ocl.Octree(root_scale, max_depth, cp)
t.init(5)
n = 0 # the frame number
stockbox = ocl.PlaneVolume(1, 0, 0.1)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(0, 0, 8.9)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(1, 1, 0.1)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(0, 1, 11.9)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(1, 2, -0.5)
t.diff_negative(stockbox)
stockbox = ocl.PlaneVolume(0, 2, 3)
t.diff_negative(stockbox)
mc = ocl.MarchingCubes()
print("mc()...", )
tris = mc.mc_tree(t) #.mc_triangles()
print(" mc() got ", len(tris), " triangles")
mc_surf = camvtk.STLSurf(triangleList=tris, color=camvtk.red)
mc_surf.SetColor(camvtk.cyan)
print(" STLSurf()...", )
myscreen.addActor(mc_surf)
print("done.")
cl = ocl.Point(0, 0, 5)
cactors = camvtk.drawBallCutter(myscreen, cutter, cl)
myscreen.render()
#myscreen.iren.Start()
#exit()
myscreen.removeActor(mc_surf)
renderinterleave = len(clpoints) / 100
step_time = 0
#render_time = 0
while (n < len(clpoints)):
cl = ocl.Point(clpoints[n].x, clpoints[n].y, clpoints[n].z)
s.setPos(cl) # move the cutter
t_before = time.time()
t.diff_negative(s) # subtract cutter from stock
t_after = time.time()
build_time = t_after - t_before
step_time = step_time + build_time
n = n + 1
if n < (len(clpoints) - renderinterleave):
myscreen.removeActor(mc_surf)
for c in cactors:
myscreen.removeActor(c)
if ((n % renderinterleave) == 0):
cactors = camvtk.drawBallCutter(myscreen, cutter, cl)
t_before = time.time()
print("mc()...", )
tris = mc.mc_tree(t) #.mc_triangles()
mc_time = time.time() - t_before
print("done in ", mc_time, " s")
print(" mc() got ", len(tris), " triangles")
print(" STLSurf()...", )
t_before = time.time()
mc_surf = camvtk.STLSurf(triangleList=tris, color=camvtk.red)
#mc_surf.SetWireframe()
mc_surf.SetColor(camvtk.cyan)
myscreen.addActor(mc_surf)
print("done.")
print(" render()...", )
myscreen.render()
render_time = time.time() - t_before
myscreen.camera.Azimuth(0.1)
lwr.SetFileName("frames/cutsim_d10_frame" + ('%06d' % n) + ".png")
w2if.Modified()
call_ms = step_time / renderinterleave
print(renderinterleave, " diff() calls in", step_time, " = ",
call_ms, " ms/call")
infotext = "Octree max_depth=%i \nCL-point %i of %i \n%i CL-pts/frame\ndiff()-time: %1.3f s/CL-point\nmc()-time: %1.3f s/frame\nrender()-time: %1.3f s/frame\n%i Triangles" % (
max_depth, n, len(clpoints), renderinterleave, call_ms,
mc_time, render_time, len(tris))
octtext.SetText(infotext)
postext = "X: %f\nY: %f\nZ: %f" % (cl.x, cl.y, cl.z)
cltext.SetText(postext)
#lwr.Write() # uncomment to actually write files to disk
print("done.")
step_time = 0
#lwr.SetFileName("frames/mc8_frame"+ ('%06d' % n)+".png")
#myscreen.camera.Azimuth( 2 )
#myscreen.render()
#w2if.Modified()
#lwr.Write()
#mc_surf.SetWireframe()
#print "sleep...",
#time.sleep(1.02)
#print "done."
print(" clpts= ", len(clpoints))
print("All done.")
myscreen.iren.Start()
stl = camvtk.STLSurf(tempfile.gettempdir() + "/model0.stl")
stl_polydata = stl.src.GetOutput()
stl_surf = ocl.STLSurf()
camvtk.vtkPolyData2OCLSTL(stl_polydata, stl_surf)
csv_file = open(tempfile.gettempdir() + '/ocl_settings.txt', 'r')
op_cutter_type = csv_file.readline().split()[0]
op_cutter_diameter = float(csv_file.readline())
op_minz = float(csv_file.readline())
csv_file.close()
cutter_length = 5
if op_cutter_type == 'END':
cutter = ocl.CylCutter(op_cutter_diameter * 1000, cutter_length)
elif op_cutter_type == 'BALL':
cutter = ocl.BallCutter(op_cutter_diameter * 1000, cutter_length)
elif op_cutter_type == 'VCARVE':
cutter = ocl.ConeCutter(op_cutter_diameter * 1000, 1, cutter_length)
else:
print "Cutter unsupported: " + op_cutter_type + '\n'
quit()
#add BullCutter
bdc = ocl.BatchDropCutter()
bdc.setSTL(stl_surf)
bdc.setCutter(cutter)
csv_file = open(tempfile.gettempdir() + '/ocl_chunks.txt', 'r')
for text_line in csv_file:
sample_point = [float(coord) for coord in text_line.split()]
bdc.appendPoint(
ocl.CLPoint(sample_point[0] * 1000, sample_point[1] * 1000,
if __name__ == "__main__":
print ocl.revision()
myscreen = camvtk.VTKScreen()
#stl = camvtk.STLSurf("../stl/gnu_tux_mod.stl")
stl = camvtk.STLSurf("../stl/demo.stl")
myscreen.addActor(stl)
stl.SetWireframe()
stl.SetColor((0.5, 0.5, 0.5))
polydata = stl.src.GetOutput()
s = ocl.STLSurf()
camvtk.vtkPolyData2OCLSTL(polydata, s)
print "STL surface read,", s.size(), "triangles"
length = 5
cutter = ocl.BallCutter(1.4321, length)
#cutter = ocl.CylCutter(1.123, length)
#cutter = ocl.BullCutter(1.123, 0.2, length)
print cutter
minx = 0
dx = 0.1 / 6
maxx = 10
miny = 0
dy = 1
maxy = 10
z = -17
# this generates a list of CL-points in a grid
clpoints = pyocl.CLPointGrid(minx, dx, maxx, miny, dy, maxy, z)
print "generated grid with", len(clpoints), " CL-points"
b = ocl.Point(0, 1, 0)
myscreen.addActor(camvtk.Point(center=(b.x, b.y, b.z), color=(1, 0, 1)))
c = ocl.Point(0, 0, 0.0)
myscreen.addActor(camvtk.Point(center=(c.x, c.y, c.z), color=(1, 0, 1)))
myscreen.addActor(camvtk.Line(p1=(a.x, a.y, a.z), p2=(c.x, c.y, c.z)))
myscreen.addActor(camvtk.Line(p1=(c.x, c.y, c.z), p2=(b.x, b.y, b.z)))
myscreen.addActor(camvtk.Line(p1=(a.x, a.y, a.z), p2=(b.x, b.y, b.z)))
t = ocl.Triangle(b, c, a)
radius1 = 1
angle = math.pi / 4
length = 10
#cutter = ocl.ConeCutter(0.37, angle)
cutter = ocl.BallCutter(0.532, length)
#cutter = ocl.CylCutter(0.3, length)
#cutter = ocl.BullCutter(0.7,0.1, length)
# these cutters do not have offsets yet (?)
#cutter = ocl.CylConeCutter(0.2,0.5,math.pi/9)
#cutter = ocl.BallConeCutter(0.4,0.6,math.pi/9)
#cutter = ocl.BullConeCutter(0.4,0.1,0.7,math.pi/6)
#cutter = ocl.ConeConeCutter(0.4,math.pi/3,0.7,math.pi/6)
#cutter = ocl.ConeCutter(0.4, math.pi/3)
print cutter
offset = 0.1
c2 = cutter.offsetCutter(offset)
print c2
minx = -0.5
a = ocl.Point(0, 1, 0.3)
myscreen.addActor(camvtk.Point(center=(a.x, a.y, a.z), color=(1, 0, 1)))
b = ocl.Point(1, 0.5, 0.3)
myscreen.addActor(camvtk.Point(center=(b.x, b.y, b.z), color=(1, 0, 1)))
c = ocl.Point(0, 0, 0)
myscreen.addActor(camvtk.Point(center=(c.x, c.y, c.z), color=(1, 0, 1)))
myscreen.addActor(camvtk.Line(p1=(a.x, a.y, a.z), p2=(c.x, c.y, c.z)))
myscreen.addActor(camvtk.Line(p1=(c.x, c.y, c.z), p2=(b.x, b.y, b.z)))
myscreen.addActor(camvtk.Line(p1=(a.x, a.y, a.z), p2=(b.x, b.y, b.z)))
t = ocl.Triangle(b, c, a)
s = ocl.STLSurf()
s.addTriangle(t) # a one-triangle STLSurf
length = 10
#cutter = ocl.CylCutter(0.3, length)
cutter = ocl.BallCutter(0.3, length)
print "fiber..."
range = 4
Nmax = 100
yvals = [
float(n - float(Nmax) / 2) / Nmax * range for n in xrange(0, Nmax + 1)
]
xvals = [
float(n - float(Nmax) / 2) / Nmax * range for n in xrange(0, Nmax + 1)
]
zmin = -0.1
zmax = 0.5
zNmax = 20
dz = (zmax - zmin) / (zNmax - 1)
zvals = []
camvtk.drawOCLtext(myscreen) a = ocl.Point(0,1,0.2) b = ocl.Point(1,0.5,0.0) c = ocl.Point(0.1,0.1,0.0) myscreen.addActor(camvtk.Point(center=(a.x,a.y,a.z), color=(1,0,1))) myscreen.addActor(camvtk.Point(center=(b.x,b.y,b.z), color=(1,0,1))) myscreen.addActor(camvtk.Point(center=(c.x,c.y,c.z), color=(1,0,1))) myscreen.addActor( camvtk.Line(p1=(a.x,a.y,a.z),p2=(c.x,c.y,c.z)) ) myscreen.addActor( camvtk.Line(p1=(c.x,c.y,c.z),p2=(b.x,b.y,b.z)) ) myscreen.addActor( camvtk.Line(p1=(a.x,a.y,a.z),p2=(b.x,b.y,b.z)) ) t = ocl.Triangle(b,c,a) angle = math.pi/4 diameter=0.3 length=5 cutter1 = ocl.BallCutter(diameter, length) cutter2 = ocl.CylCutter(diameter, length) cutter3 = ocl.BullCutter(diameter, diameter/4, length) cutter4 = ocl.ConeCutter(diameter, angle, length) #cutter = cutter.offsetCutter( 0.1 ) range=2 Nmax = 50 yvals = [float(n-float(Nmax)/2)/Nmax*range for n in xrange(0,Nmax+1)] xvals = [float(n-float(Nmax)/2)/Nmax*range for n in xrange(0,Nmax+1)] zmin = -0.1 zmax = 0.25 zNmax =5 dz = (zmax-zmin)/(zNmax-1) zvals=[]
stlfile = "../../stl/gnu_tux_mod.stl"
surface = STLSurfaceSource(stlfile)
t_before = time.time()
zheights = [
0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6
]
#zheights=[float(1.0)] # for faster computation, calculate only one waterline
wl = ocl.Waterline() # total time 14 seconds on i7 CPU
#wl = ocl.AdaptiveWaterline() # this is slower, ca 60 seconds on i7 CPU
wl.setSTL(surface)
diam = 0.5
length = 10
cutter = ocl.BallCutter(
diam, length) # any ocl MillingCutter class should work here
wl.setCutter(cutter)
wl.setSampling(
0.0314
) # this should be smaller than the smallest details in the STL file
# AdaptiveWaterline() also has settings for minimum sampling interval (see c++ code)
all_loops = []
for zh in zheights:
print "calculating Waterline at z= ", zh
wl.reset()
wl.setZ(zh) # height for this waterline
wl.run()
all_loops.append(wl.getLoops())
t_after = time.time()
calctime = t_after - t_before
print " TOTAL Waterline time is: ", calctime, " s"
camvtk.vtkPolyData2OCLSTL(polydata, s)
print("STL surface read,", s.size(), "triangles")
far = 20
# far = 0.000002 generator 52 face_count crash
# far = 0.000010 crashes at n=192
camPos = 2* far
myscreen.camera.SetPosition(camPos/1000, camPos/1000, camPos)
myscreen.camera.SetClippingRange(-2*camPos,2*camPos)
myscreen.camera.SetFocalPoint(0.051, 0, 0)
cls = ocl.CutterLocationSurface(10)
cutter = ocl.BallCutter(2,10)
cls.setCutter(cutter)
cls.setSampling(1)
cls.setMinSampling(0.1)
cls.setSTL(s)
drawDiagram(myscreen, cls)
#vd = ocl.VoronoiDiagram(far,1200)
#vod = VD(myscreen,vd,scale)
#vod.setAll(vd)
#drawFarCircle(myscreen, scale*vd.getFarRadius(), camvtk.orange)
print("PYTHON All DONE.")
import ocl #help(ocl) # c = ocl.BallCutter(1, 2) print c.__doc__ print ocl.version() help(ocl.BallCutter(4, 5))
import ocl import math print ocl.revision() # cylinder c = ocl.CylCutter(2.345, 5) d = c.offsetCutter(0.1) print c print "offset: ",d print # ball c = ocl.BallCutter(2.345, 6) d = c.offsetCutter(0.1) print c print "offset: ",d print # bull c = ocl.BullCutter(2.345, 0.123, 6) d = c.offsetCutter(0.1) print c print "offset: ",d print # cone c = ocl.ConeCutter(2.345, math.pi/6) d = c.offsetCutter(0.1) print c print "offset: ",d
def _waterline(self, obj, s, bb):
import ocl
from PathScripts.PathUtils import depth_params, fmt
import time
def drawLoops(loops):
nloop = 0
waterlinestring = ""
waterlinestring += "(waterline begin)"
for loop in loops:
p = loop[0]
loopstring = "(loop begin)" + "\n"
loopstring += "G0 Z" + str(obj.SafeHeight.Value) + "\n"
loopstring += "G0 X" + \
str(fmt(p.x)) + " Y" + str(fmt(p.y)) + "\n"
loopstring += "G1 Z" + str(fmt(p.z)) + "\n"
for p in loop[1:]:
loopstring += "G1 X" + \
str(fmt(p.x)) + " Y" + str(fmt(p.y)) + \
" Z" + str(fmt(p.z)) + "\n"
zheight = p.z
p = loop[0]
loopstring += "G1 X" + \
str(fmt(p.x)) + " Y" + str(fmt(p.y)) + \
" Z" + str(fmt(zheight)) + "\n"
loopstring += "(loop end)" + "\n"
print " loop ", nloop, " with ", len(loop), " points"
nloop = nloop + 1
waterlinestring += loopstring
waterlinestring += "(waterline end)" + "\n"
return waterlinestring
depthparams = depth_params(obj.ClearanceHeight.Value, obj.SafeHeight.Value,
obj.StartDepth.Value, obj.StepDown, obj.FinishDepth.Value, obj.FinalDepth.Value)
# stlfile = "../../stl/gnu_tux_mod.stl"
# surface = STLSurfaceSource(stlfile)
surface = s
t_before = time.time()
zheights = depthparams.get_depths()
wl = ocl.Waterline()
# wl = ocl.AdaptiveWaterline() # this is slower, ca 60 seconds on i7
# CPU
wl.setSTL(surface)
diam = 0.5
length = 10.0
# any ocl MillingCutter class should work here
cutter = ocl.BallCutter(diam, length)
wl.setCutter(cutter)
# this should be smaller than the smallest details in the STL file
wl.setSampling(obj.SampleInterval)
# AdaptiveWaterline() also has settings for minimum sampling interval
# (see c++ code)
all_loops = []
for zh in zheights:
print "calculating Waterline at z= ", zh
wl.reset()
wl.setZ(zh) # height for this waterline
wl.run()
all_loops.append(wl.getLoops())
t_after = time.time()
calctime = t_after - t_before
n = 0
output = ""
for loops in all_loops: # at each z-height, we may get many loops
print " %d/%d:" % (n, len(all_loops))
output += drawLoops(loops)
n = n + 1
print "(" + str(calctime) + ")"
return output
def _waterline(self, obj, s, bb):
import time
import ocl
def drawLoops(loops):
nloop = 0
pp = []
pp.append(Path.Command("(waterline begin)"))
for loop in loops:
p = loop[0]
pp.append(Path.Command("(loop begin)"))
pp.append(Path.Command('G0', {"Z": obj.SafeHeight.Value, 'F': self.vertRapid}))
pp.append(Path.Command('G0', {'X': p.x, "Y": p.y, 'F': self.horizRapid}))
pp.append(Path.Command('G1', {"Z": p.z, 'F': self.vertFeed}))
for p in loop[1:]:
pp.append(Path.Command('G1', {'X': p.x, "Y": p.y, "Z": p.z, 'F': self.horizFeed}))
# zheight = p.z
p = loop[0]
pp.append(Path.Command('G1', {'X': p.x, "Y": p.y, "Z": p.z, 'F': self.horizFeed}))
pp.append(Path.Command("(loop end)"))
print(" loop ", nloop, " with ", len(loop), " points")
nloop = nloop + 1
pp.append(Path.Command("(waterline end)"))
return pp
depthparams = PathUtils.depth_params(obj.ClearanceHeight.Value, obj.SafeHeight.Value,
obj.StartDepth.Value, obj.StepDown, obj.FinishDepth.Value, obj.FinalDepth.Value)
t_before = time.time()
zheights = [i for i in depthparams]
wl = ocl.Waterline()
wl.setSTL(s)
if obj.ToolController.Tool.ToolType == 'BallEndMill':
cutter = ocl.BallCutter(obj.ToolController.Tool.Diameter, 5) # TODO: 5 represents cutting edge height. Should be replaced with the data from toolcontroller?
else:
cutter = ocl.CylCutter(obj.ToolController.Tool.Diameter, 5)
wl.setCutter(cutter)
# this should be smaller than the smallest details in the STL file
wl.setSampling(obj.SampleInterval)
# AdaptiveWaterline() also has settings for minimum sampling interval
# (see c++ code)
all_loops = []
print ("zheights: {}".format(zheights))
for zh in zheights:
print("calculating Waterline at z= ", zh)
wl.reset()
wl.setZ(zh) # height for this waterline
wl.run()
all_loops.append(wl.getLoops())
t_after = time.time()
calctime = t_after - t_before
n = 0
output = []
for loops in all_loops: # at each z-height, we may get many loops
print(" %d/%d:" % (n, len(all_loops)))
output.extend(drawLoops(loops))
n = n + 1
print("(" + str(calctime) + ")")
return output
#zheights=[]
"""
zheights.append(0.29)
zheights.append(0.28)
zheights.append(0.27)
zheights.append(0.26)
zheights.append(0.25)
"""
#zheights=[ -0.35, -0.25, -0.15, -0.05, 0.05, 0.15, 0.25]
#zheights=[ 0.1]
length = 10
diam = 0.6
cutter1 = ocl.CylCutter( diam , length )
cutter2 = ocl.BallCutter( diam , length )
cutter3 = ocl.BullCutter( diam , diam/5, length )
cutter4 = ocl.ConeCutter( diam , math.pi/5, length )
cutter5 = ocl.CylConeCutter(diam/float(3),diam,math.pi/float(9))
for zh in zheights:
loops = calcWaterline(zh, cutter5, s)
drawLoops(myscreen, loops[0], camvtk.red)
#loops = calcWaterline(zh, cutter2, s)
#drawLoops(myscreen, loops[0], camvtk.green)
#loops = calcWaterline(zh, cutter3, s)
#drawLoops(myscreen, loops[0], camvtk.yellow)
#loops = calcWaterline(zh, cutter4, s)
#drawLoops(myscreen, loops[0], camvtk.pink)
def _dropcutter(self, obj, s, bb):
import ocl
import time
if obj.ToolController.Tool.ToolType == 'BallEndMill':
cutter = ocl.BallCutter(obj.ToolController.Tool.Diameter, 5) # TODO: 5 represents cutting edge height. Should be replaced with the data from toolcontroller?
else:
cutter = ocl.CylCutter(obj.ToolController.Tool.Diameter, 5)
pdc = ocl.PathDropCutter() # create a pdc
pdc.setSTL(s)
pdc.setCutter(cutter)
pdc.setZ(obj.FinalDepth.Value + obj.DepthOffset.Value) # set minimumZ
pdc.setSampling(obj.SampleInterval)
# the max and min XY area of the operation
xmin = bb.XMin - obj.DropCutterExtraOffset.x
xmax = bb.XMax + obj.DropCutterExtraOffset.x
ymin = bb.YMin - obj.DropCutterExtraOffset.y
ymax = bb.YMax + obj.DropCutterExtraOffset.y
path = ocl.Path() # create an empty path object
if obj.DropCutterDir == 'Y':
Ny = int(bb.YLength / (cutter.getDiameter() * (obj.StepOver / 100.0)))
dy = float(ymax - ymin) / Ny # the y step-over
# add Line objects to the path in this loop
for n in xrange(0, Ny):
y = ymin + n * dy
p1 = ocl.Point(xmin, y, 0) # start-point of line
p2 = ocl.Point(xmax, y, 0) # end-point of line
if (n % 2 == 0): # even
l = ocl.Line(p1, p2) # line-object
else: # odd
l = ocl.Line(p2, p1) # line-object
path.append(l) # add the line to the path
else:
Nx = int(bb.XLength / (cutter.getDiameter() * (obj.StepOver / 100.0)))
dx = float(xmax - xmin) / Nx # the y step-over
# add Line objects to the path in this loop
for n in xrange(0, Nx):
x = xmin + n * dx
p1 = ocl.Point(x, ymin, 0) # start-point of line
p2 = ocl.Point(x, ymax, 0) # end-point of line
if (n % 2 == 0): # even
l = ocl.Line(p1, p2) # line-object
else: # odd
l = ocl.Line(p2, p1) # line-object
path.append(l) # add the line to the path
pdc.setPath(path)
# run drop-cutter on the path
t_before = time.time()
pdc.run()
t_after = time.time()
print("calculation took ", t_after - t_before, " s")
# retrieve the points
clp = pdc.getCLPoints()
print("points received: " + str(len(clp)))
# generate the path commands
output = []
output.append(Path.Command('G0', {'Z': obj.ClearanceHeight.Value, 'F': self.vertRapid}))
output.append(Path.Command('G0', {'X': clp[0].x, "Y": clp[0].y, 'F': self.horizRapid}))
output.append(Path.Command('G1', {'Z': clp[0].z, 'F': self.vertFeed}))
for c in clp:
output.append(Path.Command('G1', {'X': c.x, "Y": c.y, "Z": c.z, 'F': self.horizFeed}))
return output
def zigzag(filepath,
tool_diameter=3.0,
corner_radius=0.0,
step_over=1.0,
x0=-10.0,
x1=10.0,
y0=-10.0,
y1=10.0,
direction='X',
mat_allowance=0.0,
style=0,
clearance=5.0,
rapid_safety_space=2.0,
start_depth=0.0,
step_down=2.0,
final_depth=-10.0,
units=1.0):
mm = True
if math.fabs(units) > 0.000000001:
# ocl works in mm, so convert all values to mm
mm = False
tool_diameter *= units
corner_radius *= units
step_over *= units
x0 *= units
x1 *= units
y0 *= units
y1 *= units
mat_allowance *= units
clearance *= units
rapid_safety_space *= units
start_depth *= units
step_down *= units
final_depth *= units
# read the stl file, we know it is an ascii file because HeeksCNC made it
s = STLSurfFromFile(filepath)
cutter = ocl.CylCutter(1.0, 1.0) # a dummy-cutter for now
if corner_radius == 0.0:
cutter = ocl.CylCutter(tool_diameter + mat_allowance, 100.0)
elif corner_radius > tool_diameter / 2 - 0.000000001:
cutter = ocl.BallCutter(tool_diameter + mat_allowance, 100.0)
else:
cutter = ocl.BullCutter(tool_diameter + mat_allowance, corner_radius,
100.0)
if final_depth > start_depth:
raise 'final_depth > start_depth'
height = start_depth - final_depth
zsteps = int(height / math.fabs(step_down) + 0.999999)
zstep_down = height / zsteps
incremental_rapid_to = rapid_safety_space - start_depth
if incremental_rapid_to < 0: incremental_rapid_to = 0.1
dcf = ocl.PathDropCutter()
dcf.setSTL(s)
dcf.setCutter(cutter)
for k in range(0, zsteps):
z1 = start_depth - k * zstep_down
z0 = start_depth - (k + 1) * zstep_down
dcf.setZ(z0)
steps = int((y1 - y0) / step_over) + 1
if direction == 'Y': steps = int((x1 - x0) / step_over) + 1
sub_step_over = (y1 - y0) / steps
if direction == 'Y': sub_step_over = (x1 - x0) / steps
rapid_to = z1 + incremental_rapid_to
path = ocl.Path()
for i in range(0, steps + 1):
odd_numbered_pass = (i % 2 == 1)
u = y0 + float(i) * sub_step_over
if direction == 'Y': u = x0 + float(i) * sub_step_over
if style == 0: # one way
if direction == 'Y':
path.append(
ocl.Line(ocl.Point(u, y0, 0), ocl.Point(u, y1, 0)))
else:
path.append(
ocl.Line(ocl.Point(x0, u, 0), ocl.Point(x1, u, 0)))
cut_path(path, dcf, z1, mat_allowance, mm, units, rapid_to,
incremental_rapid_to)
path = ocl.Path()
if mm:
rapid(z=clearance)
else:
rapid(z=clearance / units)
else: # back and forth
if direction == 'Y':
if odd_numbered_pass:
path.append(
ocl.Line(ocl.Point(u, y1, 0), ocl.Point(u, y0, 0)))
if i < steps:
path.append(
ocl.Line(
ocl.Point(u, y0, 0),
ocl.Point(u + sub_step_over, y0,
0))) # feed across to next pass
else:
path.append(
ocl.Line(ocl.Point(u, y0, 0), ocl.Point(u, y1, 0)))
if i < steps:
path.append(
ocl.Line(
ocl.Point(u, y1, 0),
ocl.Point(u + sub_step_over, y1,
0))) # feed across to next pass
else: # 'X'
if odd_numbered_pass:
path.append(
ocl.Line(ocl.Point(x1, u, 0), ocl.Point(x0, u, 0)))
if i < steps:
path.append(
ocl.Line(
ocl.Point(x0, u, 0),
ocl.Point(x0, u + sub_step_over,
0))) # feed across to next pass
else:
path.append(
ocl.Line(ocl.Point(x0, u, 0), ocl.Point(x1, u, 0)))
if i < steps:
path.append(
ocl.Line(
ocl.Point(x1, u, 0),
ocl.Point(x1, u + sub_step_over,
0))) # feed across to next pass
if style != 0: # back and forth
cut_path(path, dcf, z1, mat_allowance, mm, units, rapid_to,
incremental_rapid_to)
if mm:
rapid(z=clearance)
else:
rapid(z=clearance / units)
def drawScreen(a, b, c, filename, write_flag):
print(ocl.version())
myscreen = camvtk.VTKScreen()
#a = ocl.Point(0,1,0.3)
myscreen.addActor(camvtk.Point(center=(a.x, a.y, a.z), color=(1, 0, 1)))
#b = ocl.Point(1,0.5,0.3)
myscreen.addActor(camvtk.Point(center=(b.x, b.y, b.z), color=(1, 0, 1)))
#c = ocl.Point(-0.1,0.3,0.0)
myscreen.addActor(camvtk.Point(center=(c.x, c.y, c.z), color=(1, 0, 1)))
myscreen.addActor(camvtk.Line(p1=(a.x, a.y, a.z), p2=(c.x, c.y, c.z)))
myscreen.addActor(camvtk.Line(p1=(c.x, c.y, c.z), p2=(b.x, b.y, b.z)))
myscreen.addActor(camvtk.Line(p1=(a.x, a.y, a.z), p2=(b.x, b.y, b.z)))
t = ocl.Triangle(b, c, a)
s = ocl.STLSurf()
s.addTriangle(t) # a one-triangle STLSurf
zheights = [
-0.3, -0.2, -0.1, -0.05, 0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.26, 0.27,
0.28, 0.29
] # the z-coordinates for the waterlines
zheights = [
-0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, -0.05, 0.0, 0.05, 0.1,
0.15, 0.2, 0.28
]
zheights = [
-0.35, -0.3, -0.25, -0.2, -0.15, -0.1, -0.05, 0.0, 0.05, 0.1, 0.15,
0.2, 0.25, 0.28
]
zheights = []
Nmax = 20
zmin = -0.5
zmax = -0.05
dz = (zmax - zmin) / float(Nmax - 1)
z = zmin
for n in range(Nmax):
zheights.append(z)
z = z + dz
zheights = []
zheights.append(-0.25)
#zheights=[ -0.35, -0.25, -0.15, -0.05, 0.05, 0.15, 0.25]
#zheights=[ 0.1]
length = 10
diam = 0.6
cutter1 = ocl.CylCutter(diam, length)
cutter2 = ocl.BallCutter(diam, length)
cutter3 = ocl.BullCutter(diam, diam / 5, length)
cutter4 = ocl.ConeCutter(diam, math.pi / 5, length)
for zh in zheights:
#loops = calcWaterline(zh, cutter1, s)
#drawLoops(myscreen, loops[0], camvtk.yellow)
#loops = calcWaterline(zh, cutter2, s)
#drawLoops(myscreen, loops[0], camvtk.green)
#loops = calcWaterline(zh, cutter3, s)
#drawLoops(myscreen, loops[0], camvtk.yellow)
loops = calcWaterline(zh, cutter4, s)
drawLoops(myscreen, loops[0], camvtk.pink)
#for f in loops[1]:
# drawFiber(myscreen, f, camvtk.red)
#for f in loops[2]:
# drawFiber(myscreen, f, camvtk.lblue)
print("done.")
myscreen.camera.SetPosition(1, -1, 3)
myscreen.camera.SetFocalPoint(0.5, 0.5, 0)
camvtk.drawArrows(myscreen, center=(-0.5, -0.5, -0.5))
camvtk.drawOCLtext(myscreen)
myscreen.render()
"""
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(myscreen.renWin)
lwr = vtk.vtkPNGWriter()
lwr.SetInput( w2if.GetOutput() )
w2if.Modified()
lwr.SetFileName(filename)
if write_flag:
lwr.Write()
print("wrote ",filename)
"""
time.sleep(1)
