basename = fn

if fn.endswith(".conf"):

basename = fn[:len(fn)-len(".conf")]

with open(fn, "r") as f:

content = f.read()

global config

config = config_pb2.Config()

config.in_filename = basename + ".stl"

config.out_filename = basename + ".ngc"

def __init__(self, tr):

self.p = tr.getPoints()

self.low = min(p.z for p in self.p)

self.high = max(p.z for p in self.p)

self.n = tr.n

def Horizontal(self):

if self.n.z < 0:

return False

return self.high - self.low >= 0 and self.high - self.low < 0.05

def Vertical(self):

d = self.n.dot(ocl.Point(0,0,1))

return abs(d) < 0.01

def Level(self):

ret = []

for p in pl:

ret.append([p.x, p.y, p.z])

points = []

for loop in loops:

for p in loop:

points.append(p)

p1 = prev - vertex.c

p2 = vertex.p - vertex.c

smaller_angle_ccw = (p1 ^ p2 > 0)

if vertex.type == 1: # CCW arc, positive iff smaller angle is CCW

return smaller_angle_ccw

else: # CW arc, positive if smaller angle is CW

vertices = curve.getVertices()

current = vertices[0].p

#print "start at (%.2f, %.2f) z=%.2f" % (current.x, current.y, z)

for v in vertices[1:]:

if v.type == 0:

#print "line to (%.2f,%.2f) z=%.2f" % (v.p.x, v.p.y, z)

myscreen.addActor(camvtk.Line(p1=(current.x, current.y, z), p2 = (v.p.x, v.p.y, z)))

else:

r = math.hypot(v.p.x-v.c.x, v.p.y-v.c.y)

#print "arc to (%.2f,%.2f) center=(%.2f,%.2f) r=%.2f z=%.2f" % (v.p.x, v.p.y, v.c.x, v.c.y, r, z)

src = vtk.vtkArcSource()

src.SetCenter(v.c.x, v.c.y, z)

src.SetPoint1(current.x, current.y, z)

src.SetPoint2(v.p.x, v.p.y, z)

src.SetResolution(20)

src.SetNegative(not IsNegative(current, v))

mapper = vtk.vtkPolyDataMapper()

mapper.SetInput(src.GetOutput())

actor = camvtk.CamvtkActor()

actor.SetMapper(mapper)

myscreen.addActor(actor)

levels = []

good = 0

total = 0

for t in s.getTriangles():

tr = TriangleProcessor(t)

total += 1

if tr.Horizontal():

levels.append(tr.Level())

good += 1

elif tr.Vertical():

good += 1

else:

p = seq(t.getPoints())

print "Triangles: good=", good, " total=", total, "percentage=", (good*100./total)

levels.sort()

essential_levels = []

i = 0

while i < len(levels):

l0 = levels[i]

j = i+1

while j < len(levels):

l1 = levels[j]

if l1 > l0 + config.vertical_tolerance:

break

j += 1

essential_levels.append(l0)

i = j

essential_levels.sort(reverse=True)

essential_levels = [l for l in essential_levels if l >= config.bottom]

if len(essential_levels) == 0 or essential_levels[len(essential_levels) - 1] != config.bottom:

essential_levels.append(config.bottom)

cutter = ocl.CylCutter(config.tool_diameter, 20)

level_loops = []

for l in essential_levels:

print "################## Making waterline at", l, "##############################"

wl = ocl.Waterline()

wl.setSTL(s)

wl.setCutter(cutter)

wl.setSampling(0.02)

wl.setZ(l + config.vertical_tolerance)

wl.run2()

level_loops.append(wl.getLoops())

ar = area.Area()

for loop in loops:

curve = area.Curve()

for p in loop:

curve.append(area.Point(p.x, p.y))

ar.append(curve)

ar.FitArcs()

ar.Reorder()

ret = []

for i, loops in enumerate(level_loops):

print "Processing", i, "th level:"

ar = MakeArea(loops)

print "Area made"

ret.append(ar)

print "Done processing"

outer_bound = area.Area(areas[len(areas) - 1])

outer_bound.Offset(-config.tool_diameter)

cut_levels = [ ]

cut_areas = [ ]

for i, ar in enumerate(areas):

for curve in outer_bound.getCurves():

ar.append(curve)

ar.Reorder()

cut_areas.append(ar)

cut_levels.append(levels[i])

tps = []

for i, ar in enumerate(areas):

print "Making", i, "th toolpath at", levels[i]

tp = ar.MakePocketToolpath(3.175, -3.175, config.step_over, True, False, 0)

tps.append(tp)

print " -- Got", len(tp), "curves"

print "Out:", len(tps), "levels"

cur_lev = config.top

cur_idx = 0

if config.machine_top or cur_lev < config.top - config.vertical_tolerance:

yield cur_lev, cur_idx

# Inv.: last level marked was cur_lev, and last index was cur_idx

while True:

if abs(cur_lev - levels[cur_idx]) < config.vertical_tolerance:

cur_idx += 1

if cur_idx >= len(levels):

break

cur_lev -= config.step_down

if cur_lev < levels[cur_idx] + config.vertical_tolerance:

cur_lev = levels[cur_idx]

if config.machine_top or cur_lev < config.top - config.vertical_tolerance:

levs = [ ]

tps = [ ]

for lev, i in StepDownLevels(tp_levels):

levs.append(lev)

tps.append(tp_paths[i])

def __init__(self, fn):

self.f = open(fn, "w")

def Print(self, *x):

s = [ str(t) for t in x ]

self.f.write(" ".join(s))

self.f.write('\n')

def Close(self):

nw.clearance_height = config.top + config.clearance_above_top

nw.feed_height = config.top + config.engage_above_top

nw.feed = config.feed

nw.plunge_feed = config.plunge_feed

nw.writer = FileWriter(fn)

nw.comment("============ START G-CODE ===============")

nw.preamble()

nw.pen_up()

pairs = zip(lev, paths)

for lev, path in sorted(pairs, key = lambda(p): -p[0]):

nw.comment("level=%s" % lev)

for curve in path:

vertices = curve.getVertices()

current = vertices[0].p

nw.xy_rapid_to(current.x, current.y)

nw.pen_down(lev)

for v in vertices[1:]:

if v.type == 0:

nw.line_to(v.p.x, v.p.y, lev)

else:

r = math.hypot(v.p.x - v.c.x, v.p.y - v.c.y)

nw.xy_arc_to(v.p.x, v.p.y, r, v.c.x, v.c.y, v.type != 1)

nw.pen_up()

nw.postamble()

nw.comment("============ END G-CODE ===============")