def execute(self, app):
rdoc = self["rdoc"]
radius = self["dia"] / 2
cw = self["cw"]
#print("go!")
blocks = []
for bid in app.editor.getSelectedBlocks():
#print(blocks[bid])
path = app.gcode.toPath(bid)[0]
#print(path)
block = Block("trochoid")
for segment in path:
#print(segment.A)
#block.append("g0 x0 y0")
#block.append("g1 x10 y10")
#block.append("g1 x20 y10")
#block.append("g0 x0 y0")
block.extend(self.trochoid(segment, rdoc, radius, cw))
blocks.append(block)
active = app.activeBlock()
app.gcode.insBlocks(
active, blocks, "Trochoidal created"
) #<<< insert blocks over active block in the editor
app.refresh() #<<< refresh editor
app.setStatus(_("Generated: Trochoidal")) #<<< feed back result
def execute(self, app):
#print("go!")
blocks = []
paths_base = []
paths_isl = []
for bid in app.editor.getSelectedBlocks():
if app.gcode[bid].operationTest('island'):
paths_isl.extend(app.gcode.toPath(bid))
else:
paths_base.extend(app.gcode.toPath(bid))
for island in paths_isl:
paths_newbase = []
while len(paths_base) > 0:
base = paths_base.pop()
base.intersectPath(island)
island.intersectPath(base)
newbase = Path("diff")
#Add segments from outside of islands:
for i, seg in enumerate(base):
if not island.isInside(seg.midPoint()):
newbase.append(seg)
#Add segments from islands to base
for i, seg in enumerate(island):
if base.isInside(seg.midPoint(
)): #and base.isInside(seg.A) and base.isInside(seg.B):
newbase.append(seg)
#Eulerize
paths_newbase.extend(newbase.eulerize())
#paths_newbase.extend(newbase.split2contours())
paths_base = paths_newbase
for base in paths_base:
print(base)
#base = base.eulerize(True)
block = Block("diff")
block.extend(app.gcode.fromPath(base))
blocks.append(block)
#active = app.activeBlock()
app.gcode.insBlocks(
-1, blocks,
"Diff") #<<< insert blocks over active block in the editor
app.refresh() #<<< refresh editor
app.setStatus(_("Generated: Diff")) #<<< feed back result
def execute(self, app):
#print("go!")
blocks = []
paths_base = []
paths_isl = []
for bid in app.editor.getSelectedBlocks():
if app.gcode[bid].operationTest('island'):
paths_isl.extend(app.gcode.toPath(bid))
else:
paths_base.extend(app.gcode.toPath(bid))
for island in paths_isl:
paths_newbase = []
while len(paths_base) > 0:
base = paths_base.pop()
base.intersectPath(island)
island.intersectPath(base)
newbase = Path("diff")
#Add segments from outside of islands:
for i,seg in enumerate(base):
if not island.isInside(seg.midPoint()):
newbase.append(seg)
#Add segments from islands to base
for i,seg in enumerate(island):
if base.isInside(seg.midPoint()): #and base.isInside(seg.A) and base.isInside(seg.B):
newbase.append(seg)
#Eulerize
paths_newbase.extend(newbase.eulerize())
#paths_newbase.extend(newbase.split2contours())
paths_base = paths_newbase
for base in paths_base:
print(base)
#base = base.eulerize(True)
block = Block("diff")
block.extend(app.gcode.fromPath(base))
blocks.append(block)
#active = app.activeBlock()
app.gcode.insBlocks(-1, blocks, "Diff") #<<< insert blocks over active block in the editor
app.refresh() #<<< refresh editor
app.setStatus(_("Generated: Diff")) #<<< feed back result
def execute(self, app):
rdoc = self["rdoc"]
radius = self["dia"]/2
cw = self["cw"]
circ = self["circ"]
#print("go!")
blocks = []
for bid in app.editor.getSelectedBlocks():
#print(blocks[bid])
path = app.gcode.toPath(bid)[0]
#print(path)
block = Block("trochoid")
entry = self["entry"]
for segment in path:
#print(segment.A)
#block.append("g0 x0 y0")
#block.append("g1 x10 y10")
#block.append("g1 x20 y10")
#block.append("g0 x0 y0")
if entry:
eblock = Block("trochoid-in")
eblock.append("G0 Z0")
eblock.append("G0 x"+str(segment.A[0])+" y"+str(segment.A[1]-radius))
eblock.append("G2 x"+str(segment.A[0])+" y"+str(segment.A[1]-radius)+" i"+str(0)+" j"+str(radius))
blocks.append(eblock)
entry = False
block.append("G0 Z0")
block.extend(self.trochoid(segment, rdoc, radius, cw, circ))
blocks.append(block)
active = app.activeBlock()
app.gcode.insBlocks(active, blocks, "Trochoidal created") #<<< insert blocks over active block in the editor
app.refresh() #<<< refresh editor
app.setStatus(_("Generated: Trochoidal")) #<<< feed back result
def execute(self, app):
#print("go!")
blocks = []
bid = app.editor.getSelectedBlocks()[0]
xbasepath = app.gcode.toPath(bid)[0]
bid = app.editor.getSelectedBlocks()[1]
xislandpath = app.gcode.toPath(bid)[0]
xbasepath.intersectPath(xislandpath)
xislandpath.intersectPath(xbasepath)
#xnewisland = self.pathBoolIntersection(xbasepath, xislandpath)
xnewisland = self.pathBoolIntersection(xislandpath, xbasepath)
#pth = Path("temp")
#basepath.invert()
#pth.extend(basepath)
#pth.extend(basepath)
##pth.invert()
block = Block("diff")
block.extend(app.gcode.fromPath(xnewisland))
blocks.append(block)
#block = Block("diff")
#block.extend(app.gcode.fromPath(pth))
#blocks.append(block)
active = app.activeBlock()
app.gcode.insBlocks(
active, blocks,
"Diff") #<<< insert blocks over active block in the editor
app.refresh() #<<< refresh editor
app.setStatus(_("Generated: Diff")) #<<< feed back result
def execute(self, app):
#print("go!")
blocks = []
bid = app.editor.getSelectedBlocks()[0]
xbasepath = app.gcode.toPath(bid)[0]
bid = app.editor.getSelectedBlocks()[1]
xislandpath = app.gcode.toPath(bid)[0]
xbasepath.intersectPath(xislandpath)
xislandpath.intersectPath(xbasepath)
#xnewisland = self.pathBoolIntersection(xbasepath, xislandpath)
xnewisland = self.pathBoolIntersection(xislandpath, xbasepath)
#pth = Path("temp")
#basepath.invert()
#pth.extend(basepath)
#pth.extend(basepath)
##pth.invert()
block = Block("intersect")
block.extend(app.gcode.fromPath(xnewisland))
blocks.append(block)
#block = Block("diff")
#block.extend(app.gcode.fromPath(pth))
#blocks.append(block)
active = app.activeBlock()
app.gcode.insBlocks(active, blocks, "Intersect") #<<< insert blocks over active block in the editor
app.refresh() #<<< refresh editor
app.setStatus(_("Generated: Intersect")) #<<< feed back result
def execute(self, app):
feed = self["feed"]
rdoc = self["rdoc"]
radius = self["dia"]/2
cw = self["cw"]
circ = self["circ"]
evenspacing = self["evenspacing"]
if cw: cwtext = 'cw'
else: cwtext = 'ccw'
if cw: arcg = 'g2'
else: arcg = 'g3'
#print("go!")
blocks = []
for bid in app.editor.getSelectedBlocks():
#print(blocks[bid])
path = app.gcode.toPath(bid)[0]
#print(path)
block = Block("trochoid "+cwtext+" "+str(radius*2)+"+"+str(rdoc))
block.append("F"+str(feed))
entry = self["entry"]
A=path[0].A
block.append("g0 x"+str(A[0])+" y"+str(A[1]))
block.append("G1 Z0")
for segment in path:
#print(segment.A)
#block.append("g0 x0 y0")
#block.append("g1 x10 y10")
#block.append("g1 x20 y10")
#block.append("g0 x0 y0")
if entry:
eblock = Block("trochoid-in")
eblock.append("G0 Z0")
eblock.append("G0 x"+str(segment.A[0])+" y"+str(segment.A[1]-radius))
eblock.append("G2 x"+str(segment.A[0])+" y"+str(segment.A[1]-radius)+" i"+str(0)+" j"+str(radius))
blocks.append(eblock)
entry = False
#Continuity BEGINING
block.append("g1 x"+str(segment.A[0])+" y"+str(segment.A[1]))
#block.append(arcg+" x"+str(segment.A[0])+" y"+str(segment.A[1])+" r"+str(radius/2))
phi = atan2(segment.B[1]-segment.A[1], segment.B[0]-segment.A[0])
#TODO: handle arc segments
#if segment.type == Segment.LINE:
#if segment.type in (Segment.CW, Segment.CCW):
#Compensate for uneven spacing
srdoc = rdoc
if evenspacing:
subsegs = segment.length()//rdoc
remainder = segment.length()%rdoc
if remainder != 0:
srdoc = segment.length()/(subsegs+1)
#Loop over subsegmnents of segment
i=0
while i<(segment.length()+srdoc):
pos=min(segment.length(), i)
B = segment.distPoint(pos)
block.extend(self.trochoid(A,B,radius,cw,circ))
A = B
i+=srdoc
#Continuity END
#block.append("g1 x"+str(segment.B[0])+" y"+str(segment.B[1]))
block.append(arcg+" x"+str(segment.B[0])+" y"+str(segment.B[1])+" r"+str(radius/2))
blocks.append(block)
active = app.activeBlock()
app.gcode.insBlocks(active, blocks, "Trochoidal created") #<<< insert blocks over active block in the editor
app.refresh() #<<< refresh editor
app.setStatus(_("Generated: Trochoidal")) #<<< feed back result
def execute(self, app):
feed = self["feed"]
rdoc = self["rdoc"]
radius = self["dia"]/2
cw = self["cw"]
circ = self["circ"]
evenspacing = self["evenspacing"]
if cw: cwtext = 'cw'
else: cwtext = 'ccw'
if cw: arcg = 'g2'
else: arcg = 'g3'
#print("go!")
blocks = []
for bid in app.editor.getSelectedBlocks():
#print(blocks[bid])
path = app.gcode.toPath(bid)[0]
#print(path)
block = Block("trochoid "+cwtext+" "+str(radius*2)+"+"+str(rdoc))
block.append("F"+str(feed))
entry = self["entry"]
A=path[0].A
block.append("g0 x"+str(A[0])+" y"+str(A[1]))
block.append("G1 Z0")
for segment in path:
#print(segment.A)
#block.append("g0 x0 y0")
#block.append("g1 x10 y10")
#block.append("g1 x20 y10")
#block.append("g0 x0 y0")
if entry:
eblock = Block("trochoid-in")
eblock.append("G0 Z0")
eblock.append("G0 x"+str(segment.A[0])+" y"+str(segment.A[1]-radius))
eblock.append("G2 x"+str(segment.A[0])+" y"+str(segment.A[1]-radius)+" i"+str(0)+" j"+str(radius))
blocks.append(eblock)
entry = False
#Continuity BEGINING
block.append("g1 x"+str(segment.A[0])+" y"+str(segment.A[1]))
#block.append(arcg+" x"+str(segment.A[0])+" y"+str(segment.A[1])+" r"+str(radius/2))
phi = atan2(segment.B[1]-segment.A[1], segment.B[0]-segment.A[0])
#TODO: handle arc segments
#if segment.type == Segment.LINE:
#if segment.type in (Segment.CW, Segment.CCW):
#Compensate for uneven spacing
srdoc = rdoc
if evenspacing:
subsegs = segment.length()//rdoc
remainder = segment.length()%rdoc
if remainder != 0:
srdoc = segment.length()/(subsegs+1)
#Loop over subsegmnents of segment
i=0
while i<(segment.length()+srdoc):
pos=min(segment.length(), i)
B = segment.distPoint(pos)
block.extend(self.trochoid(A,B,radius,cw,circ))
A = B
i+=srdoc
#Continuity END
#block.append("g1 x"+str(segment.B[0])+" y"+str(segment.B[1]))
block.append(arcg+" x"+str(segment.B[0])+" y"+str(segment.B[1])+" r"+str(radius/2))
blocks.append(block)
active = app.activeBlock()
app.gcode.insBlocks(active, blocks, "Trochoidal created") #<<< insert blocks over active block in the editor
app.refresh() #<<< refresh editor
app.setStatus(_("Generated: Trochoidal")) #<<< feed back result
def execute(self, app):
feed = self["feed"]
rdoc = self["rdoc"]
radius = self["dia"]/2
cw = self["cw"]
circ = self["circ"]
evenspacing = self["evenspacing"]
if cw: cwtext = 'cw'
else: cwtext = 'ccw'
if cw: arcg = 'g2'
else: arcg = 'g3'
#print("go!")
blocks = []
#Loop over selected blocks
for bid in app.editor.getSelectedBlocks():
#print(blocks[bid])
path = app.gcode.toPath(bid)[0]
#print(path)
#create new block which encorporates trochoidal path
block = Block("trochoid "+cwtext+" "+str(radius*2)+"+"+str(rdoc))
block.append("F"+str(feed))
entry = self["entry"]
A=path[0].A
block.append("g0 x"+str(A[0])+" y"+str(A[1]))
block.append("G1 Z0")
#Loop over segments within path
for segment in path:
#print(segment.A)
#create Block for circular entry into path
if entry:
eblock = Block("trochoid-in")
eblock.append("G0 Z0")
eblock.append("G0 x"+str(segment.A[0])+" y"+str(segment.A[1]-radius))
eblock.append("G2 x"+str(segment.A[0])+" y"+str(segment.A[1]-radius)+" i"+str(0)+" j"+str(radius))
blocks.append(eblock)
entry = False
#Continuity BEGINING
# calculate number of subsegments to be transformed to trochoidal motion
srdoc = rdoc
segmentLength = segment.length()
subsegs = segmentLength//rdoc
remainder = segmentLength%rdoc
#Compensate for uneven spacing
if evenspacing:
if remainder != 0:
subsegs = subsegs+1
srdoc = segmentLength/subsegs
remainder = 0
#Loop over subsegments of segment
startSegment=True
for i in range(1,int(subsegs)+1):
pos=i*srdoc
B = segment.distPoint(pos)
block.extend(self.trochoid(A,B,radius,cw,circ,startSegment))
A = B
# Lead in performed, so clear flag
startSegment=False
# Process remainder
if remainder > 0:
B = segment.distPoint(segmentLength)
block.extend(self.trochoid(A,B,radius,cw,circ,startSegment))
A = B
#Continuity END
#Move bit to center of cut (B) at end of segment
block.append(arcg+" x"+str(segment.B[0])+" y"+str(segment.B[1])+" r"+str(radius/2))
blocks.append(block)
active = app.activeBlock()
app.gcode.insBlocks(active, blocks, "Trochoidal created") #<<< insert blocks over active block in the editor
app.refresh() #<<< refresh editor
app.setStatus(_("Generated: Trochoidal")) #<<< feed back result
def execute(self, app):
# ae = self.fromMm("ae")
if self["splicesteps"] =="" or self["splicesteps"]<4:
steps=4/(2*pi)
else:
steps=self["splicesteps"]/(2*pi)
# manualsetting = self["manualsetting"]
manualsetting = 1
#=========== Converted to comment and changed for current compatibility ==============================
# cutradius = CNC.vars["trochcutdiam"]/2.0
cutradius = self["diam"]/2.0
# cutradius = CNC.vars["trochcutdiam"]/2.0
#=========================================================================================
zfeed = CNC.vars["cutfeedz"]
feed =CNC.vars["cutfeed"]
minimfeed =CNC.vars["cutfeed"]
if manualsetting:
if self["diam"]:
cutradius = self["diam"]/2.0
if self["zfeed"] and self["zfeed"]!="":
zfeed = self["zfeed"]
# if self["minimfeed"] and self["minimfeed"]!="":
# minimfeed = min (self["minimfeed"],feed)
if self["feed"] and self["feed"]!="":
feed = self["feed"]
if self["endmill"]:
self.master["endmill"].makeCurrent(self["endmill"])
# radius = CNC.vars["cutdiam"]/2.0
# radius = self["diam"]/2.0
toolRadius = CNC.vars["diameter"]/2.0
radius = max(0,cutradius-toolRadius)
oldradius=radius
#-----------------------------------------------------------
# helicalRadius = self["helicalDiam"]/2.0
# if helicalRadius=="":
# helicalRadius=radius
# else:
# helicalRadius=max(0,helicalRadius- toolRadius)
helicalRadius=radius
#-----------------------------------------------------------
# helicalRadius=min(0.99*toolRadius,helicalRadius)
# if radius!=0:
# helicalRadius= min(helicalRadius,radius)
helicalPerimeter=pi*2.0*helicalRadius
# helicalangle = self["helicalangle"]
# if helicalangle>89.5:
# helicalangle=89.5
# if helicalangle<0.01:
# helicalangle=0.01
# downPecking=helicalPerimeter*tan(radians(helicalangle))
cw = self["cw"]
surface = CNC.vars["surface"]
#=========== Converted to comment and changed for current compatibility ==============================
# zbeforecontact=surface+CNC.vars["zretract"]
# zbeforecontact=surface+CNC.vars["zretract"]
# hardcrust = surface - CNC.vars["hardcrust"]
# feedbeforecontact = CNC.vars["feedbeforecontact"]/100.0
# hardcrustfeed = CNC.vars["hardcrustfeed"]/100.0
zbeforecontact=surface
zbeforecontact=surface
hardcrust = surface
feedbeforecontact = zfeed
hardcrustfeed = feed
#=====================================================================================================
t_splice = self["TypeSplice"]
dtadaptative = 0.0001
adaptativepolice=0
# minimradius = min(radius, toolRadius*self["MinTrochDiam"]/(100))
# minimradius = min(radius, toolRadius*self["MinTrochDiam"]/(100))
# minimradius = min(radius, toolRadius*CNC.vars["mintrochdiam"]/(100))
atot = self.fromMm("ae")
# spiral_twists=(radius-helicalRadius)/atot#<<spiral ae smaller than ae (aprox 50%)
# if (radius-helicalRadius)%atot: spiral_twists=1+(radius-helicalRadius)//atot
spiral_twists=ceil(radius-helicalRadius)/atot#<<spiral ae smaller than ae (aprox 50%)
rpm = self["rpm"]
downPecking=helicalPerimeter*zfeed/feed
helicalangle=degrees(atan2(downPecking,helicalPerimeter))
# steps=self["splicesteps"]/2*pi
# K_Z = self["K_Z"]
# if K_Z == "":
# K_Z = 1.0
# K_XY = self["K_XY"]
# if K_XY == "":
# K_XY = 1.0
# s_z = self["S_z"]
# s_xy = self["S_xy"]
# xyfeed = CNC.vars["cutfeed"]
# zfeed *= K_Z
# xyfeed *=K_XY
# Get selected blocks from editor
# def trochprofile_bcnc(self, cutDiam=0.0, direction=None, offset=0.0, overcut=False,adaptative=False, adaptedRadius=0.0, tooldiameter=0.0, name=None):
# app.trochprofile_bcnc(trochcutdiam, direction, self["offset"], self["overcut"], self["adaptative"], cornerradius, CNC.vars["diameter"], name) #<< diameter only to information
# cornerradius = (cutradius - CNC.vars["diameter"]/2.0
direction=self["direction"]
if direction!="on (3d Path)":
targetDepth=self["targetDepth"]
depthIncrement=self["depthIncrement"]
# tabsnumber=self["tabsnumber"]
# tabsWidth=self["tabsWidth"]
# tabsHeight=self["tabsHeight"]
tabsnumber=tabsWidth=tabsHeight=0
app.trochprofile_bcnc(2*cutradius, direction,self["offset"], self["overcut"], self["adaptative"], radius, CNC.vars["diameter"],\
targetDepth, depthIncrement, tabsnumber, tabsWidth, tabsHeight)
app.refresh()
# app.editor.selectAll()
selBlocks = app.editor.getSelectedBlocks()
# if not selBlocks:
# app.editor.selectAll()
# selBlocks = app.editor.getSelectedBlocks()
if not selBlocks:
app.setStatus(_("Trochoid abort: Please select some path"))
return
#Check inputs
if cutradius <= toolRadius:
app.setStatus(_("Trochoid Cut Diameter has to be greater than End mill"))
return
if helicalRadius <= 0.0:
app.setStatus(_("Helical Descent Diameter has to be greater than End mill"))
return
if feed <= 0:
app.setStatus(_("Feed has to be greater than 0"))
return
if zfeed <= 0:
app.setStatus(_("Plunge Feed has to be greater than 0"))
return
if minimfeed <= 0:
app.setStatus(_("Minimum Adaptative Feed has to be greater than 0"))
return
#Get all segments from gcode
allSegments = self.extractAllSegments(app,selBlocks)
#Create holes locations
# allHoles=[]
for bidSegment in allSegments:
if len(bidSegment)==0:
continue
blocks = []
# n = self["name"]
# if not n or n=="default": n="Trochoidal_3D"
# newname = Block.operationName(path.name)
n="Troch3d"
tr_block = Block(n)
phi=oldphi=0# oldadaptativephi=0
oldsegm=[[0,0,0],[0,0,0]]
# segments ---------------------------------------------
for idx, segm in enumerate(bidSegment):
if idx >= 0:
if cw:
u = 1
arc = "G2"
else:
u = -1
arc = "G3"
# ////////////---------------------------------------------------------------------
# information: ---------------------------------------------------------------------
segLength = self.calcSegmentLength(segm)
# ---------------------------------------------
# tr_block.append("(seg length "+str(round(segLength,4))+" )")
# -----------------------------------------------------------------------------
# ////////----------------------------------------------------------------------
if idx == 0:
# tr_block.append("(-------------- PARAMETERS ------------------------)")
tr_block.append("(Cut diam "+str( cutradius*2 )+" (troch "+str(radius*2.0)+"+End mill "+str(toolRadius*2.0)+" ) Advance "+str(atot)+" )")
# tr_block.append("(Cut diam "+str(CNC.vars["trochcutdiam"])+" (troch "+str(radius*2.0)+" + End mill " + str(toolRadius*2.0)+" ) Advance "+str(atot)+" )")
# tr_block.append("(Min troch "+str(int(CNC.vars["mintrochdiam"]))+"% = "+str(minimradius*2.0)+"mm , min cut diam "+str(2*(minimradius+toolRadius))+"mm )")
tr_block.append("(Feed "+str(feed)+" Plunge feed "+ str(zfeed)+" )")
#tr_block.append("(Helical diam "+str(round((helicalRadius+toolRadius)*2,2))+" ( helical diam "+str(helicalRadius*2.0)+"+End mill "+str(toolRadius*2.0)+" )")
tr_block.append("(Helical descent angle " + str(round(helicalangle,2)) +" cut diam " + str(round(helicalRadius*2.0,3))+" drop by lap "\
+ str(round(downPecking,2)) + " )")
tr_block.append("(--------------------------------------------------)")
tr_block.append("(M06 T0 "+str(toolRadius*2.0)+" mm)")
tr_block.append("M03")
tr_block.append("S "+str(rpm))
tr_block.append("F "+str(feed))
# phi = atan2(segm[1][1]-segm[0][1], segm[1][0]-segm[0][0])
# oldphi=phi #<< declare initial angle
# l = self.pol2car(radius, phi+radians(90*u))
# r = self.pol2car(radius, phi+radians(-90*u))
# B = segm[1][0],segm[1][1],segm[1][2]
# bl = self.pol2car(radius, phi+radians(90*u), B)
# br = self.pol2car(radius, phi+radians(-90*u), B)
tr_block.append("( Seg: "+str(idx)+" length "+str(round(segLength,4))+" phi "+str(round(degrees(phi),2))+" )")#+ " oldphi "+str(round(oldphi*57.29,2))+" )")
tr_block.append("(Starting point)")
if (round(segm[1][1]-segm[0][1],4)==0 and round(segm[1][0]-segm[0][0],4)==0):
phi=1234567890
tr_block.append("(The original first movement is vertical)")
else:
tr_block.append("(The original first movement is not vertical)")
tr_block.append(CNC.zsafe())
# tr_block.append("g0 x "+str(B[0])+" y"+str(B[1])+" )")#" z "+str(B[2])+" )")
# tr_block.append(arc+" x"+str(bl[0])+" y"+str(bl[1])+" R "+str(radius/2.0)+" z"+str(B[2]))
# tr_block.append(arc+" x"+str(br[0])+" y"+str(br[1])+" i"+str(r[0]/2.0)+" j"+str(r[1]/2.0)) #<< as cutting
# tr_block.append(("g1 x "+str(br[0])+" y"+str(br[1])+" z"+str(B[2])))
# tr_block.append(arc+" x"+str(bl[0])+" y"+str(bl[1])+" i"+str(l[0])+" j"+str(l[1]))
# tr_block.append(arc+" x"+str(br[0])+" y"+str(br[1])+" i"+str(r[0])+" j"+str(r[1])+" z"+str(round(B[2],5))) #<< as cutting
# if t_splice=="Circular both sides rectified":
# tr_block.append(arc+" x"+str(bl[0])+" y"+str(bl[1])+" i"+str(-r[0])+" j"+str(-r[1]))
tr_block.append("(--------------------------------------------------)")
# tr_block.append(CNC.grapid(br[0],br[1],B[2]))
# tr_block.append(CNC.zsafe()) #<<< Move rapid Z axis to the safe height in Stock Material
# tr_block.append(CNC.zenter(surface)) # <<< TROCHOID CENTER
# tr_block.append(CNC.grapid(segm[1][0],segm[1][1],segm[1][2]))
# tr_block.append(CNC.zbeforecontact()) # <<< TROCHOID CENTER
# tr_block.append(CNC.xyslowentersurface(0,-45.0)) # <<< TROCHOID CENTER
# tr_block.append(("g0 z "+str(zbeforecontact)))
# tr_block.append("( new segment begins )")
# distance to trochoid center
# if there is movement in xy plane phi calculate
if (segm[1][1]-segm[0][1]!=0 or segm[1][0]-segm[0][0]!=0):
phi = atan2(segm[1][1]-segm[0][1], segm[1][0]-segm[0][0])
# On surface
# if segm[0][2]>zbeforecontact and segm[1][2]>zbeforecontact:
if segm[0][2]>surface and segm[1][2]>surface:
tr_block.append("(Seg: "+str(idx)+" length "+str(round(segLength,4))+" phi "+str(round(degrees(phi),2))+ " On Surface)" )
tr_block.append(CNC.grapid(segm[1][0],segm[1][1],segm[1][2]))
else:
tr_distance = self.center_distance(segm,atot)
A = segm[0][0],segm[0][1],segm[0][2]
d=segLength
ae = tr_distance[4]
# ////////////---------------------------------------------------------------------
# information: ---------------------------------------------------------------------
adv = tr_distance[3] #<<<
ap = tr_distance[2] # << =zadd
# ---------------------------------------------
tr_block.append("(-----------------------------------------)")
control_cameback = self.came_back(segm, oldsegm)
if control_cameback:
tr_block.append("(-------------> Came back !! <------------- )")#+str(control_cameback)+" )")
# tr_block.append("( old Ax "+str(round(oldsegm[0][0],3))+" Ay "+str(round(oldsegm[0][1],3))+" Bx "+ str(round(oldsegm[1][0],3))+" By "+ str(round(oldsegm[1][1],3))+" )")
# tr_block.append("( curr Ax "+str(round(segm[0][0],3))+" Ay "+str(round(segm[0][1],3))+" Bx "+ str(round(segm[1][0],3))+" By "+ str(round(segm[1][1],3))+" )")
if round(segLength,5) <= dtadaptative:
adaptativepolice+=1.0
tr_block.append("(Seg "+str(idx)+" adaptativepolice " +str(adaptativepolice)+" length "+str(round(segLength,5))+" )")
# /////////// Trochoid method //////////////////////////////////////////////////////////////////////////////
if adaptativepolice==0 or adaptativepolice >2.5:
tr_block.append("( Seg: "+str(idx)+" phi "+str(round(degrees(phi),2))+ " oldphi "+str(round(degrees(oldphi),2))+" length "+str(round(segLength,5))+" )")
tr_block.append("(ae: "+str(round(ae,5))+" dz: "+str(round(ap,4))+"adv: "+str(round(adv,4))+" )")
# tr_block.append("( Bx "+str(round(segm[1][0],2))+ " By "+ str(round(segm[1][1],2)))
# -----------------------------------------------------------------------------
# ////////----------------------------------------------------------------------
if control_cameback:
# adaptativepolice+=0.5
B = segm[1][0],segm[1][1],segm[1][2]
# tr_block.append(CNC.gline(segm[1][0],segm[1][1],segm[1][2]))
t_splice="came_back"
# tr_block.extend(self.trochoid(t_splice,A,B,minimradius,radius,oldphi,phi,cw))
tr_block.extend(self.trochoid(t_splice,A,B,0.0,radius,oldphi,phi,cw))
tr_block.append("F "+ str(feed))
t_splice = self["TypeSplice"]
else:
# from POINT A -- to ---> POINT B
if segLength<=adv:
tr_block.append("(Only one trochoid, oldphi "+str(round(degrees(oldphi),2))+" )")
tr_block.extend(self.trochoid(t_splice,A,B,oldradius,radius,oldphi,phi,cw))
while d >adv:
# first trochoid
# tr_block.append("d "+ str(d))
B = A[0]+tr_distance[0], A[1]+tr_distance[1], A[2]+tr_distance[2]
# intermediates points = trochoids points
# tr_block.append(CNC.gline(B[0],B[1],B[2])) # <<< TROCHOID CENTER
# tr_block.extend(self.trochoid(A,B,radius,phi,oldphi,cw))
tr_block.append("(distance to end segment "+str(round(d,4))+" )")
tr_block.extend(self.trochoid(t_splice,A,B,oldradius,radius,oldphi,phi,cw))
A=B
d-=adv
oldphi=phi
# last point
if B[0] != segm[1][0] or B[1] != segm[1][1] or B[2] != segm[1][2]:
B = segm[1][0],segm[1][1],segm[1][2]
# tr_block.append(CNC.gline(B[0],B[1],B[2])) # <<< TROCHOID CENTER
tr_block.append("(---last trochoid, distance to end segment "+str(round(d,4))+" ---)")
tr_block.extend(self.trochoid(t_splice,A,B,oldradius,radius,phi,phi,cw))
adaptativepolice=0
# /////// Adapative method //////////////////////////////////////////////////////////////////////////////////////////////////////////
# if oldphi==3600:
else:
if adaptativepolice==1:
#goes to de two warning movements
lastphi=oldphi
tr_block.append("( Alarm "+ str(adaptativepolice)+" Seg: "+str(idx)+" phi " + str(round(degrees(phi),2))\
+ "oldphi "+str(round(degrees(oldphi),2))+ " )")
# difangle=(phi-oldadaptativephi)
# tr_block.append("(dif angle:"+str(round(difangle,4))+" )")
# oldadaptativephi=oldphi=phi
# round(difangle,5)==round(pi,5):
elif adaptativepolice==2:
phi=lastphi
if control_cameback:# abs(round(difangle,6)) == (round(pi,6)):
tr_block.append("(Starts adaptative trochoids"+" adaptativepolice "+str(adaptativepolice) )
adaptativepolice +=0.5
elif adaptativepolice==2.5:
# tr_block.append("(-----------------------------------------)")
# adaptradius=minimradius
tr_block.append("(Adaptative Seg: "+str(idx)+" length "+str(round(segLength,5))+" phi "+str(round(degrees(phi),2))\
+" oldphi "+str(round(degrees(oldphi),2))+" )")
# tr_block.append("( Ax "+str(round(segm[0][0],2))+ " Ay "+ str(round(segm[0][1],2)))
# tr_block.append(CNC.gline(segm[1][0],segm[1][1],segm[1][2]))
# from POINT A -- to ---> POINT B
# if adaptativepolice==1:
tr_distance = self.center_distance(segm,atot/3.0) #<<< short advanc distances
A = segm[0][0],segm[0][1],segm[0][2]
d=segLength
ae = tr_distance[4]
adv = tr_distance[3] #<<<
d-=adv
while d >0:#adv:
# first trochoid
if d!=segLength-adv:
oldphi=phi
# tr_block.append("d "+ str(d))
B = A[0]+tr_distance[0], A[1]+tr_distance[1], A[2]+tr_distance[2]
#------------------------------
# adaptradius= a*d + minimradius
# if d=0 : adaptradius=minimradius
# if d=seglength : adaptradius=radius
# a=(radius-minimradius)/segLength
# adaptradius=a*d+minimradius
a=radius/segLength
adaptradius=(self.roundup(a*d,4))#+minimradius
#------------------------------
if t_splice!="Splices":
t_splice="Warpedarc"
tr_block.append("(from trochoid distance to end segment "+str(round(d,4))+" )")
tr_block.append("(adaptradius "+ str(round(adaptradius,4))+" radius " + str(radius)+" )")
# tr_block.append("F "+ str(feed*adaptradius//radius))
tr_block.append("F "+ str(minimfeed+(feed-minimfeed) *adaptradius//radius))
if adaptradius>0.0:
tr_block.extend(self.trochoid(t_splice,A,B,oldradius,adaptradius,oldphi,phi,cw))
else:
tr_block.append("(R= "+str(adaptradius)+ "not sent )")
# tr_block.append("G1 x"+str(round(B[0],4))+" y "+str(round(B[1],4))+" z "+str(round(B[2],4)))
A=B
d-=adv
oldradius=adaptradius
# oldadaptativephi=0
#REVISAR, A COMENTADO
# last point
# d=0
# oldradius=adaptradius
# adaptradius=minimradius
# if B[0] != segm[1][0] or B[1] != segm[1][1] or B[2] != segm[1][2]:
# B = segm[1][0],segm[1][1],segm[1][2]
# tr_block.append(CNC.gline(B[0],B[1],B[2])) # <<< TROCHOID CENTER
# tr_block.append("(last trochoid, from trochoid distance to end segment "+str(round(d,4))+" )")
# tr_block.append("(adaptradius "+ str(adaptradius)+" )")
# tr_block.append("F "+ str(feed*adaptradius//radius))
# tr_block.extend(self.trochoid(t_splice,A,B,oldradius,adaptradius,phi,phi,cw))
adaptativepolice=0
tr_block.append("(Adaptative Completed)")
tr_block.append("F "+ str(feed//3))
# if adaptativepolice>1:
t_splice = self["TypeSplice"]
# adaptativepolice=0
oldradius=radius
oldsegm=segm
oldphi=phi
# /////// Vertical movement ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
elif idx!=0:
tr_block.append("(Seg: "+str(idx)+" length "+str(round(segLength,4))+" phi "+str(round(degrees(phi),2))+" oldphi "+str(round(degrees(oldphi),2))+" )" )
tr_block.append("(Helical descent")
# descent
A=segm[0][0],segm[0][1],segm[0][2]
if segm[0][2] > segm[1][2]:
if segm[0][2] >zbeforecontact:# and segm[1][2]<=surface:
if segm[1][2]<=zbeforecontact:
B = segm[1][0],segm[1][1],max(segm[1][2],zbeforecontact)
tr_block.append("(Rapid helical to z before contact "+"helicalRadius "+str(helicalRadius)+" )")
if idx==1 and oldphi==1234567890:
tr_block.append("g0 x "+str(B[0])+" y"+str(B[1])+" )")#" z "+str(B[2])+" )")
tr_block.extend(self.helical(A,B,helicalRadius,phi,u))
# Instead of decreasing the speed, to avoid the jerkl, decrease the drop by lap
if segm[0][2] >surface:# and segm[1][2]<=surface:
if segm[1][2]<=surface:
tr_block.append("(Slow helical to surface )" )
A=A[0],A[1],zbeforecontact
d=A[2]-surface
adv=downPecking * feedbeforecontact
while d > adv:
B = segm[1][0],segm[1][1],max(segm[1][2],A[2]-adv)
tr_block.extend(self.helical(A,B,helicalRadius,phi,u))
A=A[0],A[1],B[2]
d-=adv
B = segm[1][0],segm[1][1],surface
tr_block.extend(self.helical(A,B,helicalRadius,phi,u))
if segm[0][2] >hardcrust:# and segm[1][2]<=surface:
if hardcrust< surface:
if segm[1][2]<=hardcrust:
tr_block.append("(Helical in hard crust)" )
A=A[0],A[1],surface
d=A[2]-hardcrust
adv=downPecking * hardcrustfeed
while d > adv:
B = segm[1][0],segm[1][1],max(segm[1][2],A[2]-adv)
tr_block.extend(self.helical(A,B,helicalRadius,phi,u))
A=A[0],A[1],B[2]
d-=adv
B = segm[1][0],segm[1][1],hardcrust
tr_block.extend(self.helical(A,B,helicalRadius,phi,u))
tr_block.append("(Helical to target )" )
A=A[0],A[1],hardcrust
d=A[2]-segm[1][2]
adv=downPecking
while d > adv:
B = segm[1][0],segm[1][1],A[2]-adv
tr_block.extend(self.helical(A,B,helicalRadius,phi,u))
A=A[0],A[1],B[2]
d-=adv
B = segm[1][0],segm[1][1],segm[1][2]
tr_block.extend(self.helical(A,B,helicalRadius,phi,u))
tr_block.append("(Flatten)")
tr_block.extend(self.helical(B,B,helicalRadius,phi,u))
if round(helicalRadius,4)!=round(radius,4):
tr_block.append("(Spiral adjustement)")
# tr_block.extend(self.trochoid(t_splice,B,B,radius,helicalRadius,phi,phi+4*pi,cw))
# steps=max(1,int(steps*radius*(spiral_twists)/2.0))
# steps=min(steps, 12*spiral_twists)
# steps*=spiral_twists
# tr_block.append("(Spiral steps "+str(steps)+" in "+str(int((spiral_twists/2.)+1))+" twists)")
# tr_block.append("(Spiral "+str(int((spiral_twists/2.)+1))+" twists)")
tr_block.append("(Spiral "+str(spiral_twists)+" twists)")
tr_block.extend(self.splice_generator(B,B,helicalRadius,radius,phi,phi-spiral_twists*2*pi, radians(-90),radians(-90),u,1.2*steps))
tr_block.append("(Target diameter)")
# tr_block.extend(self.helical(B,B,radius,phi,u))
tr_block.extend(self.trochoid(t_splice,B,B,radius,radius,phi,phi,cw))
# ascent
elif segm[1][2] > segm[0][2]:
tr_block.append("(Helical rapid ascentt "+"helicalRadius "+str(helicalRadius)+" )" )
B = segm[1][0],segm[1][1],segm[1][2]
tr_block.extend(self.helical(A,B,helicalRadius,phi,u))
# tr_block.append(CNC.grapid(center[0],center[1],center[2]))
# tr_block.extend(CNC.grapid(center))
# end of segment
# tr_block.append(CNC.gline(segm[1][0],segm[1][1],segm[1][2]))
# oldsegm=segm
tr_block.append("(-----------------------------------------)")
tr_block.append(CNC.zsafe()) #<<< Move rapid Z axis to the safe height in Stock Material
blocks.append(tr_block)
self.finish_blocks(app, blocks)
