#!/usr/bin/env python
"""
Comments starting "#LT" or "#CLT" are by Chris Lusby Taylor who rewrote the engraving function in 2011.
History of CLT changes to engraving and other functions it uses:
9 May 2011 Changed test of tool diameter to square it
10 May Note that there are many unused functions, including:
bound_to_bound_distance, csp_curvature_radius_at_t,
csp_special_points, csplength, rebuild_csp, csp_slope,
csp_simple_bound_to_point_distance, csp_bound_to_point_distance,
bez_at_t, bez_to_point_distance, bez_normalized_slope, matrix_mul, transpose
Fixed csp_point_inside_bound() to work if x outside bounds
20 May Now encoding the bisectors of angles.
23 May Using r/cos(a) instead of normalised normals for bisectors of angles.
23 May Note that Z values generated for engraving are in pixels, not mm.
Removed the biarc curves - straight lines are better.
24 May Changed Bezier slope calculation to be less sensitive to tiny differences in points.
Added use of self.options.engraving_newton_iterations to control accuracy
25 May Big restructure and new recursive function.
Changed the way I treat corners - I now find if the centre of a proposed circle is
within the area bounded by the line being tested and the two angle bisectors at
its ends. See get_radius_to_line().
29 May Eliminating redundant points. If A,B,C colinear, drop B
30 May Eliminating redundant lines in divided Beziers. Changed subdivision of lines
7Jun Try to show engraving in 3D
8 Jun Displaying in stereo 3D.
Fixed a bug in bisect - it could go wrong due to rounding errors if
1+x1.x2+y1.y2<0 which should never happen. BTW, I spotted a non-normalised normal
returned by csp_normalized_normal. Need to check for that.
9 Jun Corrected spelling of 'definition' but still match previous 'defention' and 'defenition' if found in file
Changed get_tool to find 1.6.04 tools or new tools with corrected spelling
10 Jun Put 3D into a separate layer called 3D, created unless it already exists
Changed csp_normalized_slope to reject lines shorter than 1e-9.
10 Jun Changed all dimensions seen by user to be mm/inch, not pixels. This includes
tool diameter, maximum engraving distance, tool shape and all Z values.
12 Jun ver 208 Now scales correctly if orientation points moved or stretched.
12 Jun ver 209. Now detect if engraving toolshape not a function of radius
Graphics now indicate Gcode toolpath, limited by min(tool diameter/2,max-dist)
TODO Change line division to be recursive, depending on what line is touched. See line_divide
engraving() functions (c) 2011 Chris Lusby Taylor, clusbytaylor@enterprise.net
Copyright (C) 2009 Nick Drobchenko, nick@cnc-club.ru
based on gcode.py (C) 2007 hugomatic...
based on addnodes.py (C) 2005,2007 Aaron Spike, aaron@ekips.org
based on dots.py (C) 2005 Aaron Spike, aaron@ekips.org
based on interp.py (C) 2005 Aaron Spike, aaron@ekips.org
based on bezmisc.py (C) 2005 Aaron Spike, aaron@ekips.org
based on cubicsuperpath.py (C) 2005 Aaron Spike, aaron@ekips.org
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
###
### Gcodetools v 1.7
###
gcodetools_current_version = "1.7"
# standard library
import os
import math
import bezmisc
import re
import copy
import sys
import time
import cmath
import numpy
import codecs
import random
# local library
import inkex
import simplestyle
import simplepath
import cubicsuperpath
import simpletransform
import bezmisc
inkex.localize()
### Check if inkex has errormsg (0.46 version does not have one.) Could be removed later.
if "errormsg" not in dir(inkex):
inkex.errormsg = lambda msg: sys.stderr.write((unicode(msg) + "\n").encode("UTF-8"))
def bezierslopeatt(((bx0,by0),(bx1,by1),(bx2,by2),(bx3,by3)),t):
ax,ay,bx,by,cx,cy,x0,y0=bezmisc.bezierparameterize(((bx0,by0),(bx1,by1),(bx2,by2),(bx3,by3)))
dx=3*ax*(t**2)+2*bx*t+cx
dy=3*ay*(t**2)+2*by*t+cy
if dx==dy==0 :
dx = 6*ax*t+2*bx
dy = 6*ay*t+2*by
if dx==dy==0 :
dx = 6*ax
dy = 6*ay
if dx==dy==0 :
print_("Slope error x = %s*t^3+%s*t^2+%s*t+%s, y = %s*t^3+%s*t^2+%s*t+%s, t = %s, dx==dy==0" % (ax,bx,cx,dx,ay,by,cy,dy,t))
print_(((bx0,by0),(bx1,by1),(bx2,by2),(bx3,by3)))
dx, dy = 1, 1
return dx,dy
bezmisc.bezierslopeatt = bezierslopeatt
def ireplace(self,old,new,count=0):
pattern = re.compile(re.escape(old),re.I)
return re.sub(pattern,new,self,count)
def isset(variable):
# VARIABLE NAME SHOULD BE A STRING! Like isset("foobar")
return variable in locals() or variable in globals()
################################################################################
###
### Styles and additional parameters
###
################################################################################
math.pi2 = math.pi*2
straight_tolerance = 0.0001
straight_distance_tolerance = 0.0001
engraving_tolerance = 0.0001
loft_lengths_tolerance = 0.0000001
EMC_TOLERANCE_EQUAL = 0.00001
options = {}
defaults = {
'header': """%
(Header)
(Generated by gcodetools from Inkscape.)
(Using default header. To add your own header create file "header" in the output dir.)
M3
(Header end.)
""",
'footer': """
(Footer)
M5
G00 X0.0000 Y0.0000
M2
(Using default footer. To add your own footer create file "footer" in the output dir.)
(end)
%"""
}
intersection_recursion_depth = 10
intersection_tolerance = 0.00001
styles = {
"in_out_path_style" : simplestyle.formatStyle({ 'stroke': '#0072a7', 'fill': 'none', 'stroke-width':'1', 'marker-mid':'url(#InOutPathMarker)' }),
"loft_style" : {
'main curve': simplestyle.formatStyle({ 'stroke': '#88f', 'fill': 'none', 'stroke-width':'1', 'marker-end':'url(#Arrow2Mend)' }),
},
"biarc_style" : {
'biarc0': simplestyle.formatStyle({ 'stroke': '#88f', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'biarc1': simplestyle.formatStyle({ 'stroke': '#8f8', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'line': simplestyle.formatStyle({ 'stroke': '#f88', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'area': simplestyle.formatStyle({ 'stroke': '#777', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.1' }),
},
"biarc_style_dark" : {
'biarc0': simplestyle.formatStyle({ 'stroke': '#33a', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'biarc1': simplestyle.formatStyle({ 'stroke': '#3a3', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'line': simplestyle.formatStyle({ 'stroke': '#a33', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'area': simplestyle.formatStyle({ 'stroke': '#222', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.3' }),
},
"biarc_style_dark_area" : {
'biarc0': simplestyle.formatStyle({ 'stroke': '#33a', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.1' }),
'biarc1': simplestyle.formatStyle({ 'stroke': '#3a3', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.1' }),
'line': simplestyle.formatStyle({ 'stroke': '#a33', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.1' }),
'area': simplestyle.formatStyle({ 'stroke': '#222', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.3' }),
},
"biarc_style_i" : {
'biarc0': simplestyle.formatStyle({ 'stroke': '#880', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'biarc1': simplestyle.formatStyle({ 'stroke': '#808', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'line': simplestyle.formatStyle({ 'stroke': '#088', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'area': simplestyle.formatStyle({ 'stroke': '#999', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.3' }),
},
"biarc_style_dark_i" : {
'biarc0': simplestyle.formatStyle({ 'stroke': '#dd5', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'biarc1': simplestyle.formatStyle({ 'stroke': '#d5d', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'line': simplestyle.formatStyle({ 'stroke': '#5dd', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'1' }),
'area': simplestyle.formatStyle({ 'stroke': '#aaa', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.3' }),
},
"biarc_style_lathe_feed" : {
'biarc0': simplestyle.formatStyle({ 'stroke': '#07f', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'.4' }),
'biarc1': simplestyle.formatStyle({ 'stroke': '#0f7', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'.4' }),
'line': simplestyle.formatStyle({ 'stroke': '#f44', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'.4' }),
'area': simplestyle.formatStyle({ 'stroke': '#aaa', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.3' }),
},
"biarc_style_lathe_passing feed" : {
'biarc0': simplestyle.formatStyle({ 'stroke': '#07f', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'.4' }),
'biarc1': simplestyle.formatStyle({ 'stroke': '#0f7', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'.4' }),
'line': simplestyle.formatStyle({ 'stroke': '#f44', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'.4' }),
'area': simplestyle.formatStyle({ 'stroke': '#aaa', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.3' }),
},
"biarc_style_lathe_fine feed" : {
'biarc0': simplestyle.formatStyle({ 'stroke': '#7f0', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'.4' }),
'biarc1': simplestyle.formatStyle({ 'stroke': '#f70', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'.4' }),
'line': simplestyle.formatStyle({ 'stroke': '#744', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'.4' }),
'area': simplestyle.formatStyle({ 'stroke': '#aaa', 'fill': 'none', "marker-end":"url(#DrawCurveMarker)", 'stroke-width':'0.3' }),
},
"area artefact": simplestyle.formatStyle({ 'stroke': '#ff0000', 'fill': '#ffff00', 'stroke-width':'1' }),
"area artefact arrow": simplestyle.formatStyle({ 'stroke': '#ff0000', 'fill': '#ffff00', 'stroke-width':'1' }),
"dxf_points": simplestyle.formatStyle({ "stroke": "#ff0000", "fill": "#ff0000"}),
}
################################################################################
### Gcode additional functions
################################################################################
def gcode_comment_str(s, replace_new_line = False):
if replace_new_line :
s = re.sub(r"[\n\r]+", ".", s)
res = ""
if s[-1] == "\n" : s = s[:-1]
for a in s.split("\n") :
if a != "" :
res += "(" + re.sub(r"[\(\)\\\n\r]", ".", a) + ")\n"
else :
res += "\n"
return res
################################################################################
### Cubic Super Path additional functions
################################################################################
def csp_from_polyline(line) :
return [ [ [point[:] for k in range(3) ] for point in subline ] for subline in line ]
def csp_remove_zerro_segments(csp, tolerance = 1e-7):
res = []
for subpath in csp:
if len(subpath) > 0 :
res.append([subpath[0]])
for sp1,sp2 in zip(subpath,subpath[1:]) :
if point_to_point_d2(sp1[1],sp2[1])<=tolerance and point_to_point_d2(sp1[2],sp2[1])<=tolerance and point_to_point_d2(sp1[1],sp2[0])<=tolerance :
res[-1][-1][2] = sp2[2]
else :
res[-1].append(sp2)
return res
def point_inside_csp(p,csp, on_the_path = True) :
# we'll do the raytracing and see how many intersections are there on the ray's way.
# if number of intersections is even then point is outside.
# ray will be x=p.x and y=>p.y
# you can assing any value to on_the_path, by dfault if point is on the path
# function will return thai it's inside the path.
x,y = p
ray_intersections_count = 0
for subpath in csp :
for i in range(1, len(subpath)) :
sp1, sp2 = subpath[i-1], subpath[i]
ax,ay,bx,by,cx,cy,dx,dy = csp_parameterize(sp1,sp2)
if ax==0 and bx==0 and cx==0 and dx==x :
#we've got a special case here
b = csp_true_bounds( [[sp1,sp2]])
if b[1][1]<=y<=b[3][1] :
# points is on the path
return on_the_path
else :
# we can skip this segment because it wont influence the answer.
pass
else:
for t in csp_line_intersection([x,y],[x,y+5],sp1,sp2) :
if t == 0 or t == 1 :
#we've got another special case here
x1,y1 = csp_at_t(sp1,sp2,t)
if y1==y :
# the point is on the path
return on_the_path
# if t == 0 we sould have considered this case previously.
if t == 1 :
# we have to check the next segmant if it is on the same side of the ray
st_d = csp_normalized_slope(sp1,sp2,1)[0]
if st_d == 0 : st_d = csp_normalized_slope(sp1,sp2,0.99)[0]
for j in range(1, len(subpath)+1):
if (i+j) % len(subpath) == 0 : continue # skip the closing segment
sp11,sp22 = subpath[(i-1+j) % len(subpath)], subpath[(i+j) % len(subpath)]
ax1,ay1,bx1,by1,cx1,cy1,dx1,dy1 = csp_parameterize(sp1,sp2)
if ax1==0 and bx1==0 and cx1==0 and dx1==x : continue # this segment parallel to the ray, so skip it
en_d = csp_normalized_slope(sp11,sp22,0)[0]
if en_d == 0 : en_d = csp_normalized_slope(sp11,sp22,0.01)[0]
if st_d*en_d <=0 :
ray_intersections_count += 1
break
else :
x1,y1 = csp_at_t(sp1,sp2,t)
if y1==y :
# the point is on the path
return on_the_path
else :
if y1>y and 3*ax*t**2 + 2*bx*t + cx !=0 : # if it's 0 the path only touches the ray
ray_intersections_count += 1
return ray_intersections_count%2 == 1
def csp_close_all_subpaths(csp, tolerance = 0.000001):
for i in range(len(csp)):
if point_to_point_d2(csp[i][0][1] , csp[i][-1][1])> tolerance**2 :
csp[i][-1][2] = csp[i][-1][1][:]
csp[i] += [ [csp[i][0][1][:] for j in range(3)] ]
else:
if csp[i][0][1] != csp[i][-1][1] :
csp[i][-1][1] = csp[i][0][1][:]
return csp
def csp_simple_bound(csp):
minx,miny,maxx,maxy = None,None,None,None
for subpath in csp:
for sp in subpath :
for p in sp:
minx = min(minx,p[0]) if minx!=None else p[0]
miny = min(miny,p[1]) if miny!=None else p[1]
maxx = max(maxx,p[0]) if maxx!=None else p[0]
maxy = max(maxy,p[1]) if maxy!=None else p[1]
return minx,miny,maxx,maxy
def csp_segment_to_bez(sp1,sp2) :
return sp1[1:]+sp2[:2]
def bound_to_bound_distance(sp1,sp2,sp3,sp4) :
min_dist = 1e100
max_dist = 0
points1 = csp_segment_to_bez(sp1,sp2)
points2 = csp_segment_to_bez(sp3,sp4)
for i in range(4) :
for j in range(4) :
min_, max_ = line_to_line_min_max_distance_2(points1[i-1], points1[i], points2[j-1], points2[j])
min_dist = min(min_dist,min_)
max_dist = max(max_dist,max_)
print_("bound_to_bound", min_dist, max_dist)
return min_dist, max_dist
def csp_to_point_distance(csp, p, dist_bounds = [0,1e100], tolerance=.01) :
min_dist = [1e100,0,0,0]
for j in range(len(csp)) :
for i in range(1,len(csp[j])) :
d = csp_seg_to_point_distance(csp[j][i-1],csp[j][i],p,sample_points = 5, tolerance = .01)
if d[0] < dist_bounds[0] :
# draw_pointer( list(csp_at_t(subpath[dist[2]-1],subpath[dist[2]],dist[3]))
# +list(csp_at_t(csp[dist[4]][dist[5]-1],csp[dist[4]][dist[5]],dist[6])),"red","line", comment = math.sqrt(dist[0]))
return [d[0],j,i,d[1]]
else :
if d[0] < min_dist[0] : min_dist = [d[0],j,i,d[1]]
return min_dist
def csp_seg_to_point_distance(sp1,sp2,p,sample_points = 5, tolerance = .01) :
ax,ay,bx,by,cx,cy,dx,dy = csp_parameterize(sp1,sp2)
dx, dy = dx-p[0], dy-p[1]
if sample_points < 2 : sample_points = 2
d = min( [(p[0]-sp1[1][0])**2 + (p[1]-sp1[1][1])**2,0.], [(p[0]-sp2[1][0])**2 + (p[1]-sp2[1][1])**2,1.] )
for k in range(sample_points) :
t = float(k)/(sample_points-1)
i = 0
while i==0 or abs(f)>0.000001 and i<20 :
t2,t3 = t**2,t**3
f = (ax*t3+bx*t2+cx*t+dx)*(3*ax*t2+2*bx*t+cx) + (ay*t3+by*t2+cy*t+dy)*(3*ay*t2+2*by*t+cy)
df = (6*ax*t+2*bx)*(ax*t3+bx*t2+cx*t+dx) + (3*ax*t2+2*bx*t+cx)**2 + (6*ay*t+2*by)*(ay*t3+by*t2+cy*t+dy) + (3*ay*t2+2*by*t+cy)**2
if df!=0 :
t = t - f/df
else :
break
i += 1
if 0<=t<=1 :
p1 = csp_at_t(sp1,sp2,t)
d1 = (p1[0]-p[0])**2 + (p1[1]-p[1])**2
if d1 < d[0] :
d = [d1,t]
return d
def csp_seg_to_csp_seg_distance(sp1,sp2,sp3,sp4, dist_bounds = [0,1e100], sample_points = 5, tolerance=.01) :
# check the ending points first
dist = csp_seg_to_point_distance(sp1,sp2,sp3[1],sample_points, tolerance)
dist += [0.]
if dist[0] <= dist_bounds[0] : return dist
d = csp_seg_to_point_distance(sp1,sp2,sp4[1],sample_points, tolerance)
if d[0]<dist[0] :
dist = d+[1.]
if dist[0] <= dist_bounds[0] : return dist
d = csp_seg_to_point_distance(sp3,sp4,sp1[1],sample_points, tolerance)
if d[0]<dist[0] :
dist = [d[0],0.,d[1]]
if dist[0] <= dist_bounds[0] : return dist
d = csp_seg_to_point_distance(sp3,sp4,sp2[1],sample_points, tolerance)
if d[0]<dist[0] :
dist = [d[0],1.,d[1]]
if dist[0] <= dist_bounds[0] : return dist
sample_points -= 2
if sample_points < 1 : sample_points = 1
ax1,ay1,bx1,by1,cx1,cy1,dx1,dy1 = csp_parameterize(sp1,sp2)
ax2,ay2,bx2,by2,cx2,cy2,dx2,dy2 = csp_parameterize(sp3,sp4)
# try to find closes points using Newtons method
for k in range(sample_points) :
for j in range(sample_points) :
t1,t2 = float(k+1)/(sample_points+1), float(j)/(sample_points+1)
t12, t13, t22, t23 = t1*t1, t1*t1*t1, t2*t2, t2*t2*t2
i = 0
F1, F2, F = [0,0], [[0,0],[0,0]], 1e100
x,y = ax1*t13+bx1*t12+cx1*t1+dx1 - (ax2*t23+bx2*t22+cx2*t2+dx2), ay1*t13+by1*t12+cy1*t1+dy1 - (ay2*t23+by2*t22+cy2*t2+dy2)
while i<2 or abs(F-Flast)>tolerance and i<30 :
#draw_pointer(csp_at_t(sp1,sp2,t1))
f1x = 3*ax1*t12+2*bx1*t1+cx1
f1y = 3*ay1*t12+2*by1*t1+cy1
f2x = 3*ax2*t22+2*bx2*t2+cx2
f2y = 3*ay2*t22+2*by2*t2+cy2
F1[0] = 2*f1x*x + 2*f1y*y
F1[1] = -2*f2x*x - 2*f2y*y
F2[0][0] = 2*(6*ax1*t1+2*bx1)*x + 2*f1x*f1x + 2*(6*ay1*t1+2*by1)*y +2*f1y*f1y
F2[0][1] = -2*f1x*f2x - 2*f1y*f2y
F2[1][0] = -2*f2x*f1x - 2*f2y*f1y
F2[1][1] = -2*(6*ax2*t2+2*bx2)*x + 2*f2x*f2x - 2*(6*ay2*t2+2*by2)*y + 2*f2y*f2y
F2 = inv_2x2(F2)
if F2!=None :
t1 -= ( F2[0][0]*F1[0] + F2[0][1]*F1[1] )
t2 -= ( F2[1][0]*F1[0] + F2[1][1]*F1[1] )
t12, t13, t22, t23 = t1*t1, t1*t1*t1, t2*t2, t2*t2*t2
x,y = ax1*t13+bx1*t12+cx1*t1+dx1 - (ax2*t23+bx2*t22+cx2*t2+dx2), ay1*t13+by1*t12+cy1*t1+dy1 - (ay2*t23+by2*t22+cy2*t2+dy2)
Flast = F
F = x*x+y*y
else :
break
i += 1
if F < dist[0] and 0<=t1<=1 and 0<=t2<=1:
dist = [F,t1,t2]
if dist[0] <= dist_bounds[0] :
return dist
return dist
def csp_to_csp_distance(csp1,csp2, dist_bounds = [0,1e100], tolerance=.01) :
dist = [1e100,0,0,0,0,0,0]
for i1 in range(len(csp1)) :
for j1 in range(1,len(csp1[i1])) :
for i2 in range(len(csp2)) :
for j2 in range(1,len(csp2[i2])) :
d = csp_seg_bound_to_csp_seg_bound_max_min_distance(csp1[i1][j1-1],csp1[i1][j1],csp2[i2][j2-1],csp2[i2][j2])
if d[0] >= dist_bounds[1] : continue
if d[1] < dist_bounds[0] : return [d[1],i1,j1,1,i2,j2,1]
d = csp_seg_to_csp_seg_distance(csp1[i1][j1-1],csp1[i1][j1],csp2[i2][j2-1],csp2[i2][j2], dist_bounds, tolerance=tolerance)
if d[0] < dist[0] :
dist = [d[0], i1,j1,d[1], i2,j2,d[2]]
if dist[0] <= dist_bounds[0] :
return dist
if dist[0] >= dist_bounds[1] :
return dist
return dist
# draw_pointer( list(csp_at_t(csp1[dist[1]][dist[2]-1],csp1[dist[1]][dist[2]],dist[3]))
# + list(csp_at_t(csp2[dist[4]][dist[5]-1],csp2[dist[4]][dist[5]],dist[6])), "#507","line")
def csp_split(sp1,sp2,t=.5) :
[x1,y1],[x2,y2],[x3,y3],[x4,y4] = sp1[1], sp1[2], sp2[0], sp2[1]
x12 = x1+(x2-x1)*t
y12 = y1+(y2-y1)*t
x23 = x2+(x3-x2)*t
y23 = y2+(y3-y2)*t
x34 = x3+(x4-x3)*t
y34 = y3+(y4-y3)*t
x1223 = x12+(x23-x12)*t
y1223 = y12+(y23-y12)*t
x2334 = x23+(x34-x23)*t
y2334 = y23+(y34-y23)*t
x = x1223+(x2334-x1223)*t
y = y1223+(y2334-y1223)*t
return [sp1[0],sp1[1],[x12,y12]], [[x1223,y1223],[x,y],[x2334,y2334]], [[x34,y34],sp2[1],sp2[2]]
def csp_true_bounds(csp) :
# Finds minx,miny,maxx,maxy of the csp and return their (x,y,i,j,t)
minx = [float("inf"), 0, 0, 0]
maxx = [float("-inf"), 0, 0, 0]
miny = [float("inf"), 0, 0, 0]
maxy = [float("-inf"), 0, 0, 0]
for i in range(len(csp)):
for j in range(1,len(csp[i])):
ax,ay,bx,by,cx,cy,x0,y0 = bezmisc.bezierparameterize((csp[i][j-1][1],csp[i][j-1][2],csp[i][j][0],csp[i][j][1]))
roots = cubic_solver(0, 3*ax, 2*bx, cx) + [0,1]
for root in roots :
if type(root) is complex and abs(root.imag)<1e-10:
root = root.real
if type(root) is not complex and 0<=root<=1:
y = ay*(root**3)+by*(root**2)+cy*root+y0
x = ax*(root**3)+bx*(root**2)+cx*root+x0
maxx = max([x,y,i,j,root],maxx)
minx = min([x,y,i,j,root],minx)
roots = cubic_solver(0, 3*ay, 2*by, cy) + [0,1]
for root in roots :
if type(root) is complex and root.imag==0:
root = root.real
if type(root) is not complex and 0<=root<=1:
y = ay*(root**3)+by*(root**2)+cy*root+y0
x = ax*(root**3)+bx*(root**2)+cx*root+x0
maxy = max([y,x,i,j,root],maxy)
miny = min([y,x,i,j,root],miny)
maxy[0],maxy[1] = maxy[1],maxy[0]
miny[0],miny[1] = miny[1],miny[0]
return minx,miny,maxx,maxy
############################################################################
### csp_segments_intersection(sp1,sp2,sp3,sp4)
###
### Returns array containig all intersections between two segmets of cubic
### super path. Results are [ta,tb], or [ta0, ta1, tb0, tb1, "Overlap"]
### where ta, tb are values of t for the intersection point.
############################################################################
def csp_segments_intersection(sp1,sp2,sp3,sp4) :
a, b = csp_segment_to_bez(sp1,sp2), csp_segment_to_bez(sp3,sp4)
def polish_intersection(a,b,ta,tb, tolerance = intersection_tolerance) :
ax,ay,bx,by,cx,cy,dx,dy = bezmisc.bezierparameterize(a)
ax1,ay1,bx1,by1,cx1,cy1,dx1,dy1 = bezmisc.bezierparameterize(b)
i = 0
F, F1 = [.0,.0], [[.0,.0],[.0,.0]]
while i==0 or (abs(F[0])**2+abs(F[1])**2 > tolerance and i<10):
ta3, ta2, tb3, tb2 = ta**3, ta**2, tb**3, tb**2
F[0] = ax*ta3+bx*ta2+cx*ta+dx-ax1*tb3-bx1*tb2-cx1*tb-dx1
F[1] = ay*ta3+by*ta2+cy*ta+dy-ay1*tb3-by1*tb2-cy1*tb-dy1
F1[0][0] = 3*ax *ta2 + 2*bx *ta + cx
F1[0][1] = -3*ax1*tb2 - 2*bx1*tb - cx1
F1[1][0] = 3*ay *ta2 + 2*by *ta + cy
F1[1][1] = -3*ay1*tb2 - 2*by1*tb - cy1
det = F1[0][0]*F1[1][1] - F1[0][1]*F1[1][0]
if det!=0 :
F1 = [ [ F1[1][1]/det, -F1[0][1]/det], [-F1[1][0]/det, F1[0][0]/det] ]
ta = ta - ( F1[0][0]*F[0] + F1[0][1]*F[1] )
tb = tb - ( F1[1][0]*F[0] + F1[1][1]*F[1] )
else: break
i += 1
return ta, tb
def recursion(a,b, ta0,ta1,tb0,tb1, depth_a,depth_b) :
global bezier_intersection_recursive_result
if a==b :
bezier_intersection_recursive_result += [[ta0,tb0,ta1,tb1,"Overlap"]]
return
tam, tbm = (ta0+ta1)/2, (tb0+tb1)/2
if depth_a>0 and depth_b>0 :
a1,a2 = bez_split(a,0.5)
b1,b2 = bez_split(b,0.5)
if bez_bounds_intersect(a1,b1) : recursion(a1,b1, ta0,tam,tb0,tbm, depth_a-1,depth_b-1)
if bez_bounds_intersect(a2,b1) : recursion(a2,b1, tam,ta1,tb0,tbm, depth_a-1,depth_b-1)
if bez_bounds_intersect(a1,b2) : recursion(a1,b2, ta0,tam,tbm,tb1, depth_a-1,depth_b-1)
if bez_bounds_intersect(a2,b2) : recursion(a2,b2, tam,ta1,tbm,tb1, depth_a-1,depth_b-1)
elif depth_a>0 :
a1,a2 = bez_split(a,0.5)
if bez_bounds_intersect(a1,b) : recursion(a1,b, ta0,tam,tb0,tb1, depth_a-1,depth_b)
if bez_bounds_intersect(a2,b) : recursion(a2,b, tam,ta1,tb0,tb1, depth_a-1,depth_b)
elif depth_b>0 :
b1,b2 = bez_split(b,0.5)
if bez_bounds_intersect(a,b1) : recursion(a,b1, ta0,ta1,tb0,tbm, depth_a,depth_b-1)
if bez_bounds_intersect(a,b2) : recursion(a,b2, ta0,ta1,tbm,tb1, depth_a,depth_b-1)
else : # Both segments have been subdevided enougth. Let's get some intersections :).
intersection, t1, t2 = straight_segments_intersection([a[0]]+[a[3]],[b[0]]+[b[3]])
if intersection :
if intersection == "Overlap" :
t1 = ( max(0,min(1,t1[0]))+max(0,min(1,t1[1])) )/2
t2 = ( max(0,min(1,t2[0]))+max(0,min(1,t2[1])) )/2
bezier_intersection_recursive_result += [[ta0+t1*(ta1-ta0),tb0+t2*(tb1-tb0)]]
global bezier_intersection_recursive_result
bezier_intersection_recursive_result = []
recursion(a,b,0.,1.,0.,1.,intersection_recursion_depth,intersection_recursion_depth)
intersections = bezier_intersection_recursive_result
for i in range(len(intersections)) :
if len(intersections[i])<5 or intersections[i][4] != "Overlap" :
intersections[i] = polish_intersection(a,b,intersections[i][0],intersections[i][1])
return intersections
def csp_segments_true_intersection(sp1,sp2,sp3,sp4) :
intersections = csp_segments_intersection(sp1,sp2,sp3,sp4)
res = []
for intersection in intersections :
if (
(len(intersection)==5 and intersection[4] == "Overlap" and (0<=intersection[0]<=1 or 0<=intersection[1]<=1) and (0<=intersection[2]<=1 or 0<=intersection[3]<=1) )
or ( 0<=intersection[0]<=1 and 0<=intersection[1]<=1 )
) :
res += [intersection]
return res
def csp_get_t_at_curvature(sp1,sp2,c, sample_points = 16):
# returns a list containning [t1,t2,t3,...,tn], 0<=ti<=1...
if sample_points < 2 : sample_points = 2
tolerance = .0000000001
res = []
ax,ay,bx,by,cx,cy,dx,dy = csp_parameterize(sp1,sp2)
for k in range(sample_points) :
t = float(k)/(sample_points-1)
i, F = 0, 1e100
while i<2 or abs(F)>tolerance and i<17 :
try : # some numerical calculation could exceed the limits
t2 = t*t
#slopes...
f1x = 3*ax*t2+2*bx*t+cx
f1y = 3*ay*t2+2*by*t+cy
f2x = 6*ax*t+2*bx
f2y = 6*ay*t+2*by
f3x = 6*ax
f3y = 6*ay
d = (f1x**2+f1y**2)**1.5
F1 = (
( (f1x*f3y-f3x*f1y)*d - (f1x*f2y-f2x*f1y)*3.*(f2x*f1x+f2y*f1y)*((f1x**2+f1y**2)**.5) ) /
((f1x**2+f1y**2)**3)
)
F = (f1x*f2y-f1y*f2x)/d - c
t -= F/F1
except:
break
i += 1
if 0<=t<=1 and F<=tolerance:
if len(res) == 0 :
res.append(t)
for i in res :
if abs(t-i)<=0.001 :
break
if not abs(t-i)<=0.001 :
res.append(t)
return res
def csp_max_curvature(sp1,sp2):
ax,ay,bx,by,cx,cy,dx,dy = csp_parameterize(sp1,sp2)
tolerance = .0001
F = 0.
i = 0
while i<2 or F-Flast<tolerance and i<10 :
t = .5
f1x = 3*ax*t**2 + 2*bx*t + cx
f1y = 3*ay*t**2 + 2*by*t + cy
f2x = 6*ax*t + 2*bx
f2y = 6*ay*t + 2*by
f3x = 6*ax
f3y = 6*ay
d = pow(f1x**2+f1y**2,1.5)
if d != 0 :
Flast = F
F = (f1x*f2y-f1y*f2x)/d
F1 = (
( d*(f1x*f3y-f3x*f1y) - (f1x*f2y-f2x*f1y)*3.*(f2x*f1x+f2y*f1y)*pow(f1x**2+f1y**2,.5) ) /
(f1x**2+f1y**2)**3
)
i+=1
if F1!=0:
t -= F/F1
else:
break
else: break
return t
def csp_curvature_at_t(sp1,sp2,t, depth = 3) :
ax,ay,bx,by,cx,cy,dx,dy = bezmisc.bezierparameterize(csp_segment_to_bez(sp1,sp2))
#curvature = (x'y''-y'x'') / (x'^2+y'^2)^1.5
f1x = 3*ax*t**2 + 2*bx*t + cx
f1y = 3*ay*t**2 + 2*by*t + cy
f2x = 6*ax*t + 2*bx
f2y = 6*ay*t + 2*by
d = (f1x**2+f1y**2)**1.5
if d != 0 :
return (f1x*f2y-f1y*f2x)/d
else :
t1 = f1x*f2y-f1y*f2x
if t1 > 0 : return 1e100
if t1 < 0 : return -1e100
# Use the Lapitals rule to solve 0/0 problem for 2 times...
t1 = 2*(bx*ay-ax*by)*t+(ay*cx-ax*cy)
if t1 > 0 : return 1e100
if t1 < 0 : return -1e100
t1 = bx*ay-ax*by
if t1 > 0 : return 1e100
if t1 < 0 : return -1e100
if depth>0 :
# little hack ;^) hope it wont influence anything...
return csp_curvature_at_t(sp1,sp2,t*1.004, depth-1)
return 1e100
def csp_curvature_radius_at_t(sp1,sp2,t) :
c = csp_curvature_at_t(sp1,sp2,t)
if c == 0 : return 1e100
else: return 1/c
def csp_special_points(sp1,sp2) :
# special points = curvature == 0
ax,ay,bx,by,cx,cy,dx,dy = bezmisc.bezierparameterize((sp1[1],sp1[2],sp2[0],sp2[1]))
a = 3*ax*by-3*ay*bx
b = 3*ax*cy-3*cx*ay
c = bx*cy-cx*by
roots = cubic_solver(0, a, b, c)
res = []
for i in roots :
if type(i) is complex and i.imag==0:
i = i.real
if type(i) is not complex and 0<=i<=1:
res.append(i)
return res
def csp_subpath_ccw(subpath):
# Remove all zerro length segments
s = 0
#subpath = subpath[:]
if (P(subpath[-1][1])-P(subpath[0][1])).l2() > 1e-10 :
subpath[-1][2] = subpath[-1][1]
subpath[0][0] = subpath[0][1]
subpath += [ [subpath[0][1],subpath[0][1],subpath[0][1]] ]
pl = subpath[-1][2]
for sp1 in subpath:
for p in sp1 :
s += (p[0]-pl[0])*(p[1]+pl[1])
pl = p
return s<0
def csp_at_t(sp1,sp2,t):
ax,bx,cx,dx = sp1[1][0], sp1[2][0], sp2[0][0], sp2[1][0]
ay,by,cy,dy = sp1[1][1], sp1[2][1], sp2[0][1], sp2[1][1]
x1, y1 = ax+(bx-ax)*t, ay+(by-ay)*t
x2, y2 = bx+(cx-bx)*t, by+(cy-by)*t
x3, y3 = cx+(dx-cx)*t, cy+(dy-cy)*t
x4,y4 = x1+(x2-x1)*t, y1+(y2-y1)*t
x5,y5 = x2+(x3-x2)*t, y2+(y3-y2)*t
x,y = x4+(x5-x4)*t, y4+(y5-y4)*t
return [x,y]
def csp_at_length(sp1,sp2,l=0.5, tolerance = 0.01):
bez = (sp1[1][:],sp1[2][:],sp2[0][:],sp2[1][:])
t = bezmisc.beziertatlength(bez, l, tolerance)
return csp_at_t(sp1,sp2,t)
def csp_splitatlength(sp1, sp2, l = 0.5, tolerance = 0.01):
bez = (sp1[1][:],sp1[2][:],sp2[0][:],sp2[1][:])
t = bezmisc.beziertatlength(bez, l, tolerance)
return csp_split(sp1, sp2, t)
def cspseglength(sp1,sp2, tolerance = 0.01):
bez = (sp1[1][:],sp1[2][:],sp2[0][:],sp2[1][:])
return bezmisc.bezierlength(bez, tolerance)
def csplength(csp):
total = 0
lengths = []
for sp in csp:
for i in xrange(1,len(sp)):
l = cspseglength(sp[i-1],sp[i])
lengths.append(l)
total += l
return lengths, total
def csp_segments(csp):
l, seg = 0, [0]
for sp in csp:
for i in xrange(1,len(sp)):
l += cspseglength(sp[i-1],sp[i])
seg += [ l ]
if l>0 :
seg = [seg[i]/l for i in xrange(len(seg))]
return seg,l
def rebuild_csp (csp, segs, s=None):
# rebuild_csp() adds to csp control points making it's segments looks like segs
if s==None : s, l = csp_segments(csp)
if len(s)>len(segs) : return None
segs = segs[:]
segs.sort()
for i in xrange(len(s)):
d = None
for j in xrange(len(segs)):
d = min( [abs(s[i]-segs[j]),j], d) if d!=None else [abs(s[i]-segs[j]),j]
del segs[d[1]]
for i in xrange(len(segs)):
for j in xrange(0,len(s)):
if segs[i]<s[j] : break
if s[j]-s[j-1] != 0 :
t = (segs[i] - s[j-1])/(s[j]-s[j-1])
sp1,sp2,sp3 = csp_split(csp[j-1],csp[j], t)
csp = csp[:j-1] + [sp1,sp2,sp3] + csp[j+1:]
s = s[:j] + [ s[j-1]*(1-t)+s[j]*t ] + s[j:]
return csp, s
def csp_slope(sp1,sp2,t):
bez = (sp1[1][:],sp1[2][:],sp2[0][:],sp2[1][:])
return bezmisc.bezierslopeatt(bez,t)
def csp_line_intersection(l1,l2,sp1,sp2):
dd=l1[0]
cc=l2[0]-l1[0]
bb=l1[1]
aa=l2[1]-l1[1]
if aa==cc==0 : return []
if aa:
coef1=cc/aa
coef2=1
else:
coef1=1
coef2=aa/cc
bez = (sp1[1][:],sp1[2][:],sp2[0][:],sp2[1][:])
ax,ay,bx,by,cx,cy,x0,y0=bezmisc.bezierparameterize(bez)
a=coef1*ay-coef2*ax
b=coef1*by-coef2*bx
c=coef1*cy-coef2*cx
d=coef1*(y0-bb)-coef2*(x0-dd)
roots = cubic_solver(a,b,c,d)
retval = []
for i in roots :
if type(i) is complex and abs(i.imag)<1e-7:
i = i.real
if type(i) is not complex and -1e-10<=i<=1.+1e-10:
retval.append(i)
return retval
def csp_split_by_two_points(sp1,sp2,t1,t2) :
if t1>t2 : t1, t2 = t2, t1
if t1 == t2 :
sp1,sp2,sp3 = csp_split(sp1,sp2,t)
return [sp1,sp2,sp2,sp3]
elif t1 <= 1e-10 and t2 >= 1.-1e-10 :
return [sp1,sp1,sp2,sp2]
elif t1 <= 1e-10:
sp1,sp2,sp3 = csp_split(sp1,sp2,t2)
return [sp1,sp1,sp2,sp3]
elif t2 >= 1.-1e-10 :
sp1,sp2,sp3 = csp_split(sp1,sp2,t1)
return [sp1,sp2,sp3,sp3]
else:
sp1,sp2,sp3 = csp_split(sp1,sp2,t1)
sp2,sp3,sp4 = csp_split(sp2,sp3,(t2-t1)/(1-t1) )
return [sp1,sp2,sp3,sp4]
def csp_seg_split(sp1,sp2, points):
# points is float=t or list [t1, t2, ..., tn]
if type(points) is float :
points = [points]
points.sort()
res = [sp1,sp2]
last_t = 0
for t in points:
if 1e-10<t<1.-1e-10 :
sp3,sp4,sp5 = csp_split(res[-2],res[-1], (t-last_t)/(1-last_t))
last_t = t
res[-2:] = [sp3,sp4,sp5]
return res
def csp_subpath_split_by_points(subpath, points) :
# points are [[i,t]...] where i-segment's number
points.sort()
points = [[1,0.]] + points + [[len(subpath)-1,1.]]
parts = []
for int1,int2 in zip(points,points[1:]) :
if int1==int2 :
continue
if int1[1] == 1. :
int1[0] += 1
int1[1] = 0.
if int1==int2 :
continue
if int2[1] == 0. :
int2[0] -= 1
int2[1] = 1.
if int1[0] == 0 and int2[0]==len(subpath)-1:# and small(int1[1]) and small(int2[1]-1) :
continue
if int1[0]==int2[0] : # same segment
sp = csp_split_by_two_points(subpath[int1[0]-1],subpath[int1[0]],int1[1], int2[1])
if sp[1]!=sp[2] :
parts += [ [sp[1],sp[2]] ]
else :
sp5,sp1,sp2 = csp_split(subpath[int1[0]-1],subpath[int1[0]],int1[1])
sp3,sp4,sp5 = csp_split(subpath[int2[0]-1],subpath[int2[0]],int2[1])
if int1[0]==int2[0]-1 :
parts += [ [sp1, [sp2[0],sp2[1],sp3[2]], sp4] ]
else :
parts += [ [sp1,sp2]+subpath[int1[0]+1:int2[0]-1]+[sp3,sp4] ]
return parts
def arc_from_s_r_n_l(s,r,n,l) :
if abs(n[0]**2+n[1]**2 - 1) > 1e-10 : n = normalize(n)
return arc_from_c_s_l([s[0]+n[0]*r, s[1]+n[1]*r],s,l)
def arc_from_c_s_l(c,s,l) :
r = point_to_point_d(c,s)
if r == 0 : return []
alpha = l/r
cos_, sin_ = math.cos(alpha), math.sin(alpha)
e = [ c[0] + (s[0]-c[0])*cos_ - (s[1]-c[1])*sin_, c[1] + (s[0]-c[0])*sin_ + (s[1]-c[1])*cos_]
n = [c[0]-s[0],c[1]-s[1]]
slope = rotate_cw(n) if l>0 else rotate_ccw(n)
return csp_from_arc(s, e, c, r, slope)
def csp_from_arc(start, end, center, r, slope_st) :
# Creates csp that approximise specified arc
r = abs(r)
alpha = (atan2(end[0]-center[0],end[1]-center[1]) - atan2(start[0]-center[0],start[1]-center[1])) % math.pi2
sectors = int(abs(alpha)*2/math.pi)+1
alpha_start = atan2(start[0]-center[0],start[1]-center[1])
cos_,sin_ = math.cos(alpha_start), math.sin(alpha_start)
k = (4.*math.tan(alpha/sectors/4.)/3.)
if dot(slope_st , [- sin_*k*r, cos_*k*r]) < 0 :
if alpha>0 : alpha -= math.pi2
else: alpha += math.pi2
if abs(alpha*r)<0.001 :
return []
sectors = int(abs(alpha)*2/math.pi)+1
k = (4.*math.tan(alpha/sectors/4.)/3.)
result = []
for i in range(sectors+1) :
cos_,sin_ = math.cos(alpha_start + alpha*i/sectors), math.sin(alpha_start + alpha*i/sectors)
sp = [ [], [center[0] + cos_*r, center[1] + sin_*r], [] ]
sp[0] = [sp[1][0] + sin_*k*r, sp[1][1] - cos_*k*r ]
sp[2] = [sp[1][0] - sin_*k*r, sp[1][1] + cos_*k*r ]
result += [sp]
result[0][0] = result[0][1][:]
result[-1][2] = result[-1][1]
return result
def point_to_arc_distance(p, arc):
### Distance calculattion from point to arc
P0,P2,c,a = arc
dist = None
p = P(p)
r = (P0-c).mag()
if r>0 :
i = c + (p-c).unit()*r
alpha = ((i-c).angle() - (P0-c).angle())
if a*alpha<0:
if alpha>0: alpha = alpha-math.pi2
else: alpha = math.pi2+alpha
if between(alpha,0,a) or min(abs(alpha),abs(alpha-a))<straight_tolerance :
return (p-i).mag(), [i.x, i.y]
else :
d1, d2 = (p-P0).mag(), (p-P2).mag()
if d1<d2 :
return (d1, [P0.x,P0.y])
else :
return (d2, [P2.x,P2.y])
def csp_to_arc_distance(sp1,sp2, arc1, arc2, tolerance = 0.01 ): # arc = [start,end,center,alpha]
n, i = 10, 0
d, d1, dl = (0,(0,0)), (0,(0,0)), 0
while i<1 or (abs(d1[0]-dl[0])>tolerance and i<4):
i += 1
dl = d1*1
for j in range(n+1):
t = float(j)/n
p = csp_at_t(sp1,sp2,t)
d = min(point_to_arc_distance(p,arc1), point_to_arc_distance(p,arc2))
d1 = max(d1,d)
n=n*2
return d1[0]
def csp_simple_bound_to_point_distance(p, csp):
minx,miny,maxx,maxy = None,None,None,None
for subpath in csp:
for sp in subpath:
for p_ in sp:
minx = min(minx,p_[0]) if minx!=None else p_[0]
miny = min(miny,p_[1]) if miny!=None else p_[1]
maxx = max(maxx,p_[0]) if maxx!=None else p_[0]
maxy = max(maxy,p_[1]) if maxy!=None else p_[1]
return math.sqrt(max(minx-p[0],p[0]-maxx,0)**2+max(miny-p[1],p[1]-maxy,0)**2)
def csp_point_inside_bound(sp1, sp2, p):
bez = [sp1[1],sp1[2],sp2[0],sp2[1]]
x,y = p
c = 0
#CLT added test of x in range
xmin=1e100
xmax=-1e100
for i in range(4):
[x0,y0], [x1,y1] = bez[i-1], bez[i]
xmin=min(xmin,x0)
xmax=max(xmax,x0)
if x0-x1!=0 and (y-y0)*(x1-x0)>=(x-x0)*(y1-y0) and x>min(x0,x1) and x<=max(x0,x1) :
c +=1
return xmin<=x<=xmax and c%2==0
def csp_bound_to_point_distance(sp1, sp2, p):
if csp_point_inside_bound(sp1, sp2, p) :
return 0.
bez = csp_segment_to_bez(sp1,sp2)
min_dist = 1e100
for i in range(0,4):
d = point_to_line_segment_distance_2(p, bez[i-1],bez[i])
if d <= min_dist : min_dist = d
return min_dist
def line_line_intersect(p1,p2,p3,p4) : # Return only true intersection.
if (p1[0]==p2[0] and p1[1]==p2[1]) or (p3[0]==p4[0] and p3[1]==p4[1]) : return False
x = (p2[0]-p1[0])*(p4[1]-p3[1]) - (p2[1]-p1[1])*(p4[0]-p3[0])
if x==0 : # Lines are parallel
if (p3[0]-p1[0])*(p2[1]-p1[1]) == (p3[1]-p1[1])*(p2[0]-p1[0]) :
if p3[0]!=p4[0] :
t11 = (p1[0]-p3[0])/(p4[0]-p3[0])
t12 = (p2[0]-p3[0])/(p4[0]-p3[0])
t21 = (p3[0]-p1[0])/(p2[0]-p1[0])
t22 = (p4[0]-p1[0])/(p2[0]-p1[0])
else:
t11 = (p1[1]-p3[1])/(p4[1]-p3[1])
t12 = (p2[1]-p3[1])/(p4[1]-p3[1])
t21 = (p3[1]-p1[1])/(p2[1]-p1[1])
t22 = (p4[1]-p1[1])/(p2[1]-p1[1])
return ("Overlap" if (0<=t11<=1 or 0<=t12<=1) and (0<=t21<=1 or 0<=t22<=1) else False)
else: return False
else :
return (
0<=((p4[0]-p3[0])*(p1[1]-p3[1]) - (p4[1]-p3[1])*(p1[0]-p3[0]))/x<=1 and
0<=((p2[0]-p1[0])*(p1[1]-p3[1]) - (p2[1]-p1[1])*(p1[0]-p3[0]))/x<=1 )
def line_line_intersection_points(p1,p2,p3,p4) : # Return only points [ (x,y) ]
if (p1[0]==p2[0] and p1[1]==p2[1]) or (p3[0]==p4[0] and p3[1]==p4[1]) : return []
x = (p2[0]-p1[0])*(p4[1]-p3[1]) - (p2[1]-p1[1])*(p4[0]-p3[0])
if x==0 : # Lines are parallel
if (p3[0]-p1[0])*(p2[1]-p1[1]) == (p3[1]-p1[1])*(p2[0]-p1[0]) :
if p3[0]!=p4[0] :
t11 = (p1[0]-p3[0])/(p4[0]-p3[0])
t12 = (p2[0]-p3[0])/(p4[0]-p3[0])
t21 = (p3[0]-p1[0])/(p2[0]-p1[0])
t22 = (p4[0]-p1[0])/(p2[0]-p1[0])
else:
t11 = (p1[1]-p3[1])/(p4[1]-p3[1])
t12 = (p2[1]-p3[1])/(p4[1]-p3[1])
t21 = (p3[1]-p1[1])/(p2[1]-p1[1])
t22 = (p4[1]-p1[1])/(p2[1]-p1[1])
res = []
if (0<=t11<=1 or 0<=t12<=1) and (0<=t21<=1 or 0<=t22<=1) :
if 0<=t11<=1 : res += [p1]
if 0<=t12<=1 : res += [p2]
if 0<=t21<=1 : res += [p3]
if 0<=t22<=1 : res += [p4]
return res
else: return []
else :
t1 = ((p4[0]-p3[0])*(p1[1]-p3[1]) - (p4[1]-p3[1])*(p1[0]-p3[0]))/x
t2 = ((p2[0]-p1[0])*(p1[1]-p3[1]) - (p2[1]-p1[1])*(p1[0]-p3[0]))/x
if 0<=t1<=1 and 0<=t2<=1 : return [ [p1[0]*(1-t1)+p2[0]*t1, p1[1]*(1-t1)+p2[1]*t1] ]
else : return []
def point_to_point_d2(a,b):
return (a[0]-b[0])**2 + (a[1]-b[1])**2
def point_to_point_d(a,b):
return math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)
def point_to_line_segment_distance_2(p1, p2,p3) :
# p1 - point, p2,p3 - line segment
#draw_pointer(p1)
w0 = [p1[0]-p2[0], p1[1]-p2[1]]
v = [p3[0]-p2[0], p3[1]-p2[1]]
c1 = w0[0]*v[0] + w0[1]*v[1]
if c1 <= 0 :
return w0[0]*w0[0]+w0[1]*w0[1]
c2 = v[0]*v[0] + v[1]*v[1]
if c2 <= c1 :
return (p1[0]-p3[0])**2 + (p1[1]-p3[1])**2
return (p1[0]- p2[0]-v[0]*c1/c2)**2 + (p1[1]- p2[1]-v[1]*c1/c2)
def line_to_line_distance_2(p1,p2,p3,p4):
if line_line_intersect(p1,p2,p3,p4) : return 0
return min(
point_to_line_segment_distance_2(p1,p3,p4),
point_to_line_segment_distance_2(p2,p3,p4),
point_to_line_segment_distance_2(p3,p1,p2),
point_to_line_segment_distance_2(p4,p1,p2))
def csp_seg_bound_to_csp_seg_bound_max_min_distance(sp1,sp2,sp3,sp4) :
bez1 = csp_segment_to_bez(sp1,sp2)
bez2 = csp_segment_to_bez(sp3,sp4)
min_dist = 1e100
max_dist = 0.
for i in range(4) :
if csp_point_inside_bound(sp1, sp2, bez2[i]) or csp_point_inside_bound(sp3, sp4, bez1[i]) :
min_dist = 0.
break
for i in range(4) :
for j in range(4) :
d = line_to_line_distance_2(bez1[i-1],bez1[i],bez2[j-1],bez2[j])
if d < min_dist : min_dist = d
d = (bez2[j][0]-bez1[i][0])**2 + (bez2[j][1]-bez1[i][1])**2
if max_dist < d : max_dist = d
return min_dist, max_dist
def csp_reverse(csp) :
for i in range(len(csp)) :
n = []
for j in csp[i] :
n = [ [j[2][:],j[1][:],j[0][:]] ] + n
csp[i] = n[:]
return csp
def csp_normalized_slope(sp1,sp2,t) :
ax,ay,bx,by,cx,cy,dx,dy=bezmisc.bezierparameterize((sp1[1][:],sp1[2][:],sp2[0][:],sp2[1][:]))
if sp1[1]==sp2[1]==sp1[2]==sp2[0] : return [1.,0.]
f1x = 3*ax*t*t+2*bx*t+cx
f1y = 3*ay*t*t+2*by*t+cy
if abs(f1x*f1x+f1y*f1y) > 1e-9 : #LT changed this from 1e-20, which caused problems
l = math.sqrt(f1x*f1x+f1y*f1y)
return [f1x/l, f1y/l]
if t == 0 :
f1x = sp2[0][0]-sp1[1][0]
f1y = sp2[0][1]-sp1[1][1]
if abs(f1x*f1x+f1y*f1y) > 1e-9 : #LT changed this from 1e-20, which caused problems
l = math.sqrt(f1x*f1x+f1y*f1y)
return [f1x/l, f1y/l]
else :
f1x = sp2[1][0]-sp1[1][0]
f1y = sp2[1][1]-sp1[1][1]
if f1x*f1x+f1y*f1y != 0 :
l = math.sqrt(f1x*f1x+f1y*f1y)
return [f1x/l, f1y/l]
elif t == 1 :
f1x = sp2[1][0]-sp1[2][0]
f1y = sp2[1][1]-sp1[2][1]
if abs(f1x*f1x+f1y*f1y) > 1e-9 :
l = math.sqrt(f1x*f1x+f1y*f1y)
return [f1x/l, f1y/l]
else :
f1x = sp2[1][0]-sp1[1][0]
f1y = sp2[1][1]-sp1[1][1]
if f1x*f1x+f1y*f1y != 0 :
l = math.sqrt(f1x*f1x+f1y*f1y)
return [f1x/l, f1y/l]
else :
return [1.,0.]
def csp_normalized_normal(sp1,sp2,t) :
nx,ny = csp_normalized_slope(sp1,sp2,t)
return [-ny, nx]
def csp_parameterize(sp1,sp2):
return bezmisc.bezierparameterize(csp_segment_to_bez(sp1,sp2))
def csp_concat_subpaths(*s):
def concat(s1,s2) :
if s1 == [] : return s2
if s2 == [] : return s1
if (s1[-1][1][0]-s2[0][1][0])**2 + (s1[-1][1][1]-s2[0][1][1])**2 > 0.00001 :
return s1[:-1]+[ [s1[-1][0],s1[-1][1],s1[-1][1]], [s2[0][1],s2[0][1],s2[0][2]] ] + s2[1:]
else :
return s1[:-1]+[ [s1[-1][0],s2[0][1],s2[0][2]] ] + s2[1:]
if len(s) == 0 : return []
if len(s) ==1 : return s[0]
result = s[0]
for s1 in s[1:]:
result = concat(result,s1)
return result
def csp_subpaths_end_to_start_distance2(s1,s2):
return (s1[-1][1][0]-s2[0][1][0])**2 + (s1[-1][1][1]-s2[0][1][1])**2
def csp_clip_by_line(csp,l1,l2) :
result = []
for i in range(len(csp)):
s = csp[i]
intersections = []
for j in range(1,len(s)) :
intersections += [ [j,int_] for int_ in csp_line_intersection(l1,l2,s[j-1],s[j])]
splitted_s = csp_subpath_split_by_points(s, intersections)
for s in splitted_s[:] :
clip = False
for p in csp_true_bounds([s]) :
if (l1[1]-l2[1])*p[0] + (l2[0]-l1[0])*p[1] + (l1[0]*l2[1]-l2[0]*l1[1])<-0.01 :
clip = True
break
if clip :
splitted_s.remove(s)
result += splitted_s
return result
def csp_subpath_line_to(subpath, points, prepend = False) :
# Appends subpath with line or polyline.
if len(points)>0 :
if not prepend :
if len(subpath)>0:
subpath[-1][2] = subpath[-1][1][:]
if type(points[0]) == type([1,1]) :
for p in points :
subpath += [ [p[:],p[:],p[:]] ]
else:
subpath += [ [points,points,points] ]
else :
if len(subpath)>0:
subpath[0][0] = subpath[0][1][:]
if type(points[0]) == type([1,1]) :
for p in points :
subpath = [ [p[:],p[:],p[:]] ] + subpath
else:
subpath = [ [points,points,points] ] + subpath
return subpath
def csp_join_subpaths(csp) :
result = csp[:]
done_smf = True
joined_result = []
while done_smf :
done_smf = False
while len(result)>0:
s1 = result[-1][:]
del(result[-1])
j = 0
joined_smf = False
while j<len(joined_result) :
if csp_subpaths_end_to_start_distance2(joined_result[j],s1) <0.000001 :
joined_result[j] = csp_concat_subpaths(joined_result[j],s1)
done_smf = True
joined_smf = True
break
if csp_subpaths_end_to_start_distance2(s1,joined_result[j]) <0.000001 :
joined_result[j] = csp_concat_subpaths(s1,joined_result[j])
done_smf = True
joined_smf = True
break
j += 1
if not joined_smf : joined_result += [s1[:]]
if done_smf :
result = joined_result[:]
joined_result = []
return joined_result
def triangle_cross(a,b,c):
return (a[0]-b[0])*(c[1]-b[1]) - (c[0]-b[0])*(a[1]-b[1])
def csp_segment_convex_hull(sp1,sp2):
a,b,c,d = sp1[1][:], sp1[2][:], sp2[0][:], sp2[1][:]
abc = triangle_cross(a,b,c)
abd = triangle_cross(a,b,d)
bcd = triangle_cross(b,c,d)
cad = triangle_cross(c,a,d)
if abc == 0 and abd == 0 : return [min(a,b,c,d), max(a,b,c,d)]
if abc == 0 : return [d, min(a,b,c), max(a,b,c)]
if abd == 0 : return [c, min(a,b,d), max(a,b,d)]
if bcd == 0 : return [a, min(b,c,d), max(b,c,d)]
if cad == 0 : return [b, min(c,a,d), max(c,a,d)]
m1, m2, m3 = abc*abd>0, abc*bcd>0, abc*cad>0
if m1 and m2 and m3 : return [a,b,c]
if m1 and m2 and not m3 : return [a,b,c,d]
if m1 and not m2 and m3 : return [a,b,d,c]
if not m1 and m2 and m3 : return [a,d,b,c]
if m1 and not (m2 and m3) : return [a,b,d]
if not (m1 and m2) and m3 : return [c,a,d]
if not (m1 and m3) and m2 : return [b,c,d]
raise ValueError, "csp_segment_convex_hull happend something that shouldnot happen!"
################################################################################
### Bezier additional functions
################################################################################
def bez_bounds_intersect(bez1, bez2) :
return bounds_intersect(bez_bound(bez2), bez_bound(bez1))
def bez_bound(bez) :
return [
min(bez[0][0], bez[1][0], bez[2][0], bez[3][0]),
min(bez[0][1], bez[1][1], bez[2][1], bez[3][1]),
max(bez[0][0], bez[1][0], bez[2][0], bez[3][0]),
max(bez[0][1], bez[1][1], bez[2][1], bez[3][1]),
]
def bounds_intersect(a, b) :
return not ( (a[0]>b[2]) or (b[0]>a[2]) or (a[1]>b[3]) or (b[1]>a[3]) )
def tpoint((x1,y1),(x2,y2),t):
return [x1+t*(x2-x1),y1+t*(y2-y1)]
def bez_to_csp_segment(bez) :
return [bez[0],bez[0],bez[1]], [bez[2],bez[3],bez[3]]
def bez_split(a,t=0.5) :
a1 = tpoint(a[0],a[1],t)
at = tpoint(a[1],a[2],t)
b2 = tpoint(a[2],a[3],t)
a2 = tpoint(a1,at,t)
b1 = tpoint(b2,at,t)
a3 = tpoint(a2,b1,t)
return [a[0],a1,a2,a3], [a3,b1,b2,a[3]]
def bez_at_t(bez,t) :
return csp_at_t([bez[0],bez[0],bez[1]],[bez[2],bez[3],bez[3]],t)
def bez_to_point_distance(bez,p,needed_dist=[0.,1e100]):
# returns [d^2,t]
return csp_seg_to_point_distance(bez_to_csp_segment(bez),p,needed_dist)
def bez_normalized_slope(bez,t):
return csp_normalized_slope([bez[0],bez[0],bez[1]], [bez[2],bez[3],bez[3]],t)
################################################################################
### Some vector functions
################################################################################
def normalize((x,y)) :
l = math.sqrt(x**2+y**2)
if l == 0 : return [0.,0.]
else : return [x/l, y/l]
def cross(a,b) :
return a[1] * b[0] - a[0] * b[1]
def dot(a,b) :
return a[0] * b[0] + a[1] * b[1]
def rotate_ccw(d) :
return [-d[1],d[0]]
def rotate_cw(d) :
return [d[1],-d[0]]
def vectors_ccw(a,b):
return a[0]*b[1]-b[0]*a[1] < 0
def vector_add(a,b) :
return [a[0]+b[0],a[1]+b[1]]
def vector_mul(a,b) :
return [a[0]*b,a[1]*b]
def vector_from_to_length(a,b):
return math.sqrt((a[0]-b[0])*(a[0]-b[0]) + (a[1]-b[1])*(a[1]-b[1]))
################################################################################
### Common functions
################################################################################
def matrix_mul(a,b) :
return [ [ sum([a[i][k]*b[k][j] for k in range(len(a[0])) ]) for j in range(len(b[0]))] for i in range(len(a))]
try :
return [ [ sum([a[i][k]*b[k][j] for k in range(len(a[0])) ]) for j in range(len(b[0]))] for i in range(len(a))]
except :
return None
def transpose(a) :
try :
return [ [ a[i][j] for i in range(len(a)) ] for j in range(len(a[0])) ]
except :
return None
def det_3x3(a):
return float(
a[0][0]*a[1][1]*a[2][2] + a[0][1]*a[1][2]*a[2][0] + a[1][0]*a[2][1]*a[0][2]
- a[0][2]*a[1][1]*a[2][0] - a[0][0]*a[2][1]*a[1][2] - a[0][1]*a[2][2]*a[1][0]
)
def inv_3x3(a): # invert matrix 3x3
det = det_3x3(a)
if det==0: return None
return [
[ (a[1][1]*a[2][2] - a[2][1]*a[1][2])/det, -(a[0][1]*a[2][2] - a[2][1]*a[0][2])/det, (a[0][1]*a[1][2] - a[1][1]*a[0][2])/det ],
[ -(a[1][0]*a[2][2] - a[2][0]*a[1][2])/det, (a[0][0]*a[2][2] - a[2][0]*a[0][2])/det, -(a[0][0]*a[1][2] - a[1][0]*a[0][2])/det ],
[ (a[1][0]*a[2][1] - a[2][0]*a[1][1])/det, -(a[0][0]*a[2][1] - a[2][0]*a[0][1])/det, (a[0][0]*a[1][1] - a[1][0]*a[0][1])/det ]
]
def inv_2x2(a): # invert matrix 2x2
det = a[0][0]*a[1][1] - a[1][0]*a[0][1]
if det==0: return None
return [
[a[1][1]/det, -a[0][1]/det],
[-a[1][0]/det, a[0][0]/det]
]
def small(a) :
global small_tolerance
return abs(a)<small_tolerance
def atan2(*arg):
if len(arg)==1 and ( type(arg[0]) == type([0.,0.]) or type(arg[0])==type((0.,0.)) ) :
return (math.pi/2 - math.atan2(arg[0][0], arg[0][1]) ) % math.pi2
elif len(arg)==2 :
return (math.pi/2 - math.atan2(arg[0],arg[1]) ) % math.pi2
else :
raise ValueError, "Bad argumets for atan! (%s)" % arg
def get_text(node) :
value = None
if node.text!=None : value = value +"\n" + node.text if value != None else node.text
for k in node :
if k.tag == inkex.addNS('tspan','svg'):
if k.text!=None : value = value +"\n" + k.text if value != None else k.text
return value
def draw_text(text,x,y, group = None, style = None, font_size = 10, gcodetools_tag = None) :
if style == None :
style = "font-family:DejaVu Sans;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:DejaVu Sans;fill:#000000;fill-opacity:1;stroke:none;"
style += "font-size:%fpx;"%font_size
attributes = { 'x': str(x),
inkex.addNS("space","xml"):"preserve",
'y': str(y),
'style' : style
}
if gcodetools_tag!=None :
attributes["gcodetools"] = str(gcodetools_tag)
if group == None:
group = options.doc_root
t = inkex.etree.SubElement( group, inkex.addNS('text','svg'), attributes)
text = str(text).split("\n")
for s in text :
span = inkex.etree.SubElement( t, inkex.addNS('tspan','svg'),
{
'x': str(x),
'y': str(y),
inkex.addNS("role","sodipodi"):"line",
})
y += font_size
span.text = str(s)
def draw_csp(csp, stroke = "#f00", fill = "none", comment = "", width = 0.354, group = None, style = None, gcodetools_tag = None) :
if style == None :
style = "fill:%s;fill-opacity:1;stroke:%s;stroke-width:%s"%(fill,stroke,width)
attributes = { 'd': cubicsuperpath.formatPath(csp),
'style' : style
}
if comment != '':
attributes['comment'] = comment
if group == None :
group = options.doc_root
return inkex.etree.SubElement( group, inkex.addNS('path','svg'), attributes)
def draw_pointer(x,color = "#f00", figure = "cross", group = None, comment = "", fill=None, width = .1, size = 10., text = None, font_size=None, pointer_type=None, attrib = None) :
size = size/2
if attrib == None : attrib = {}
if pointer_type == None:
pointer_type = "Pointer"
attrib["gcodetools"] = pointer_type
if group == None:
group = options.self.current_layer
if text != None :
if font_size == None : font_size = 7
group = inkex.etree.SubElement( group, inkex.addNS('g','svg'), {"gcodetools": pointer_type+" group"} )
draw_text(text,x[0]+size*2.2,x[1]-size, group = group, font_size = font_size)
if figure == "line" :
s = ""
for i in range(1,len(x)/2) :
s+= " %s, %s " %(x[i*2],x[i*2+1])
attrib.update({"d": "M %s,%s L %s"%(x[0],x[1],s), "style":"fill:none;stroke:%s;stroke-width:%f;"%(color,width),"comment":str(comment)})
inkex.etree.SubElement( group, inkex.addNS('path','svg'), attrib)
elif figure == "arrow" :
if fill == None : fill = "#12b3ff"
fill_opacity = "0.8"
d = "m %s,%s " % (x[0],x[1]) + re.sub("([0-9\-.e]+)",(lambda match: str(float(match.group(1))*size*2.)), "0.88464,-0.40404 c -0.0987,-0.0162 -0.186549,-0.0589 -0.26147,-0.1173 l 0.357342,-0.35625 c 0.04631,-0.039 0.0031,-0.13174 -0.05665,-0.12164 -0.0029,-1.4e-4 -0.0058,-1.4e-4 -0.0087,0 l -2.2e-5,2e-5 c -0.01189,0.004 -0.02257,0.0119 -0.0305,0.0217 l -0.357342,0.35625 c -0.05818,-0.0743 -0.102813,-0.16338 -0.117662,-0.26067 l -0.409636,0.88193 z")
attrib.update({"d": d, "style":"fill:%s;stroke:none;fill-opacity:%s;"%(fill,fill_opacity),"comment":str(comment)})
inkex.etree.SubElement( group, inkex.addNS('path','svg'), attrib)
else :
attrib.update({"d": "m %s,%s l %f,%f %f,%f %f,%f %f,%f , %f,%f"%(x[0],x[1], size,size, -2*size,-2*size, size,size, size,-size, -2*size,2*size ), "style":"fill:none;stroke:%s;stroke-width:%f;"%(color,width),"comment":str(comment)})
inkex.etree.SubElement( group, inkex.addNS('path','svg'), attrib)
def straight_segments_intersection(a,b, true_intersection = True) : # (True intersection means check ta and tb are in [0,1])
ax,bx,cx,dx, ay,by,cy,dy = a[0][0],a[1][0],b[0][0],b[1][0], a[0][1],a[1][1],b[0][1],b[1][1]
if (ax==bx and ay==by) or (cx==dx and cy==dy) : return False, 0, 0
if (bx-ax)*(dy-cy)-(by-ay)*(dx-cx)==0 : # Lines are parallel
ta = (ax-cx)/(dx-cx) if cx!=dx else (ay-cy)/(dy-cy)
tb = (bx-cx)/(dx-cx) if cx!=dx else (by-cy)/(dy-cy)
tc = (cx-ax)/(bx-ax) if ax!=bx else (cy-ay)/(by-ay)
td = (dx-ax)/(bx-ax) if ax!=bx else (dy-ay)/(by-ay)
return ("Overlap" if 0<=ta<=1 or 0<=tb<=1 or 0<=tc<=1 or 0<=td<=1 or not true_intersection else False), (ta,tb), (tc,td)
else :
ta = ( (ay-cy)*(dx-cx)-(ax-cx)*(dy-cy) ) / ( (bx-ax)*(dy-cy)-(by-ay)*(dx-cx) )
tb = ( ax-cx+ta*(bx-ax) ) / (dx-cx) if dx!=cx else ( ay-cy+ta*(by-ay) ) / (dy-cy)
return (0<=ta<=1 and 0<=tb<=1 or not true_intersection), ta, tb
def isnan(x): return type(x) is float and x != x
def isinf(x): inf = 1e5000; return x == inf or x == -inf
def between(c,x,y):
return x-straight_tolerance<=c<=y+straight_tolerance or y-straight_tolerance<=c<=x+straight_tolerance
def cubic_solver_real(a,b,c,d):
# returns only real roots of a cubic equation.
roots = cubic_solver(a,b,c,d)
res = []
for root in roots :
if type(root) is complex :
if -1e-10<root.imag<1e-10 :
res.append(root.real)
else :
res.append(root)
return res
def cubic_solver(a,b,c,d):
if a!=0:
# Monics formula see http://en.wikipedia.org/wiki/Cubic_function#Monic_formula_of_roots
a,b,c = (b/a, c/a, d/a)
m = 2*a**3 - 9*a*b + 27*c
k = a**2 - 3*b
n = m**2 - 4*k**3
w1 = -.5 + .5*cmath.sqrt(3)*1j
w2 = -.5 - .5*cmath.sqrt(3)*1j
if n>=0 :
t = m+math.sqrt(n)
m1 = pow(t/2,1./3) if t>=0 else -pow(-t/2,1./3)
t = m-math.sqrt(n)
n1 = pow(t/2,1./3) if t>=0 else -pow(-t/2,1./3)
else :
m1 = pow(complex((m+cmath.sqrt(n))/2),1./3)
n1 = pow(complex((m-cmath.sqrt(n))/2),1./3)
x1 = -1./3 * (a + m1 + n1)
x2 = -1./3 * (a + w1*m1 + w2*n1)
x3 = -1./3 * (a + w2*m1 + w1*n1)
return [x1,x2,x3]
elif b!=0:
det = c**2-4*b*d
if det>0 :
return [(-c+math.sqrt(det))/(2*b),(-c-math.sqrt(det))/(2*b)]
elif d == 0 :
return [-c/(b*b)]
else :
return [(-c+cmath.sqrt(det))/(2*b),(-c-cmath.sqrt(det))/(2*b)]
elif c!=0 :
return [-d/c]
else : return []
################################################################################
### print_ prints any arguments into specified log file
################################################################################
def print_(*arg):
f = open(options.log_filename,"a")
for s in arg :
s = str(unicode(s).encode('unicode_escape'))+" "
f.write( s )
f.write("\n")
f.close()
################################################################################
### Point (x,y) operations
################################################################################
class P:
def __init__(self, x, y=None):
if not y==None:
self.x, self.y = float(x), float(y)
else:
self.x, self.y = float(x[0]), float(x[1])
def __add__(self, other): return P(self.x + other.x, self.y + other.y)
def __sub__(self, other): return P(self.x - other.x, self.y - other.y)
def __neg__(self): return P(-self.x, -self.y)
def __mul__(self, other):
if isinstance(other, P):
return self.x * other.x + self.y * other.y
return P(self.x * other, self.y * other)
__rmul__ = __mul__
def __div__(self, other): return P(self.x / other, self.y / other)
def mag(self): return math.hypot(self.x, self.y)
def unit(self):
h = self.mag()
if h: return self / h
else: return P(0,0)
def dot(self, other): return self.x * other.x + self.y * other.y
def rot(self, theta):
c = math.cos(theta)
s = math.sin(theta)
return P(self.x * c - self.y * s, self.x * s + self.y * c)
def angle(self): return math.atan2(self.y, self.x)
def __repr__(self): return '%f,%f' % (self.x, self.y)
def pr(self): return "%.2f,%.2f" % (self.x, self.y)
def to_list(self): return [self.x, self.y]
def ccw(self): return P(-self.y,self.x)
def l2(self): return self.x*self.x + self.y*self.y
class Arc():
def __init__(self,st,end,c,a):
self.st = P(st)
self.end = P(end)
self.c = P(c)
self.r = (P(st)-P(c)).mag()
self.a = ( (self.st-self.c).angle() - (self.end-self.c).angle() ) % math.pi2
if a<0 : self.a -= math.pi2
def offset(self, r):
if self.a>0 :
r += self.r
else :
r = self.r - r
if self.r != 0 :
self.st = self.c + (self.st-self.c)*r/self.r
self.end = self.c + (self.end-self.c)*r/self.r
self.r = r
def length(self):
return abs(self.a*self.r)
def draw(self, group, style, layer, transform, num = 0, reverse_angle = 1):
st = P(gcodetools.transform(self.st.to_list(), layer, True))
c = P(gcodetools.transform(self.c.to_list(), layer, True))
a = self.a * reverse_angle
r = (st-c)
a_st = (math.atan2(r.x,-r.y) - math.pi/2) % (math.pi*2)
r = r.mag()
if a<0:
a_end = a_st+a
style = style['biarc%s'%(num%2)]
else:
a_end = a_st
a_st = a_st+a
style = style['biarc%s_r'%(num%2)]
attr = {
'style': style,
inkex.addNS('cx','sodipodi'): str(c.x),
inkex.addNS('cy','sodipodi'): str(c.y),
inkex.addNS('rx','sodipodi'): str(r),
inkex.addNS('ry','sodipodi'): str(r),
inkex.addNS('start','sodipodi'): str(a_st),
inkex.addNS('end','sodipodi'): str(a_end),
inkex.addNS('open','sodipodi'): 'true',
inkex.addNS('type','sodipodi'): 'arc',
"gcodetools": "Preview",
}
if transform != [] :
attr["transform"] = transform
inkex.etree.SubElement( group, inkex.addNS('path','svg'), attr)
def intersect(self,b) :
return []
class Line():
def __init__(self,st,end):
if st.__class__ == P :
st = st.to_list()
if end.__class__ == P :
end = end.to_list()
self.st = P(st)
self.end = P(end)
self.l = self.length()
if self.l != 0 :
self.n = ((self.end-self.st)/self.l).ccw()
else:
self.n = [0,1]
def offset(self, r):
self.st -= self.n*r
self.end -= self.n*r
def l2(self): return (self.st-self.end).l2()
def length(self): return (self.st-self.end).mag()
def draw(self, group, style, layer, transform, num = 0, reverse_angle = 1):
st = gcodetools.transform(self.st.to_list(), layer, True)
end = gcodetools.transform(self.end.to_list(), layer, True)
attr = { 'style': style['line'],
'd':'M %s,%s L %s,%s' % (st[0],st[1],end[0],end[1]),
"gcodetools": "Preview",
}
if transform != [] :
attr["transform"] = transform
inkex.etree.SubElement( group, inkex.addNS('path','svg'), attr )
def intersect(self,b) :
if b.__class__ == Line :
if self.l < 10e-8 or b.l < 10e-8 : return []
v1 = self.end - self.st
v2 = b.end - b.st
x = v1.x*v2.y - v2.x*v1.y
if x == 0 :
# lines are parallel
res = []
if (self.st.x-b.st.x)*v1.y - (self.st.y-b.st.y)*v1.x == 0:
# lines are the same
if v1.x != 0 :
if 0<=(self.st.x-b.st.x)/v2.x<=1 : res.append(self.st)
if 0<=(self.end.x-b.st.x)/v2.x<=1 : res.append(self.end)
if 0<=(b.st.x-self.st.x)/v1.x<=1 : res.append(b.st)
if 0<=(b.end.x-b.st.x)/v1.x<=1 : res.append(b.end)
else :
if 0<=(self.st.y-b.st.y)/v2.y<=1 : res.append(self.st)
if 0<=(self.end.y-b.st.y)/v2.y<=1 : res.append(self.end)
if 0<=(b.st.y-self.st.y)/v1.y<=1 : res.append(b.st)
if 0<=(b.end.y-b.st.y)/v1.y<=1 : res.append(b.end)
return res
else :
t1 = ( -v1.x*(b.end.y-self.end.y) + v1.y*(b.end.x-self.end.x) ) / x
t2 = ( -v1.y*(self.st.x-b.st.x) + v1.x*(self.st.y-b.st.y) ) / x
gcodetools.error((x,t1,t2), "warning")
if 0<=t1<=1 and 0<=t2<=1 : return [ self.st+v1*t1 ]
else : return []
else: return []
class Biarc:
def __init__(self, items=None):
if items == None :
self.items = []
else:
self.items = items
def l(self) :
return sum([i.length() for i in items])
def close(self) :
for subitems in self.items:
if (subitems[0].st-subitems[-1].end).l2()>10e-16 :
subitems.append(Line(subitems[-1].end,subitems[0].st))
def offset(self,r) :
# offset each element
self.close()
for subitems in self.items :
for item in subitems :
item.offset(r)
self.connect(r)
def connect(self, r) :
for subitems in self.items :
for a,b in zip(subitems, subitems[1:]) :
i = a.intersect(b)
for p in i :
draw_pointer(p.to_list())
def clip_offset(self):
pass
def draw(self, layer, group=None, style=styles["biarc_style"]):
global gcodetools
gcodetools.set_markers()
for i in [0,1]:
style['biarc%s_r'%i] = simplestyle.parseStyle(style['biarc%s'%i])
style['biarc%s_r'%i]["marker-start"] = "url(#DrawCurveMarker_r)"
del(style['biarc%s_r'%i]["marker-end"])
style['biarc%s_r'%i] = simplestyle.formatStyle(style['biarc%s_r'%i])
if group==None:
if "preview_groups" not in dir(options.self) :
gcodetools.preview_groups = { layer: inkex.etree.SubElement( gcodetools.layers[min(1,len(gcodetools.layers)-1)], inkex.addNS('g','svg'), {"gcodetools": "Preview group"} ) }
elif layer not in gcodetools.preview_groups :
gcodetools.preview_groups[layer] = inkex.etree.SubElement( gcodetools.layers[min(1,len(gcodetools.layers)-1)], inkex.addNS('g','svg'), {"gcodetools": "Preview group"} )
group = gcodetools.preview_groups[layer]
transform = gcodetools.get_transforms(group)
if transform != [] :
transform = gcodetools.reverse_transform(transform)
transform = simpletransform.formatTransform(transform)
a,b,c = [0.,0.], [1.,0.], [0.,1.]
k = (b[0]-a[0])*(c[1]-a[1])-(c[0]-a[0])*(b[1]-a[1])
a,b,c = gcodetools.transform(a, layer, True), gcodetools.transform(b, layer, True), gcodetools.transform(c, layer, True)
if ((b[0]-a[0])*(c[1]-a[1])-(c[0]-a[0])*(b[1]-a[1]))*k > 0 : reverse_angle = -1
else : reverse_angle = 1
num = 0
for subitems in self.items :
for item in subitems :
num += 1
#if num>1 : break
item.draw(group, style, layer, transform, num, reverse_angle)
def from_old_style(self, curve) :
#Crve defenitnion [start point, type = {'arc','line','move','end'}, arc center, arc angle, end point, [zstart, zend]]
self.items = []
for sp in curve:
print_(sp)
if sp[1] == 'move':
self.items.append([])
if sp[1] == 'arc':
self.items[-1].append(Arc(sp[0],sp[4],sp[2],sp[3]))
if sp[1] == 'line':
self.items[-1].append(Line(sp[0],sp[4]))
################################################################################
###
### Offset function
###
### This function offsets given cubic super path.
### It's based on src/livarot/PathOutline.cpp from Inkscape's source code.
###
###
################################################################################
def csp_offset(csp, r) :
offset_tolerance = 0.05
offset_subdivision_depth = 10
time_ = time.time()
time_start = time_
print_("Offset start at %s"% time_)
print_("Offset radius %s"% r)
def csp_offset_segment(sp1,sp2,r) :
result = []
t = csp_get_t_at_curvature(sp1,sp2,1/r)
if len(t) == 0 : t =[0.,1.]
t.sort()
if t[0]>.00000001 : t = [0.]+t
if t[-1]<.99999999 : t.append(1.)
for st,end in zip(t,t[1:]) :
c = csp_curvature_at_t(sp1,sp2,(st+end)/2)
sp = csp_split_by_two_points(sp1,sp2,st,end)
if sp[1]!=sp[2]:
if (c>1/r and r<0 or c<1/r and r>0) :
offset = offset_segment_recursion(sp[1],sp[2],r, offset_subdivision_depth, offset_tolerance)
else : # This part will be clipped for sure... TODO Optimize it...
offset = offset_segment_recursion(sp[1],sp[2],r, offset_subdivision_depth, offset_tolerance)
if result==[] :
result = offset[:]
else:
if csp_subpaths_end_to_start_distance2(result,offset)<0.0001 :
result = csp_concat_subpaths(result,offset)
else:
intersection = csp_get_subapths_last_first_intersection(result,offset)
if intersection != [] :
i,t1,j,t2 = intersection
sp1_,sp2_,sp3_ = csp_split(result[i-1],result[i],t1)
result = result[:i-1] + [ sp1_, sp2_ ]
sp1_,sp2_,sp3_ = csp_split(offset[j-1],offset[j],t2)
result = csp_concat_subpaths( result, [sp2_,sp3_] + offset[j+1:] )
else :
pass # ???
#raise ValueError, "Offset curvature clipping error"
#draw_csp([result])
return result
def create_offset_segment(sp1,sp2,r) :
# See Gernot Hoffmann "Bezier Curves" p.34 -> 7.1 Bezier Offset Curves
p0,p1,p2,p3 = P(sp1[1]),P(sp1[2]),P(sp2[0]),P(sp2[1])
s0,s1,s3 = p1-p0,p2-p1,p3-p2
n0 = s0.ccw().unit() if s0.l2()!=0 else P(csp_normalized_normal(sp1,sp2,0))
n3 = s3.ccw().unit() if s3.l2()!=0 else P(csp_normalized_normal(sp1,sp2,1))
n1 = s1.ccw().unit() if s1.l2()!=0 else (n0.unit()+n3.unit()).unit()
q0,q3 = p0+r*n0, p3+r*n3
c = csp_curvature_at_t(sp1,sp2,0)
q1 = q0 + (p1-p0)*(1- (r*c if abs(c)<100 else 0) )
c = csp_curvature_at_t(sp1,sp2,1)
q2 = q3 + (p2-p3)*(1- (r*c if abs(c)<100 else 0) )
return [[q0.to_list(), q0.to_list(), q1.to_list()],[q2.to_list(), q3.to_list(), q3.to_list()]]
def csp_get_subapths_last_first_intersection(s1,s2):
_break = False
for i in range(1,len(s1)) :
sp11, sp12 = s1[-i-1], s1[-i]
for j in range(1,len(s2)) :
sp21,sp22 = s2[j-1], s2[j]
intersection = csp_segments_true_intersection(sp11,sp12,sp21,sp22)
if intersection != [] :
_break = True
break
if _break:break
if _break :
intersection = max(intersection)
return [len(s1)-i,intersection[0], j,intersection[1]]
else :
return []
def csp_join_offsets(prev,next,sp1,sp2,sp1_l,sp2_l,r):
if len(next)>1 :
if (P(prev[-1][1])-P(next[0][1])).l2()<0.001 :
return prev,[],next
intersection = csp_get_subapths_last_first_intersection(prev,next)
if intersection != [] :
i,t1,j,t2 = intersection
sp1_,sp2_,sp3_ = csp_split(prev[i-1],prev[i],t1)
sp3_,sp4_,sp5_ = csp_split(next[j-1], next[j],t2)
return prev[:i-1] + [ sp1_, sp2_ ], [], [sp4_,sp5_] + next[j+1:]
# Offsets do not intersect... will add an arc...
start = (P(csp_at_t(sp1_l,sp2_l,1.)) + r*P(csp_normalized_normal(sp1_l,sp2_l,1.))).to_list()
end = (P(csp_at_t(sp1,sp2,0.)) + r*P(csp_normalized_normal(sp1,sp2,0.))).to_list()
arc = csp_from_arc(start, end, sp1[1], r, csp_normalized_slope(sp1_l,sp2_l,1.) )
if arc == [] :
return prev,[],next
else:
# Clip prev by arc
if csp_subpaths_end_to_start_distance2(prev,arc)>0.00001 :
intersection = csp_get_subapths_last_first_intersection(prev,arc)
if intersection != [] :
i,t1,j,t2 = intersection
sp1_,sp2_,sp3_ = csp_split(prev[i-1],prev[i],t1)
sp3_,sp4_,sp5_ = csp_split(arc[j-1],arc[j],t2)
prev = prev[:i-1] + [ sp1_, sp2_ ]
arc = [sp4_,sp5_] + arc[j+1:]
#else : raise ValueError, "Offset curvature clipping error"
# Clip next by arc
if next == [] :
return prev,[],arc
if csp_subpaths_end_to_start_distance2(arc,next)>0.00001 :
intersection = csp_get_subapths_last_first_intersection(arc,next)
if intersection != [] :
i,t1,j,t2 = intersection
sp1_,sp2_,sp3_ = csp_split(arc[i-1],arc[i],t1)
sp3_,sp4_,sp5_ = csp_split(next[j-1],next[j],t2)
arc = arc[:i-1] + [ sp1_, sp2_ ]
next = [sp4_,sp5_] + next[j+1:]
#else : raise ValueError, "Offset curvature clipping error"
return prev,arc,next
def offset_segment_recursion(sp1,sp2,r, depth, tolerance) :
sp1_r,sp2_r = create_offset_segment(sp1,sp2,r)
err = max(
csp_seg_to_point_distance(sp1_r,sp2_r, (P(csp_at_t(sp1,sp2,.25)) + P(csp_normalized_normal(sp1,sp2,.25))*r).to_list())[0],
csp_seg_to_point_distance(sp1_r,sp2_r, (P(csp_at_t(sp1,sp2,.50)) + P(csp_normalized_normal(sp1,sp2,.50))*r).to_list())[0],
csp_seg_to_point_distance(sp1_r,sp2_r, (P(csp_at_t(sp1,sp2,.75)) + P(csp_normalized_normal(sp1,sp2,.75))*r).to_list())[0],
)
if err>tolerance**2 and depth>0:
#print_(csp_seg_to_point_distance(sp1_r,sp2_r, (P(csp_at_t(sp1,sp2,.25)) + P(csp_normalized_normal(sp1,sp2,.25))*r).to_list())[0], tolerance)
if depth > offset_subdivision_depth-2 :
t = csp_max_curvature(sp1,sp2)
t = max(.1,min(.9 ,t))
else :
t = .5
sp3,sp4,sp5 = csp_split(sp1,sp2,t)
r1 = offset_segment_recursion(sp3,sp4,r, depth-1, tolerance)
r2 = offset_segment_recursion(sp4,sp5,r, depth-1, tolerance)
return r1[:-1]+ [[r1[-1][0],r1[-1][1],r2[0][2]]] + r2[1:]
else :
#draw_csp([[sp1_r,sp2_r]])
#draw_pointer(sp1[1]+sp1_r[1], "#057", "line")
#draw_pointer(sp2[1]+sp2_r[1], "#705", "line")
return [sp1_r,sp2_r]
############################################################################
# Some small definitions
############################################################################
csp_len = len(csp)
############################################################################
# Prepare the path
############################################################################
# Remove all small segments (segment length < 0.001)
for i in xrange(len(csp)) :
for j in xrange(len(csp[i])) :
sp = csp[i][j]
if (P(sp[1])-P(sp[0])).mag() < 0.001 :
csp[i][j][0] = sp[1]
if (P(sp[2])-P(sp[0])).mag() < 0.001 :
csp[i][j][2] = sp[1]
for i in xrange(len(csp)) :
for j in xrange(1,len(csp[i])) :
if cspseglength(csp[i][j-1], csp[i][j])<0.001 :
csp[i] = csp[i][:j] + csp[i][j+1:]
if cspseglength(csp[i][-1],csp[i][0])>0.001 :
csp[i][-1][2] = csp[i][-1][1]
csp[i]+= [ [csp[i][0][1],csp[i][0][1],csp[i][0][1]] ]
# TODO Get rid of self intersections.
original_csp = csp[:]
# Clip segments which has curvature>1/r. Because their offset will be selfintersecting and very nasty.
print_("Offset prepared the path in %s"%(time.time()-time_))
print_("Path length = %s"% sum([len(i)for i in csp] ) )
time_ = time.time()
############################################################################
# Offset
############################################################################
# Create offsets for all segments in the path. And join them together inside each subpath.
unclipped_offset = [[] for i in xrange(csp_len)]
offsets_original = [[] for i in xrange(csp_len)]
join_points = [[] for i in xrange(csp_len)]
intersection = [[] for i in xrange(csp_len)]
for i in xrange(csp_len) :
subpath = csp[i]
subpath_offset = []
last_offset_len = 0
for sp1,sp2 in zip(subpath, subpath[1:]) :
segment_offset = csp_offset_segment(sp1,sp2,r)
if subpath_offset == [] :
subpath_offset = segment_offset
prev_l = len(subpath_offset)
else :
prev, arc, next = csp_join_offsets(subpath_offset[-prev_l:],segment_offset,sp1,sp2,sp1_l,sp2_l,r)
#draw_csp([prev],"Blue")
#draw_csp([arc],"Magenta")
subpath_offset = csp_concat_subpaths(subpath_offset[:-prev_l+1],prev,arc,next)
prev_l = len(next)
sp1_l, sp2_l = sp1[:], sp2[:]
# Join last and first offsets togother to close the curve
prev, arc, next = csp_join_offsets(subpath_offset[-prev_l:], subpath_offset[:2], subpath[0], subpath[1], sp1_l,sp2_l, r)
subpath_offset[:2] = next[:]
subpath_offset = csp_concat_subpaths(subpath_offset[:-prev_l+1],prev,arc)
#draw_csp([prev],"Blue")
#draw_csp([arc],"Red")
#draw_csp([next],"Red")
# Collect subpath's offset and save it to unclipped offset list.
unclipped_offset[i] = subpath_offset[:]
#for k,t in intersection[i]:
# draw_pointer(csp_at_t(subpath_offset[k-1], subpath_offset[k], t))
#inkex.etree.SubElement( options.doc_root, inkex.addNS('path','svg'), {"d": cubicsuperpath.formatPath(unclipped_offset), "style":"fill:none;stroke:#0f0;"} )
print_("Offsetted path in %s"%(time.time()-time_))
time_ = time.time()
#for i in range(len(unclipped_offset)):
# draw_csp([unclipped_offset[i]], color = ["Green","Red","Blue"][i%3], width = .1)
#return []
############################################################################
# Now to the clipping.
############################################################################
# First of all find all intersection's between all segments of all offseted subpaths, including self intersections.
#TODO define offset tolerance here
global small_tolerance
small_tolerance = 0.01
summ = 0
summ1 = 0
for subpath_i in xrange(csp_len) :
for subpath_j in xrange(subpath_i,csp_len) :
subpath = unclipped_offset[subpath_i]
subpath1 = unclipped_offset[subpath_j]
for i in xrange(1,len(subpath)) :
# If subpath_i==subpath_j we are looking for self intersections, so
# we'll need search intersections only for xrange(i,len(subpath1))
for j in ( xrange(i,len(subpath1)) if subpath_i==subpath_j else xrange(len(subpath1))) :
if subpath_i==subpath_j and j==i :
# Find self intersections of a segment
sp1,sp2,sp3 = csp_split(subpath[i-1],subpath[i],.5)
intersections = csp_segments_intersection(sp1,sp2,sp2,sp3)
summ +=1
for t in intersections :
summ1 += 1
if not ( small(t[0]-1) and small(t[1]) ) and 0<=t[0]<=1 and 0<=t[1]<=1 :
intersection[subpath_i] += [ [i,t[0]/2],[j,t[1]/2+.5] ]
else :
intersections = csp_segments_intersection(subpath[i-1],subpath[i],subpath1[j-1],subpath1[j])
summ +=1
for t in intersections :
summ1 += 1
#TODO tolerance dependence to cpsp_length(t)
if len(t) == 2 and 0<=t[0]<=1 and 0<=t[1]<=1 and not (
subpath_i==subpath_j and (
(j-i-1) % (len(subpath)-1) == 0 and small(t[0]-1) and small(t[1]) or
(i-j-1) % (len(subpath)-1) == 0 and small(t[1]-1) and small(t[0]) ) ) :
intersection[subpath_i] += [ [i,t[0]] ]
intersection[subpath_j] += [ [j,t[1]] ]
#draw_pointer(csp_at_t(subpath[i-1],subpath[i],t[0]),"#f00")
#print_(t)
#print_(i,j)
elif len(t)==5 and t[4]=="Overlap":
intersection[subpath_i] += [ [i,t[0]], [i,t[1]] ]
intersection[subpath_j] += [ [j,t[1]], [j,t[3]] ]
print_("Intersections found in %s"%(time.time()-time_))
print_("Examined %s segments"%(summ))
print_("found %s intersections"%(summ1))
time_ = time.time()
########################################################################
# Split unclipped offset by intersection points into splitted_offset
########################################################################
splitted_offset = []
for i in xrange(csp_len) :
subpath = unclipped_offset[i]
if len(intersection[i]) > 0 :
parts = csp_subpath_split_by_points(subpath, intersection[i])
# Close parts list to close path (The first and the last parts are joined together)
if [1,0.] not in intersection[i] :
parts[0][0][0] = parts[-1][-1][0]
parts[0] = csp_concat_subpaths(parts[-1], parts[0])
splitted_offset += parts[:-1]
else:
splitted_offset += parts[:]
else :
splitted_offset += [subpath[:]]
#for i in range(len(splitted_offset)):
# draw_csp([splitted_offset[i]], color = ["Green","Red","Blue"][i%3])
print_("Splitted in %s"%(time.time()-time_))
time_ = time.time()
########################################################################
# Clipping
########################################################################
result = []
for subpath_i in range(len(splitted_offset)):
clip = False
s1 = splitted_offset[subpath_i]
for subpath_j in range(len(splitted_offset)):
s2 = splitted_offset[subpath_j]
if (P(s1[0][1])-P(s2[-1][1])).l2()<0.0001 and ( (subpath_i+1) % len(splitted_offset) != subpath_j ):
if dot(csp_normalized_normal(s2[-2],s2[-1],1.),csp_normalized_slope(s1[0],s1[1],0.))*r<-0.0001 :
clip = True
break
if (P(s2[0][1])-P(s1[-1][1])).l2()<0.0001 and ( (subpath_j+1) % len(splitted_offset) != subpath_i ):
if dot(csp_normalized_normal(s2[0],s2[1],0.),csp_normalized_slope(s1[-2],s1[-1],1.))*r>0.0001 :
clip = True
break
if not clip :
result += [s1[:]]
elif options.offset_draw_clippend_path :
draw_csp([s1],color="Red",width=.1)
draw_pointer( csp_at_t(s2[-2],s2[-1],1.)+
(P(csp_at_t(s2[-2],s2[-1],1.))+ P(csp_normalized_normal(s2[-2],s2[-1],1.))*10).to_list(),"Green", "line" )
draw_pointer( csp_at_t(s1[0],s1[1],0.)+
(P(csp_at_t(s1[0],s1[1],0.))+ P(csp_normalized_slope(s1[0],s1[1],0.))*10).to_list(),"Red", "line" )
# Now join all together and check closure and orientation of result
joined_result = csp_join_subpaths(result)
# Check if each subpath from joined_result is closed
#draw_csp(joined_result,color="Green",width=1)
for s in joined_result[:] :
if csp_subpaths_end_to_start_distance2(s,s) > 0.001 :
# Remove open parts
if options.offset_draw_clippend_path:
draw_csp([s],color="Orange",width=1)
draw_pointer(s[0][1], comment= csp_subpaths_end_to_start_distance2(s,s))
draw_pointer(s[-1][1], comment = csp_subpaths_end_to_start_distance2(s,s))
joined_result.remove(s)
else :
# Remove small parts
minx,miny,maxx,maxy = csp_true_bounds([s])
if (minx[0]-maxx[0])**2 + (miny[1]-maxy[1])**2 < 0.1 :
joined_result.remove(s)
print_("Clipped and joined path in %s"%(time.time()-time_))
time_ = time.time()
########################################################################
# Now to the Dummy cliping: remove parts from splitted offset if their
# centers are closer to the original path than offset radius.
########################################################################
r1,r2 = ( (0.99*r)**2, (1.01*r)**2 ) if abs(r*.01)<1 else ((abs(r)-1)**2, (abs(r)+1)**2)
for s in joined_result[:]:
dist = csp_to_point_distance(original_csp, s[int(len(s)/2)][1], dist_bounds = [r1,r2], tolerance = .000001)
if not r1 < dist[0] < r2 :
joined_result.remove(s)
if options.offset_draw_clippend_path:
draw_csp([s], comment = math.sqrt(dist[0]))
draw_pointer(csp_at_t(csp[dist[1]][dist[2]-1],csp[dist[1]][dist[2]],dist[3])+s[int(len(s)/2)][1],"blue", "line", comment = [math.sqrt(dist[0]),i,j,sp] )
print_("-----------------------------")
print_("Total offset time %s"%(time.time()-time_start))
print_()
return joined_result
################################################################################
###
### Biarc function
###
### Calculates biarc approximation of cubic super path segment
### splits segment if needed or approximates it with straight line
###
################################################################################
def biarc(sp1, sp2, z1, z2, depth=0):
def biarc_split(sp1,sp2, z1, z2, depth):
if depth<options.biarc_max_split_depth:
sp1,sp2,sp3 = csp_split(sp1,sp2)
l1, l2 = cspseglength(sp1,sp2), cspseglength(sp2,sp3)
if l1+l2 == 0 : zm = z1
else : zm = z1+(z2-z1)*l1/(l1+l2)
return biarc(sp1,sp2,z1,zm,depth+1)+biarc(sp2,sp3,zm,z2,depth+1)
else: return [ [sp1[1],'line', 0, 0, sp2[1], [z1,z2]] ]
P0, P4 = P(sp1[1]), P(sp2[1])
TS, TE, v = (P(sp1[2])-P0), -(P(sp2[0])-P4), P0 - P4
tsa, tea, va = TS.angle(), TE.angle(), v.angle()
if TE.mag()<straight_distance_tolerance and TS.mag()<straight_distance_tolerance:
# Both tangents are zerro - line straight
return [ [sp1[1],'line', 0, 0, sp2[1], [z1,z2]] ]
if TE.mag() < straight_distance_tolerance:
TE = -(TS+v).unit()
r = TS.mag()/v.mag()*2
elif TS.mag() < straight_distance_tolerance:
TS = -(TE+v).unit()
r = 1/( TE.mag()/v.mag()*2 )
else:
r=TS.mag()/TE.mag()
TS, TE = TS.unit(), TE.unit()
tang_are_parallel = ((tsa-tea)%math.pi<straight_tolerance or math.pi-(tsa-tea)%math.pi<straight_tolerance )
if ( tang_are_parallel and
((v.mag()<straight_distance_tolerance or TE.mag()<straight_distance_tolerance or TS.mag()<straight_distance_tolerance) or
1-abs(TS*v/(TS.mag()*v.mag()))<straight_tolerance) ):
# Both tangents are parallel and start and end are the same - line straight
# or one of tangents still smaller then tollerance
# Both tangents and v are parallel - line straight
return [ [sp1[1],'line', 0, 0, sp2[1], [z1,z2]] ]
c,b,a = v*v, 2*v*(r*TS+TE), 2*r*(TS*TE-1)
if v.mag()==0:
return biarc_split(sp1, sp2, z1, z2, depth)
asmall, bsmall, csmall = abs(a)<10**-10,abs(b)<10**-10,abs(c)<10**-10
if asmall and b!=0: beta = -c/b
elif csmall and a!=0: beta = -b/a
elif not asmall:
discr = b*b-4*a*c
if discr < 0: raise ValueError, (a,b,c,discr)
disq = discr**.5
beta1 = (-b - disq) / 2 / a
beta2 = (-b + disq) / 2 / a
if beta1*beta2 > 0 : raise ValueError, (a,b,c,disq,beta1,beta2)
beta = max(beta1, beta2)
elif asmall and bsmall:
return biarc_split(sp1, sp2, z1, z2, depth)
alpha = beta * r
ab = alpha + beta
P1 = P0 + alpha * TS
P3 = P4 - beta * TE
P2 = (beta / ab) * P1 + (alpha / ab) * P3
def calculate_arc_params(P0,P1,P2):
D = (P0+P2)/2
if (D-P1).mag()==0: return None, None
R = D - ( (D-P0).mag()**2/(D-P1).mag() )*(P1-D).unit()
p0a, p1a, p2a = (P0-R).angle()%(2*math.pi), (P1-R).angle()%(2*math.pi), (P2-R).angle()%(2*math.pi)
alpha = (p2a - p0a) % (2*math.pi)
if (p0a<p2a and (p1a<p0a or p2a<p1a)) or (p2a<p1a<p0a) :
alpha = -2*math.pi+alpha
if abs(R.x)>1000000 or abs(R.y)>1000000 or (R-P0).mag<options.min_arc_radius**2 :
return None, None
else :
return R, alpha
R1,a1 = calculate_arc_params(P0,P1,P2)
R2,a2 = calculate_arc_params(P2,P3,P4)
if R1==None or R2==None or (R1-P0).mag()<straight_tolerance or (R2-P2).mag()<straight_tolerance : return [ [sp1[1],'line', 0, 0, sp2[1], [z1,z2]] ]
d = csp_to_arc_distance(sp1,sp2, [P0,P2,R1,a1],[P2,P4,R2,a2])
if d > options.biarc_tolerance and depth<options.biarc_max_split_depth : return biarc_split(sp1, sp2, z1, z2, depth)
else:
if R2.mag()*a2 == 0 : zm = z2
else : zm = z1 + (z2-z1)*(abs(R1.mag()*a1))/(abs(R2.mag()*a2)+abs(R1.mag()*a1))
l = (P0-P2).l2()
if l < EMC_TOLERANCE_EQUAL**2 or l<EMC_TOLERANCE_EQUAL**2 * R1.l2() /100 :
# arc should be straight otherwise it could be threated as full circle
arc1 = [ sp1[1], 'line', 0, 0, [P2.x,P2.y], [z1,zm] ]
else :
arc1 = [ sp1[1], 'arc', [R1.x,R1.y], a1, [P2.x,P2.y], [z1,zm] ]
l = (P4-P2).l2()
if l < EMC_TOLERANCE_EQUAL**2 or l<EMC_TOLERANCE_EQUAL**2 * R2.l2() /100 :
# arc should be straight otherwise it could be threated as full circle
arc2 = [ [P2.x,P2.y], 'line', 0, 0, [P4.x,P4.y], [zm,z2] ]
else :
arc2 = [ [P2.x,P2.y], 'arc', [R2.x,R2.y], a2, [P4.x,P4.y], [zm,z2] ]
return [ arc1, arc2 ]
def biarc_curve_segment_length(seg):
if seg[1] == "arc" :
return math.sqrt((seg[0][0]-seg[2][0])**2+(seg[0][1]-seg[2][1])**2)*seg[3]
elif seg[1] == "line" :
return math.sqrt((seg[0][0]-seg[4][0])**2+(seg[0][1]-seg[4][1])**2)
else:
return 0
def biarc_curve_clip_at_l(curve, l, clip_type = "strict") :
# get first subcurve and ceck it's length
subcurve, subcurve_l, moved = [], 0, False
for seg in curve:
if seg[1] == "move" and moved or seg[1] == "end" :
break
if seg[1] == "move" : moved = True
subcurve_l += biarc_curve_segment_length(seg)
if seg[1] == "arc" or seg[1] == "line" :
subcurve += [seg]
if subcurve_l < l and clip_type == "strict" : return []
lc = 0
if (subcurve[-1][4][0]-subcurve[0][0][0])**2 + (subcurve[-1][4][1]-subcurve[0][0][1])**2 < 10**-7 : subcurve_closed = True
i = 0
reverse = False
while lc<l :
seg = subcurve[i]
if reverse :
if seg[1] == "line" :
seg = [seg[4], "line", 0 , 0, seg[0], seg[5]] # Hmmm... Do we have to swap seg[5][0] and seg[5][1] (zstart and zend) or not?
elif seg[1] == "arc" :
seg = [seg[4], "arc", seg[2] , -seg[3], seg[0], seg[5]] # Hmmm... Do we have to swap seg[5][0] and seg[5][1] (zstart and zend) or not?
ls = biarc_curve_segment_length(seg)
if ls != 0 :
if l-lc>ls :
res += [seg]
else :
if seg[1] == "arc" :
r = math.sqrt((seg[0][0]-seg[2][0])**2+(seg[0][1]-seg[2][1])**2)
x,y = seg[0][0]-seg[2][0], seg[0][1]-seg[2][1]
a = seg[3]/ls*(l-lc)
x,y = x*math.cos(a) - y*math.sin(a), x*math.sin(a) + y*math.cos(a)
x,y = x+seg[2][0], y+seg[2][1]
res += [[ seg[0], "arc", seg[2], a, [x,y], [seg[5][0],seg[5][1]/ls*(l-lc)] ]]
if seg[1] == "line" :
res += [[ seg[0], "line", 0, 0, [(seg[4][0]-seg[0][0])/ls*(l-lc),(seg[4][1]-seg[0][1])/ls*(l-lc)], [seg[5][0],seg[5][1]/ls*(l-lc)] ]]
i += 1
if i >= len(subcurve) and not subcurve_closed:
reverse = not reverse
i = i%len(subcurve)
return res
class Postprocessor():
def __init__(self, error_function_handler):
self.error = error_function_handler
self.functions = {
"remap" : self.remap,
"remapi" : self.remapi ,
"scale" : self.scale,
"move" : self.move,
"flip" : self.flip_axis,
"flip_axis" : self.flip_axis,
"round" : self.round_coordinates,
"parameterize" : self.parameterize,
"regex" : self.re_sub_on_gcode_lines
}
def process(self,command):
command = re.sub(r"\\\\",":#:#:slash:#:#:",command)
command = re.sub(r"\\;",":#:#:semicolon:#:#:",command)
command = command.split(";")
for s in command:
s = re.sub(":#:#:slash:#:#:","\\\\",s)
s = re.sub(":#:#:semicolon:#:#:","\\;",s)
s = s.strip()
if s!="" :
self.parse_command(s)
def parse_command(self,command):
r = re.match(r"([A-Za-z0-9_]+)\s*\(\s*(.*)\)",command)
if not r:
self.error("Parse error while postprocessing.\n(Command: '%s')"%(command), "error")
function, parameters = r.group(1).lower(),r.group(2)
if function in self.functions :
print_("Postprocessor: executing function %s(%s)"%(function,parameters))
self.functions[function](parameters)
else :
self.error("Unrecognized function '%s' while postprocessing.\n(Command: '%s')"%(function,command), "error")
def re_sub_on_gcode_lines(self, parameters):
gcode = self.gcode.split("\n")
self.gcode = ""
try :
for line in gcode :
self.gcode += eval( "re.sub(%s,line)"%parameters) +"\n"
except Exception as ex :
self.error("Bad parameters for regexp. They should be as re.sub pattern and replacement parameters! For example: r\"G0(\d)\", r\"G\\1\" \n(Parameters: '%s')\n %s"%(parameters, ex), "error")
def remapi(self,parameters):
self.remap(parameters, case_sensitive = True)
def remap(self,parameters, case_sensitive = False):
# remap parameters should be like "x->y,y->x"
parameters = parameters.replace("\,",":#:#:coma:#:#:")
parameters = parameters.split(",")
pattern, remap = [], []
for s in parameters:
s = s.replace(":#:#:coma:#:#:","\,")
r = re.match("""\s*(\'|\")(.*)\\1\s*->\s*(\'|\")(.*)\\3\s*""",s)
if not r :
self.error("Bad parameters for remap.\n(Parameters: '%s')"%(parameters), "error")
pattern +=[r.group(2)]
remap +=[r.group(4)]
for i in range(len(pattern)) :
if case_sensitive :
self.gcode = ireplace(self.gcode, pattern[i], ":#:#:remap_pattern%s:#:#:"%i )
else :
self.gcode = self.gcode.replace(pattern[i], ":#:#:remap_pattern%s:#:#:"%i)
for i in range(len(remap)) :
self.gcode = self.gcode.replace(":#:#:remap_pattern%s:#:#:"%i, remap[i])
def transform(self, move, scale):
axis = ["xi","yj","zk","a"]
flip = scale[0]*scale[1]*scale[2] < 0
gcode = ""
warned = []
r_scale = scale[0]
plane = "g17"
for s in self.gcode.split("\n"):
# get plane selection:
s_wo_comments = re.sub(r"\([^\)]*\)","",s)
r = re.search(r"(?i)(G17|G18|G19)", s_wo_comments)
if r :
plane = r.group(1).lower()
if plane == "g17" : r_scale = scale[0] # plane XY -> scale x
if plane == "g18" : r_scale = scale[0] # plane XZ -> scale x
if plane == "g19" : r_scale = scale[1] # plane YZ -> scale y
# Raise warning if scale factors are not the game for G02 and G03
if plane not in warned:
r = re.search(r"(?i)(G02|G03)", s_wo_comments)
if r :
if plane == "g17" and scale[0]!=scale[1]: self.error("Post-processor: Scale factors for X and Y axis are not the same. G02 and G03 codes will be corrupted.","warning")
if plane == "g18" and scale[0]!=scale[2]: self.error("Post-processor: Scale factors for X and Z axis are not the same. G02 and G03 codes will be corrupted.","warning")
if plane == "g19" and scale[1]!=scale[2]: self.error("Post-processor: Scale factors for Y and Z axis are not the same. G02 and G03 codes will be corrupted.","warning")
warned += [plane]
# Transform
for i in range(len(axis)) :
if move[i] != 0 or scale[i] != 1:
for a in axis[i] :
r = re.search(r"(?i)("+a+r")\s*(-?)\s*(\d*\.?\d*)", s)
if r and r.group(3)!="":
s = re.sub(r"(?i)("+a+r")\s*(-?)\s*(\d*\.?\d*)", r"\1 %f"%(float(r.group(2)+r.group(3))*scale[i]+(move[i] if a not in ["i","j","k"] else 0) ), s)
#scale radius R
if r_scale != 1 :
r = re.search(r"(?i)(r)\s*(-?\s*(\d*\.?\d*))", s)
if r and r.group(3)!="":
try:
s = re.sub(r"(?i)(r)\s*(-?)\s*(\d*\.?\d*)", r"\1 %f"%( float(r.group(2)+r.group(3))*r_scale ), s)
except:
pass
gcode += s + "\n"
self.gcode = gcode
if flip :
self.remapi("'G02'->'G03', 'G03'->'G02'")
def parameterize(self,parameters) :
planes = []
feeds = {}
coords = []
gcode = ""
coords_def = {"x":"x","y":"y","z":"z","i":"x","j":"y","k":"z","a":"a"}
for s in self.gcode.split("\n"):
s_wo_comments = re.sub(r"\([^\)]*\)","",s)
# get Planes
r = re.search(r"(?i)(G17|G18|G19)", s_wo_comments)
if r :
plane = r.group(1).lower()
if plane not in planes :
planes += [plane]
# get Feeds
r = re.search(r"(?i)(F)\s*(-?)\s*(\d*\.?\d*)", s_wo_comments)
if r :
feed = float (r.group(2)+r.group(3))
if feed not in feeds :
feeds[feed] = "#"+str(len(feeds)+20)
#Coordinates
for c in "xyzijka" :
r = re.search(r"(?i)("+c+r")\s*(-?)\s*(\d*\.?\d*)", s_wo_comments)
if r :
c = coords_def[r.group(1).lower()]
if c not in coords :
coords += [c]
# Add offset parametrization
offset = {"x":"#6","y":"#7","z":"#8","a":"#9"}
for c in coords:
gcode += "%s = 0 (%s axis offset)\n" % (offset[c],c.upper())
# Add scale parametrization
if planes == [] : planes = ["g17"]
if len(planes)>1 : # have G02 and G03 in several planes scale_x = scale_y = scale_z required
gcode += "#10 = 1 (Scale factor)\n"
scale = {"x":"#10","i":"#10","y":"#10","j":"#10","z":"#10","k":"#10","r":"#10"}
else :
gcode += "#10 = 1 (%s Scale factor)\n" % ({"g17":"XY","g18":"XZ","g19":"YZ"}[planes[0]])
gcode += "#11 = 1 (%s Scale factor)\n" % ({"g17":"Z","g18":"Y","g19":"X"}[planes[0]])
scale = {"x":"#10","i":"#10","y":"#10","j":"#10","z":"#10","k":"#10","r":"#10"}
if "g17" in planes :
scale["z"] = "#11"
scale["k"] = "#11"
if "g18" in planes :
scale["y"] = "#11"
scale["j"] = "#11"
if "g19" in planes :
scale["x"] = "#11"
scale["i"] = "#11"
# Add a scale
if "a" in coords:
gcode += "#12 = 1 (A axis scale)\n"
scale["a"] = "#12"
# Add feed parametrization
for f in feeds :
gcode += "%s = %f (Feed definition)\n" % (feeds[f],f)
# Parameterize Gcode
for s in self.gcode.split("\n"):
#feed replace :
r = re.search(r"(?i)(F)\s*(-?)\s*(\d*\.?\d*)", s)
if r and len(r.group(3))>0:
s = re.sub(r"(?i)(F)\s*(-?)\s*(\d*\.?\d*)", "F [%s]"%feeds[float(r.group(2)+r.group(3))], s)
#Coords XYZA replace
for c in "xyza" :
r = re.search(r"(?i)(("+c+r")\s*(-?)\s*(\d*\.?\d*))", s)
if r and len(r.group(4))>0:
s = re.sub(r"(?i)("+c+r")\s*((-?)\s*(\d*\.?\d*))", r"\1[\2*%s+%s]"%(scale[c],offset[c]), s)
#Coords IJKR replace
for c in "ijkr" :
r = re.search(r"(?i)(("+c+r")\s*(-?)\s*(\d*\.?\d*))", s)
if r and len(r.group(4))>0:
s = re.sub(r"(?i)("+c+r")\s*((-?)\s*(\d*\.?\d*))", r"\1[\2*%s]"%scale[c], s)
gcode += s + "\n"
self.gcode = gcode
def round_coordinates(self,parameters) :
try:
round_ = int(parameters)
except :
self.error("Bad parameters for round. Round should be an integer! \n(Parameters: '%s')"%(parameters), "error")
gcode = ""
for s in self.gcode.split("\n"):
for a in "xyzijkaf" :
r = re.search(r"(?i)("+a+r")\s*(-?\s*(\d*\.?\d*))", s)
if r :
if r.group(2)!="":
s = re.sub(
r"(?i)("+a+r")\s*(-?)\s*(\d*\.?\d*)",
(r"\1 %0."+str(round_)+"f" if round_>0 else r"\1 %d")%round(float(r.group(2)),round_),
s)
gcode += s + "\n"
self.gcode = gcode
def scale(self, parameters):
parameters = parameters.split(",")
scale = [1.,1.,1.,1.]
try :
for i in range(len(parameters)) :
if float(parameters[i])==0 :
self.error("Bad parameters for scale. Scale should not be 0 at any axis! \n(Parameters: '%s')"%(parameters), "error")
scale[i] = float(parameters[i])
except :
self.error("Bad parameters for scale.\n(Parameters: '%s')"%(parameters), "error")
self.transform([0,0,0,0],scale)
def move(self, parameters):
parameters = parameters.split(",")
move = [0.,0.,0.,0.]
try :
for i in range(len(parameters)) :
move[i] = float(parameters[i])
except :
self.error("Bad parameters for move.\n(Parameters: '%s')"%(parameters), "error")
self.transform(move,[1.,1.,1.,1.])
def flip_axis(self, parameters):
parameters = parameters.lower()
axis = {"x":1.,"y":1.,"z":1.,"a":1.}
for p in parameters:
if p in [","," "," ","\r","'",'"'] : continue
if p not in ["x","y","z","a"] :
self.error("Bad parameters for flip_axis. Parameter should be string consists of 'xyza' \n(Parameters: '%s')"%(parameters), "error")
axis[p] = -axis[p]
self.scale("%f,%f,%f,%f"%(axis["x"],axis["y"],axis["z"],axis["a"]))
################################################################################
### Polygon class
################################################################################
class Polygon:
def __init__(self, polygon=None):
self.polygon = [] if polygon==None else polygon[:]
def move(self, x, y) :
for i in range(len(self.polygon)) :
for j in range(len(self.polygon[i])) :
self.polygon[i][j][0] += x
self.polygon[i][j][1] += y
def bounds(self) :
minx,miny,maxx,maxy = 1e400, 1e400, -1e400, -1e400
for poly in self.polygon :
for p in poly :
if minx > p[0] : minx = p[0]
if miny > p[1] : miny = p[1]
if maxx < p[0] : maxx = p[0]
if maxy < p[1] : maxy = p[1]
return minx*1,miny*1,maxx*1,maxy*1
def width(self):
b = self.bounds()
return b[2]-b[0]
def rotate_(self,sin,cos) :
self.polygon = [
[
[point[0]*cos - point[1]*sin,point[0]*sin + point[1]*cos] for point in subpoly
]
for subpoly in self.polygon
]
def rotate(self, a):
cos, sin = math.cos(a), math.sin(a)
self.rotate_(sin,cos)
def drop_into_direction(self, direction, surface) :
# Polygon is a list of simple polygons
# Surface is a polygon + line y = 0
# Direction is [dx,dy]
if len(self.polygon) == 0 or len(self.polygon[0])==0 : return
if direction[0]**2 + direction[1]**2 <1e-10 : return
direction = normalize(direction)
sin,cos = direction[0], -direction[1]
self.rotate_(-sin,cos)
surface.rotate_(-sin,cos)
self.drop_down(surface, zerro_plane = False)
self.rotate_(sin,cos)
surface.rotate_(sin,cos)
def centroid(self):
centroids = []
sa = 0
for poly in self.polygon:
cx,cy,a = 0,0,0
for i in range(len(poly)):
[x1,y1],[x2,y2] = poly[i-1],poly[i]
cx += (x1+x2)*(x1*y2-x2*y1)
cy += (y1+y2)*(x1*y2-x2*y1)
a += (x1*y2-x2*y1)
a *= 3.
if abs(a)>0 :
cx /= a
cy /= a
sa += abs(a)
centroids += [ [cx,cy,a] ]
if sa == 0 : return [0.,0.]
cx,cy = 0.,0.
for c in centroids :
cx += c[0]*c[2]
cy += c[1]*c[2]
cx /= sa
cy /= sa
return [cx,cy]
def drop_down(self, surface, zerro_plane = True) :
# Polygon is a list of simple polygons
# Surface is a polygon + line y = 0
# Down means min y (0,-1)
if len(self.polygon) == 0 or len(self.polygon[0])==0 : return
# Get surface top point
top = surface.bounds()[3]
if zerro_plane : top = max(0, top)
# Get polygon bottom point
bottom = self.bounds()[1]
self.move(0, top - bottom + 10)
# Now get shortest distance from surface to polygon in positive x=0 direction
# Such distance = min(distance(vertex, edge)...) where edge from surface and
# vertex from polygon and vice versa...
dist = 1e300
for poly in surface.polygon :
for i in range(len(poly)) :
for poly1 in self.polygon :
for i1 in range(len(poly1)) :
st,end = poly[i-1], poly[i]
vertex = poly1[i1]
if st[0]<=vertex[0]<= end[0] or end[0]<=vertex[0]<=st[0] :
if st[0]==end[0] : d = min(vertex[1]-st[1],vertex[1]-end[1])
else : d = vertex[1] - st[1] - (end[1]-st[1])*(vertex[0]-st[0])/(end[0]-st[0])
if dist > d : dist = d
# and vice versa just change the sign because vertex now under the edge
st,end = poly1[i1-1], poly1[i1]
vertex = poly[i]
if st[0]<=vertex[0]<=end[0] or end[0]<=vertex[0]<=st[0] :
if st[0]==end[0] : d = min(- vertex[1]+st[1],-vertex[1]+end[1])
else : d = - vertex[1] + st[1] + (end[1]-st[1])*(vertex[0]-st[0])/(end[0]-st[0])
if dist > d : dist = d
if zerro_plane and dist > 10 + top : dist = 10 + top
#print_(dist, top, bottom)
#self.draw()
self.move(0, -dist)
def draw(self,color="#075",width=.1, group = None) :
csp = [csp_subpath_line_to([],poly+[poly[0]]) for poly in self.polygon]
draw_csp( csp, color=color,width=width, group = group)
def add(self, add) :
if type(add) == type([]) :
self.polygon += add[:]
else :
self.polygon += add.polygon[:]
def point_inside(self,p) :
inside = False
for poly in self.polygon :
for i in range(len(poly)):
st,end = poly[i-1], poly[i]
if p==st or p==end : return True # point is a vertex = point is on the edge
if st[0]>end[0] : st, end = end, st # This will be needed to check that edge if open only at rigth end
c = (p[1]-st[1])*(end[0]-st[0])-(end[1]-st[1])*(p[0]-st[0])
#print_(c)
if st[0]<=p[0]<end[0] :
if c<0 :
inside = not inside
elif c == 0 : return True # point is on the edge
elif st[0]==end[0]==p[0] and (st[1]<=p[1]<=end[1] or end[1]<=p[1]<=st[1]) : # point is on the edge
return True
return inside
def hull(self) :
# Add vertices at all self intersection points.
hull = []
for i1 in range(len(self.polygon)):
poly1 = self.polygon[i1]
poly_ = []
for j1 in range(len(poly1)):
s, e = poly1[j1-1],poly1[j1]
poly_ += [s]
# Check self intersections
for j2 in range(j1+1,len(poly1)):
s1, e1 = poly1[j2-1],poly1[j2]
int_ = line_line_intersection_points(s,e,s1,e1)
for p in int_ :
if point_to_point_d2(p,s)>0.000001 and point_to_point_d2(p,e)>0.000001 :
poly_ += [p]
# Check self intersections with other polys
for i2 in range(len(self.polygon)):
if i1==i2 : continue
poly2 = self.polygon[i2]
for j2 in range(len(poly2)):
s1, e1 = poly2[j2-1],poly2[j2]
int_ = line_line_intersection_points(s,e,s1,e1)
for p in int_ :
if point_to_point_d2(p,s)>0.000001 and point_to_point_d2(p,e)>0.000001 :
poly_ += [p]
hull += [poly_]
# Create the dictionary containing all edges in both directions
edges = {}
for poly in self.polygon :
for i in range(len(poly)):
s,e = tuple(poly[i-1]), tuple(poly[i])
if (point_to_point_d2(e,s)<0.000001) : continue
break_s, break_e = False, False
for p in edges :
if point_to_point_d2(p,s)<0.000001 :
break_s = True
s = p
if point_to_point_d2(p,e)<0.000001 :
break_e = True
e = p
if break_s and break_e : break
l = point_to_point_d(s,e)
if not break_s and not break_e :
edges[s] = [ [s,e,l] ]
edges[e] = [ [e,s,l] ]
#draw_pointer(s+e,"red","line")
#draw_pointer(s+e,"red","line")
else :
if e in edges :
for edge in edges[e] :
if point_to_point_d2(edge[1],s)<0.000001 :
break
if point_to_point_d2(edge[1],s)>0.000001 :
edges[e] += [ [e,s,l] ]
#draw_pointer(s+e,"red","line")
else :
edges[e] = [ [e,s,l] ]
#draw_pointer(s+e,"green","line")
if s in edges :
for edge in edges[s] :
if point_to_point_d2(edge[1],e)<0.000001 :
break
if point_to_point_d2(edge[1],e)>0.000001 :
edges[s] += [ [s,e, l] ]
#draw_pointer(s+e,"red","line")
else :
edges[s] = [ [s,e,l] ]
#draw_pointer(s+e,"green","line")
def angle_quadrant(sin,cos):
# quadrants are (0,pi/2], (pi/2,pi], (pi,3*pi/2], (3*pi/2, 2*pi], i.e. 0 is in the 4-th quadrant
if sin>0 and cos>=0 : return 1
if sin>=0 and cos<0 : return 2
if sin<0 and cos<=0 : return 3
if sin<=0 and cos>0 : return 4
def angle_is_less(sin,cos,sin1,cos1):
# 0 = 2*pi is the largest angle
if [sin1, cos1] == [0,1] : return True
if [sin, cos] == [0,1] : return False
if angle_quadrant(sin,cos)>angle_quadrant(sin1,cos1) :
return False
if angle_quadrant(sin,cos)<angle_quadrant(sin1,cos1) :
return True
if sin>=0 and cos>0 : return sin<sin1
if sin>0 and cos<=0 : return sin>sin1
if sin<=0 and cos<0 : return sin>sin1
if sin<0 and cos>=0 : return sin<sin1
def get_closes_edge_by_angle(edges, last):
# Last edge is normalized vector of the last edge.
min_angle = [0,1]
next = last
last_edge = [(last[0][0]-last[1][0])/last[2], (last[0][1]-last[1][1])/last[2]]
for p in edges:
#draw_pointer(list(p[0])+[p[0][0]+last_edge[0]*40,p[0][1]+last_edge[1]*40], "Red", "line", width=1)
#print_("len(edges)=",len(edges))
cur = [(p[1][0]-p[0][0])/p[2],(p[1][1]-p[0][1])/p[2]]
cos, sin = dot(cur,last_edge), cross(cur,last_edge)
#draw_pointer(list(p[0])+[p[0][0]+cur[0]*40,p[0][1]+cur[1]*40], "Orange", "line", width=1, comment = [sin,cos])
#print_("cos, sin=",cos,sin)
#print_("min_angle_before=",min_angle)
if angle_is_less(sin,cos,min_angle[0],min_angle[1]) :
min_angle = [sin,cos]
next = p
#print_("min_angle=",min_angle)
return next
# Join edges together into new polygon cutting the vertexes inside new polygon
self.polygon = []
len_edges = sum([len(edges[p]) for p in edges])
loops = 0
while len(edges)>0 :
poly = []
if loops > len_edges : raise ValueError, "Hull error"
loops+=1
# Find left most vertex.
start = (1e100,1)
for edge in edges :
start = min(start, min(edges[edge]))
last = [(start[0][0]-1,start[0][1]),start[0],1]
first_run = True
loops1 = 0
while (last[1]!=start[0] or first_run) :
first_run = False
if loops1 > len_edges : raise ValueError, "Hull error"
loops1 += 1
next = get_closes_edge_by_angle(edges[last[1]],last)
#draw_pointer(next[0]+next[1],"Green","line", comment=i, width= 1)
#print_(next[0],"-",next[1])
last = next
poly += [ list(last[0]) ]
self.polygon += [ poly ]
# Remove all edges that are intersects new poly (any vertex inside new poly)
poly_ = Polygon([poly])
for p in edges.keys()[:] :
if poly_.point_inside(list(p)) : del edges[p]
self.draw(color="Green", width=1)
class Arangement_Genetic:
# gene = [fittness, order, rotation, xposition]
# spieces = [gene]*shapes count
# population = [spieces]
def __init__(self, polygons, material_width):
self.population = []
self.genes_count = len(polygons)
self.polygons = polygons
self.width = material_width
self.mutation_factor = 0.1
self.order_mutate_factor = 1.
self.move_mutate_factor = 1.
def add_random_species(self,count):
for i in range(count):
specimen = []
order = range(self.genes_count)
random.shuffle(order)
for j in order:
specimen += [ [j, random.random(), random.random()] ]
self.population += [ [None,specimen] ]
def species_distance2(self,sp1,sp2) :
# retun distance, each component is normalized
s = 0
for j in range(self.genes_count) :
s += ((sp1[j][0]-sp2[j][0])/self.genes_count)**2 + (( sp1[j][1]-sp2[j][1]))**2 + ((sp1[j][2]-sp2[j][2]))**2
return s
def similarity(self,sp1,top) :
# Define similarity as a simple distance between two points in len(gene)*len(spiece) -th dimentions
# for sp2 in top_spieces sum(|sp1-sp2|)/top_count
sim = 0
for sp2 in top :
sim += math.sqrt(species_distance2(sp1,sp2[1]))
return sim/len(top)
def leave_top_species(self,count):
self.population.sort()
res = [ copy.deepcopy(self.population[0]) ]
del self.population[0]
for i in range(count-1) :
t = []
for j in range(20) :
i1 = random.randint(0,len(self.population)-1)
t += [ [self.population[i1][0],i1] ]
t.sort()
res += [ copy.deepcopy(self.population[t[0][1]]) ]
del self.population[t[0][1]]
self.population = res
#del self.population[0]
#for c in range(count-1) :
# rank = []
# for i in range(len(self.population)) :
# sim = self.similarity(self.population[i][1],res)
# rank += [ [self.population[i][0] / sim if sim>0 else 1e100,i] ]
# rank.sort()
# res += [ copy.deepcopy(self.population[rank[0][1]]) ]
# print_(rank[0],self.population[rank[0][1]][0])
# print_(res[-1])
# del self.population[rank[0][1]]
self.population = res
def populate_species(self,count, parent_count):
self.population.sort()
self.inc = 0
for c in range(count):
parent1 = random.randint(0,parent_count-1)
parent2 = random.randint(0,parent_count-1)
if parent1==parent2 : parent2 = (parent2+1) % parent_count
parent1, parent2 = self.population[parent1][1], self.population[parent2][1]
i1,i2 = 0, 0
genes_order = []
specimen = [ [0,0.,0.] for i in range(self.genes_count) ]
self.incest_mutation_multiplyer = 1.
self.incest_mutation_count_multiplyer = 1.
if self.species_distance2(parent1, parent2) <= .01/self.genes_count :
# OMG it's a incest :O!!!
# Damn you bastards!
self.inc +=1
self.incest_mutation_multiplyer = 2.
self.incest_mutation_count_multiplyer = 2.
else :
pass
# if random.random()<.01 : print_(self.species_distance2(parent1, parent2))
start_gene = random.randint(0,self.genes_count)
end_gene = (max(1,random.randint(0,self.genes_count),int(self.genes_count/4))+start_gene) % self.genes_count
if end_gene<start_gene :
end_gene, start_gene = start_gene, end_gene
parent1, parent2 = parent2, parent1
for i in range(start_gene,end_gene) :
#rotation_mutate_param = random.random()/100
#xposition_mutate_param = random.random()/100
tr = 1. #- rotation_mutate_param
tp = 1. #- xposition_mutate_param
specimen[i] = [parent1[i][0], parent1[i][1]*tr+parent2[i][1]*(1-tr),parent1[i][2]*tp+parent2[i][2]*(1-tp)]
genes_order += [ parent1[i][0] ]
for i in range(0,start_gene)+range(end_gene,self.genes_count) :
tr = 0. #rotation_mutate_param
tp = 0. #xposition_mutate_param
j = i
while parent2[j][0] in genes_order :
j = (j+1)%self.genes_count
specimen[i] = [parent2[j][0], parent1[i][1]*tr+parent2[i][1]*(1-tr),parent1[i][2]*tp+parent2[i][2]*(1-tp)]
genes_order += [ parent2[j][0] ]
for i in range(random.randint(self.mutation_genes_count[0],self.mutation_genes_count[0]*self.incest_mutation_count_multiplyer )) :
if random.random() < self.order_mutate_factor * self.incest_mutation_multiplyer :
i1,i2 = random.randint(0,self.genes_count-1),random.randint(0,self.genes_count-1)
specimen[i1][0], specimen[i2][0] = specimen[i2][0], specimen[i1][0]
if random.random() < self.move_mutation_factor * self.incest_mutation_multiplyer:
i1 = random.randint(0,self.genes_count-1)
specimen[i1][1] = (specimen[i1][1]+random.random()*math.pi2*self.move_mutation_multiplier)%1.
specimen[i1][2] = (specimen[i1][2]+random.random()*self.move_mutation_multiplier)%1.
self.population += [ [None,specimen] ]
def test_spiece_drop_down(self,spiece) :
surface = Polygon()
for p in spiece :
time_ = time.time()
poly = Polygon(copy.deepcopy(self.polygons[p[0]].polygon))
poly.rotate(p[1]*math.pi2)
w = poly.width()
left = poly.bounds()[0]
poly.move( -left + (self.width-w)*p[2],0)
poly.drop_down(surface)
surface.add(poly)
return surface
def test(self,test_function):
time_ = time.time()
for i in range(len(self.population)) :
if self.population[i][0] == None :
surface = test_function(self.population[i][1])
b = surface.bounds()
self.population[i][0] = (b[3]-b[1])*(b[2]-b[0])
self.population.sort()
def test_spiece_centroid(self,spiece) :
poly = Polygon( self.polygons[spiece[0][0]].polygon[:])
poly.rotate(spiece[0][1]*math.pi2)
surface = Polygon(poly.polygon)
for p in spiece[1:] :
poly = Polygon(self.polygons[p[0]].polygon[:])
c = surface.centroid()
surface.move(-c[0],-c[1])
c1 = poly.centroid()
poly.move(-c1[0],-c1[1])
poly.rotate(p[1]*math.pi2+p[2]*math.pi2)
surface.rotate(p[2]*math.pi2)
poly.drop_down(surface)
surface.add(poly)
surface.rotate(-p[2]*math.pi2)
return surface
def test_inline(self) :
###
### Fast test function using weave's from scipy inline function
###
try :
converters is None
except :
try:
from scipy import weave
from scipy.weave import converters
except:
options.self.error("For this function Scipy is needed. See http://www.cnc-club.ru/gcodetools for details.","error")
# Prepare vars
poly_, subpoly_, points_ = [], [], []
for poly in self.polygons :
p = poly.polygon
poly_ += [len(subpoly_), len(subpoly_)+len(p)*2]
for subpoly in p :
subpoly_ += [len(points_), len(points_)+len(subpoly)*2+2]
for point in subpoly :
points_ += point
points_ += subpoly[0] # Close subpolygon
test_ = []
population_ = []
for spiece in self.population:
test_.append( spiece[0] if spiece[0] != None else -1)
for sp in spiece[1]:
population_ += sp
lp_, ls_, l_, lt_ = len(poly_), len(subpoly_), len(points_), len(test_)
f = open('inline_test.c', 'r')
code = f.read()
f.close()
f = open('inline_test_functions.c', 'r')
functions = f.read()
f.close()
stdout_ = sys.stdout
s = ''
sys.stdout = s
test = weave.inline(
code,
['points_','subpoly_','poly_', 'lp_', 'ls_', 'l_', 'lt_','test_', 'population_'],
compiler='gcc',
support_code = functions,
)
if s!='' : options.self.error(s,"warning")
sys.stdout = stdout_
for i in range(len(test_)):
self.population[i][0] = test_[i]
#surface.draw()
################################################################################
###
### Gcodetools class
###
################################################################################
class Gcodetools(inkex.Effect):
def export_gcode(self,gcode, no_headers = False) :
if self.options.postprocessor != "" or self.options.postprocessor_custom != "" :
postprocessor = Postprocessor(self.error)
postprocessor.gcode = gcode
if self.options.postprocessor != "" :
postprocessor.process(self.options.postprocessor)
if self.options.postprocessor_custom != "" :
postprocessor.process(self.options.postprocessor_custom)
if not no_headers :
postprocessor.gcode = self.header + postprocessor.gcode + self.footer
f = open(self.options.directory+self.options.file, "w")
f.write(postprocessor.gcode)
f.close()
################################################################################
### In/out paths:
### TODO move it to the bottom
################################################################################
def plasma_prepare_path(self) :
def add_arc(sp1,sp2,end = False,l=10.,r=10.) :
if not end :
n = csp_normalized_normal(sp1,sp2,0.)
return csp_reverse([arc_from_s_r_n_l(sp1[1],r,n,-l)])[0]
else:
n = csp_normalized_normal(sp1,sp2,1.)
return arc_from_s_r_n_l(sp2[1],r,n,l)
def add_normal(sp1,sp2,end = False,l=10.,r=10.) :
# r is needed only for be compatible with add_arc
if not end :
n = csp_normalized_normal(sp1,sp2,0.)
p = [n[0]*l+sp1[1][0],n[1]*l+sp1[1][1]]
return csp_subpath_line_to([], [p,sp1[1]])
else:
n = csp_normalized_normal(sp1,sp2,1.)
p = [n[0]*l+sp2[1][0],n[1]*l+sp2[1][1]]
return csp_subpath_line_to([], [sp2[1],p])
def add_tangent(sp1,sp2,end = False,l=10.,r=10.) :
# r is needed only for be compatible with add_arc
if not end :
n = csp_normalized_slope(sp1,sp2,0.)
p = [-n[0]*l+sp1[1][0],-n[1]*l+sp1[1][1]]
return csp_subpath_line_to([], [p,sp1[1]])
else:
n = csp_normalized_slope(sp1,sp2,1.)
p = [n[0]*l+sp2[1][0],n[1]*l+sp2[1][1]]
return csp_subpath_line_to([], [sp2[1],p])
if not self.options.in_out_path and not self.options.plasma_prepare_corners and self.options.in_out_path_do_not_add_reference_point:
self.error("Warning! Extenstion is not said to do anything! Enable one of Create in-out paths or Prepare corners checkboxes or disable Do not add in-out referense point!")
return
# Add in-out-reference point if there is no one yet.
if ( (len(self.in_out_reference_points)==0 and self.options.in_out_path
or not self.options.in_out_path and not self.options.plasma_prepare_corners )
and not self.options.in_out_path_do_not_add_reference_point) :
self.options.orientation_points_count = "in-out reference point"
self.orientation()
if self.options.in_out_path or self.options.plasma_prepare_corners:
self.set_markers()
add_func = {"Round":add_arc, "Perpendicular": add_normal, "Tangent": add_tangent}[self.options.in_out_path_type]
if self.options.in_out_path_type == "Round" and self.options.in_out_path_len > self.options.in_out_path_radius*3/2*math.pi :
self.error("In-out len is to big for in-out radius will cropp it to be r*3/2*pi!", "warning")
if self.selected_paths == {} and self.options.auto_select_paths:
self.selected_paths = self.paths
self.error(_("No paths are selected! Trying to work on all available paths."),"warning")
if self.selected_paths == {}:
self.error(_("Nothing is selected. Please select something."),"warning")
a = self.options.plasma_prepare_corners_tolerance
corner_tolerance = cross([1.,0.], [math.cos(a),math.sin(a)])
for layer in self.layers :
if layer in self.selected_paths :
max_dist = self.transform_scalar(self.options.in_out_path_point_max_dist, layer, reverse=True)
l = self.transform_scalar(self.options.in_out_path_len, layer, reverse=True)
plasma_l = self.transform_scalar(self.options.plasma_prepare_corners_distance, layer, reverse=True)
r = self.transform_scalar(self.options.in_out_path_radius, layer, reverse=True)
l = min(l,r*3/2*math.pi)
for path in self.selected_paths[layer]:
csp = self.apply_transforms( path, cubicsuperpath.parsePath(path.get("d")) )
csp = csp_remove_zerro_segments(csp)
res = []
for subpath in csp :
# Find closes point to in-out reference point
# If subpath is open skip this step
if self.options.in_out_path :
# split and reverse path for further add in-out points
if point_to_point_d2(subpath[0][1], subpath[-1][1]) < 1.e-10 :
d = [1e100,1,1,1.]
for p in self.in_out_reference_points :
d1 = csp_to_point_distance([subpath], p, dist_bounds = [0,max_dist], tolerance=.01)
if d1[0] < d[0] :
d = d1[:]
p_ = p
if d[0] < max_dist**2 :
# Lets find is there any angles near this point to put in-out path in
# the angle if it's possible
# remove last node to make iterations easier
subpath[0][0] = subpath[-1][0]
del subpath[-1]
max_cross = [-1e100, None]
for j in range(len(subpath)) :
sp1,sp2,sp3 = subpath[j-2],subpath[j-1],subpath[j]
if point_to_point_d2(sp2[1],p_)<max_dist**2:
s1,s2 = csp_normalized_slope(sp1,sp2,1.), csp_normalized_slope(sp2,sp3,0.)
max_cross = max(max_cross,[cross(s1,s2),j-1])
# return back last point
subpath.append(subpath[0])
if max_cross[1] !=None and max_cross[0]>corner_tolerance :
# there's an angle near the point
j = max_cross[1]
if j<0 : j -= 1
if j!=0 :
subpath = csp_concat_subpaths(subpath[j:],subpath[:j+1])
else :
# have to cut path's segment
d,i,j,t = d
sp1,sp2,sp3 = csp_split(subpath[j-1],subpath[j],t)
subpath = csp_concat_subpaths([sp2,sp3], subpath[j:], subpath[:j], [sp1,sp2])
if self.options.plasma_prepare_corners :
# prepare corners
# find corners and add some nodes
# corner at path's start/end is ignored
res_ = [subpath[0]]
for sp2, sp3 in zip(subpath[1:],subpath[2:]) :
sp1 = res_[-1]
s1,s2 = csp_normalized_slope(sp1,sp2,1.), csp_normalized_slope(sp2,sp3,0.)
if cross(s1,s2) > corner_tolerance :
# got a corner to process
S1,S2 = P(s1),P(s2)
N = (S1-S2).unit()*plasma_l
SP2= P(sp2[1])
P1 = (SP2 + N)
res_ += [
[sp2[0],sp2[1], (SP2+S1*plasma_l).to_list() ],
[ (P1-N.ccw()/2 ).to_list(), P1.to_list(), (P1+N.ccw()/2).to_list()],
[(SP2-S2*plasma_l).to_list(), sp2[1],sp2[2]]
]
else:
res_ += [sp2]
res_ += [sp3]
subpath = res_
if self.options.in_out_path :
# finally add let's add in-out paths...
subpath = csp_concat_subpaths(
add_func(subpath[0],subpath[1],False,l,r),
subpath,
add_func(subpath[-2],subpath[-1],True,l,r)
)
res += [ subpath ]
if self.options.in_out_path_replace_original_path :
path.set("d", cubicsuperpath.formatPath( self.apply_transforms(path,res,True) ))
else:
draw_csp(res, width=1, style=styles["in_out_path_style"] )
################################################################################
### Arrangement: arranges paths by givven params
### TODO move it to the bottom
################################################################################
def arrangement(self) :
paths = self.selected_paths
surface = Polygon()
polygons = []
time_ = time.time()
print_("Arrangement start at %s"%(time_))
original_paths = []
for layer in self.layers :
if layer in paths :
for path in paths[layer] :
csp = cubicsuperpath.parsePath(path.get("d"))
polygon = Polygon()
for subpath in csp :
for sp1, sp2 in zip(subpath,subpath[1:]) :
polygon.add([csp_segment_convex_hull(sp1,sp2)])
#print_("Redused edges count from", sum([len(poly) for poly in polygon.polygon ]) )
polygon.hull()
original_paths += [path]
polygons += [polygon]
print_("Paths hull computed in %s sec."%(time.time()-time_))
print_("Got %s polygons having average %s edges each."% ( len(polygons), float(sum([ sum([len(poly) for poly in polygon.polygon]) for polygon in polygons ])) / len(polygons) ) )
time_ = time.time()
# material_width = self.options.arrangement_material_width
# population = Arangement_Genetic(polygons, material_width)
# population.add_random_species(1)
# population.test_population_centroid()
## return
material_width = self.options.arrangement_material_width
population = Arangement_Genetic(polygons, material_width)
print_("Genetic algorithm start at %s"%(time_))
start_time = time.time()
time_ = time.time()
population.add_random_species(50)
#population.test(population.test_spiece_centroid)
print_("Initial population done in %s"%(time.time()-time_))
time_ = time.time()
pop = copy.deepcopy(population)
population_count = self.options.arrangement_population_count
last_champ = -1
champions_count = 0
for i in range(population_count):
population.leave_top_species(20)
population.move_mutation_multiplier = random.random()/2
population.order_mutation_factor = .2
population.move_mutation_factor = 1.
population.mutation_genes_count = [1,2]
population.populate_species(250, 20)
print_("Populate done at %s"%(time.time()-time_))
"""
randomize = i%100 < 40
if i%100 < 40 :
population.add_random_species(250)
if 40<= i%100 < 100 :
population.mutation_genes_count = [1,max(2,int(population.genes_count/4))] #[1,max(2,int(population.genes_count/2))] if 40<=i%100<60 else [1,max(2,int(population.genes_count/10))]
population.move_mutation_multiplier = 1. if 40<=i%100<80 else .1
population.move_mutation_factor = (-(i%100)/30+10/3) if 50<=i%100<100 else .5
population.order_mutation_factor = 1./(i%100-79) if 80<=i%100<100 else 1.
population.populate_species(250, 10)
"""
if self.options.arrangement_inline_test :
population.test_inline()
else:
population.test(population.test_spiece_centroid)
print_("Test done at %s"%(time.time()-time_))
draw_new_champ = False
print_()
if population.population[0][0]!= last_champ :
draw_new_champ = True
improve = last_champ-population.population[0][0]
last_champ = population.population[0][0]*1
print_("Cicle %s done in %s"%(i,time.time()-time_))
time_ = time.time()
print_("%s incests been found"%population.inc)
print_()
if i == 0 or i == population_count-1 or draw_new_champ :
colors = ["blue"]
surface = population.test_spiece_centroid(population.population[0][1])
b = surface.bounds()
x,y = 400* (champions_count%10), 700*int(champions_count/10)
surface.move(x-b[0],y-b[1])
surface.draw(width=2, color=colors[0])
draw_text("Step = %s\nSquare = %f\nSquare improvement = %f\nTime from start = %f"%(i,(b[2]-b[0])*(b[3]-b[1]),improve,time.time()-start_time),x,y-50)
champions_count += 1
"""
spiece = population.population[0][1]
poly = Polygon(copy.deepcopy(population.polygons[spiece[0][0]].polygon))
poly.rotate(spiece[0][2]*math.pi2)
surface = Polygon(poly.polygon)
poly.draw(width = 2, color= "Violet")
for p in spiece[1:] :
poly = Polygon(copy.deepcopy(population.polygons[p[0]].polygon))
poly.rotate(p[2]*math.pi2)
direction = [math.cos(p[1]*math.pi2), -math.sin(p[1]*math.pi2)]
normalize(direction)
c = surface.centroid()
c1 = poly.centroid()
poly.move(c[0]-c1[0]-direction[0]*400,c[1]-c1[1]-direction[1]*400)
c = surface.centroid()
c1 = poly.centroid()
poly.draw(width = 5, color= "Violet")
draw_pointer(c+c1,"Green","line")
direction = normalize(direction)
sin,cos = direction[0], direction[1]
poly.rotate_(-sin,cos)
surface.rotate_(-sin,cos)
# poly.draw(color = "Violet",width=4)
surface.draw(color = "Orange",width=4)
poly.rotate_(sin,cos)
surface.rotate_(sin,cos)
poly.drop_into_direction(direction,surface)
surface.add(poly)
"""
# Now we'll need apply transforms to original paths
def __init__(self):
inkex.Effect.__init__(self)
self.OptionParser.add_option("-d", "--directory", action="store", type="string", dest="directory", default="/home/", help="Directory for gcode file")
self.OptionParser.add_option("-f", "--filename", action="store", type="string", dest="file", default="-1.0", help="File name")
self.OptionParser.add_option("", "--add-numeric-suffix-to-filename", action="store", type="inkbool", dest="add_numeric_suffix_to_filename", default=True,help="Add numeric suffix to filename")
self.OptionParser.add_option("", "--Zscale", action="store", type="float", dest="Zscale", default="1.0", help="Scale factor Z")
self.OptionParser.add_option("", "--Zoffset", action="store", type="float", dest="Zoffset", default="0.0", help="Offset along Z")
self.OptionParser.add_option("-s", "--Zsafe", action="store", type="float", dest="Zsafe", default="0.5", help="Z above all obstacles")
self.OptionParser.add_option("-z", "--Zsurface", action="store", type="float", dest="Zsurface", default="0.0", help="Z of the surface")
self.OptionParser.add_option("-c", "--Zdepth", action="store", type="float", dest="Zdepth", default="-0.125", help="Z depth of cut")
self.OptionParser.add_option("", "--Zstep", action="store", type="float", dest="Zstep", default="-0.125", help="Z step of cutting")
self.OptionParser.add_option("-p", "--feed", action="store", type="float", dest="feed", default="4.0", help="Feed rate in unit/min")
self.OptionParser.add_option("", "--biarc-tolerance", action="store", type="float", dest="biarc_tolerance", default="1", help="Tolerance used when calculating biarc interpolation.")
self.OptionParser.add_option("", "--biarc-max-split-depth", action="store", type="int", dest="biarc_max_split_depth", default="4", help="Defines maximum depth of splitting while approximating using biarcs.")
self.OptionParser.add_option("", "--path-to-gcode-order", action="store", type="string", dest="path_to_gcode_order", default="path by path", help="Defines cutting order path by path or layer by layer.")
self.OptionParser.add_option("", "--path-to-gcode-depth-function",action="store", type="string", dest="path_to_gcode_depth_function", default="zd", help="Path to gcode depth function.")
self.OptionParser.add_option("", "--path-to-gcode-sort-paths", action="store", type="inkbool", dest="path_to_gcode_sort_paths", default=True, help="Sort paths to reduse rapid distance.")
self.OptionParser.add_option("", "--comment-gcode", action="store", type="string", dest="comment_gcode", default="", help="Comment Gcode")
self.OptionParser.add_option("", "--comment-gcode-from-properties",action="store", type="inkbool", dest="comment_gcode_from_properties", default=False,help="Get additional comments from Object Properties")
self.OptionParser.add_option("", "--tool-diameter", action="store", type="float", dest="tool_diameter", default="3", help="Tool diameter used for area cutting")
self.OptionParser.add_option("", "--max-area-curves", action="store", type="int", dest="max_area_curves", default="100", help="Maximum area curves for each area")
self.OptionParser.add_option("", "--area-inkscape-radius", action="store", type="float", dest="area_inkscape_radius", default="0", help="Area curves overlaping (depends on tool diameter [0,0.9])")
self.OptionParser.add_option("", "--area-tool-overlap", action="store", type="float", dest="area_tool_overlap", default="-10", help="Radius for preparing curves using inkscape")
self.OptionParser.add_option("", "--unit", action="store", type="string", dest="unit", default="G21 (All units in mm)", help="Units")
self.OptionParser.add_option("", "--active-tab", action="store", type="string", dest="active_tab", default="", help="Defines which tab is active")
self.OptionParser.add_option("", "--area-fill-angle", action="store", type="float", dest="area_fill_angle", default="0", help="Fill area with lines heading this angle")
self.OptionParser.add_option("", "--area-fill-shift", action="store", type="float", dest="area_fill_shift", default="0", help="Shift the lines by tool d * shift")
self.OptionParser.add_option("", "--area-fill-method", action="store", type="string", dest="area_fill_method", default="zig-zag", help="Filling method either zig-zag or spiral")
self.OptionParser.add_option("", "--area-find-artefacts-diameter",action="store", type="float", dest="area_find_artefacts_diameter", default="1", help="Artefacts seeking radius")
self.OptionParser.add_option("", "--area-find-artefacts-action", action="store", type="string", dest="area_find_artefacts_action", default="mark with an arrow", help="Artefacts action type")
self.OptionParser.add_option("", "--auto_select_paths", action="store", type="inkbool", dest="auto_select_paths", default=True, help="Select all paths if nothing is selected.")
self.OptionParser.add_option("", "--loft-distances", action="store", type="string", dest="loft_distances", default="10", help="Distances between paths.")
self.OptionParser.add_option("", "--loft-direction", action="store", type="string", dest="loft_direction", default="crosswise", help="Direction of loft's interpolation.")
self.OptionParser.add_option("", "--loft-interpolation-degree", action="store", type="float", dest="loft_interpolation_degree", default="2", help="Which interpolation use to loft the paths smooth interpolation or staright.")
self.OptionParser.add_option("", "--min-arc-radius", action="store", type="float", dest="min_arc_radius", default=".1", help="All arc having radius less than minimum will be considered as straight line")
self.OptionParser.add_option("", "--engraving-sharp-angle-tollerance",action="store", type="float", dest="engraving_sharp_angle_tollerance", default="150", help="All angles thar are less than engraving-sharp-angle-tollerance will be thought sharp")
self.OptionParser.add_option("", "--engraving-max-dist", action="store", type="float", dest="engraving_max_dist", default="10", help="Distanse from original path where engraving is not needed (usualy it's cutting tool diameter)")
self.OptionParser.add_option("", "--engraving-newton-iterations", action="store", type="int", dest="engraving_newton_iterations", default="4", help="Number of sample points used to calculate distance")
self.OptionParser.add_option("", "--engraving-draw-calculation-paths",action="store", type="inkbool", dest="engraving_draw_calculation_paths", default=False, help="Draw additional graphics to debug engraving path")
self.OptionParser.add_option("", "--engraving-cutter-shape-function",action="store", type="string", dest="engraving_cutter_shape_function", default="w", help="Cutter shape function z(w). Ex. cone: w. ")
self.OptionParser.add_option("", "--lathe-width", action="store", type="float", dest="lathe_width", default=10., help="Lathe width")
self.OptionParser.add_option("", "--lathe-fine-cut-width", action="store", type="float", dest="lathe_fine_cut_width", default=1., help="Fine cut width")
self.OptionParser.add_option("", "--lathe-fine-cut-count", action="store", type="int", dest="lathe_fine_cut_count", default=1., help="Fine cut count")
self.OptionParser.add_option("", "--lathe-create-fine-cut-using", action="store", type="string", dest="lathe_create_fine_cut_using", default="Move path", help="Create fine cut using")
self.OptionParser.add_option("", "--lathe-x-axis-remap", action="store", type="string", dest="lathe_x_axis_remap", default="X", help="Lathe X axis remap")
self.OptionParser.add_option("", "--lathe-z-axis-remap", action="store", type="string", dest="lathe_z_axis_remap", default="Z", help="Lathe Z axis remap")
self.OptionParser.add_option("", "--lathe-rectangular-cutter-width",action="store", type="float", dest="lathe_rectangular_cutter_width", default="4", help="Rectangular cutter width")
self.OptionParser.add_option("", "--create-log", action="store", type="inkbool", dest="log_create_log", default=False, help="Create log files")
self.OptionParser.add_option("", "--log-filename", action="store", type="string", dest="log_filename", default='', help="Create log files")
self.OptionParser.add_option("", "--orientation-points-count", action="store", type="string", dest="orientation_points_count", default="2", help="Orientation points count")
self.OptionParser.add_option("", "--tools-library-type", action="store", type="string", dest="tools_library_type", default='cylinder cutter', help="Create tools definition")
self.OptionParser.add_option("", "--dxfpoints-action", action="store", type="string", dest="dxfpoints_action", default='replace', help="dxfpoint sign toggle")
self.OptionParser.add_option("", "--help-language", action="store", type="string", dest="help_language", default='http://www.cnc-club.ru/forum/viewtopic.php?f=33&t=35', help="Open help page in webbrowser.")
self.OptionParser.add_option("", "--offset-radius", action="store", type="float", dest="offset_radius", default=10., help="Offset radius")
self.OptionParser.add_option("", "--offset-step", action="store", type="float", dest="offset_step", default=10., help="Offset step")
self.OptionParser.add_option("", "--offset-draw-clippend-path", action="store", type="inkbool", dest="offset_draw_clippend_path", default=False, help="Draw clipped path")
self.OptionParser.add_option("", "--offset-just-get-distance", action="store", type="inkbool", dest="offset_just_get_distance", default=False, help="Don't do offset just get distance")
self.OptionParser.add_option("", "--arrangement-material-width", action="store", type="float", dest="arrangement_material_width", default=500, help="Materials width for arrangement")
self.OptionParser.add_option("", "--arrangement-population-count",action="store", type="int", dest="arrangement_population_count", default=100, help="Genetic algorithm populations count")
self.OptionParser.add_option("", "--arrangement-inline-test", action="store", type="inkbool", dest="arrangement_inline_test", default=False, help="Use C-inline test (some additional packets will be needed)")
self.OptionParser.add_option("", "--postprocessor", action="store", type="string", dest="postprocessor", default='', help="Postprocessor command.")
self.OptionParser.add_option("", "--postprocessor-custom", action="store", type="string", dest="postprocessor_custom", default='', help="Postprocessor custom command.")
self.OptionParser.add_option("", "--graffiti-max-seg-length", action="store", type="float", dest="graffiti_max_seg_length", default=1., help="Graffiti maximum segment length.")
self.OptionParser.add_option("", "--graffiti-min-radius", action="store", type="float", dest="graffiti_min_radius", default=10., help="Graffiti minimal connector's radius.")
self.OptionParser.add_option("", "--graffiti-start-pos", action="store", type="string", dest="graffiti_start_pos", default="(0;0)", help="Graffiti Start position (x;y).")
self.OptionParser.add_option("", "--graffiti-create-linearization-preview", action="store", type="inkbool", dest="graffiti_create_linearization_preview", default=True, help="Graffiti create linearization preview.")
self.OptionParser.add_option("", "--graffiti-create-preview", action="store", type="inkbool", dest="graffiti_create_preview", default=True, help="Graffiti create preview.")
self.OptionParser.add_option("", "--graffiti-preview-size", action="store", type="int", dest="graffiti_preview_size", default=800, help="Graffiti preview's size.")
self.OptionParser.add_option("", "--graffiti-preview-emmit", action="store", type="int", dest="graffiti_preview_emmit", default=800, help="Preview's paint emmit (pts/s).")
self.OptionParser.add_option("", "--in-out-path", action="store", type="inkbool", dest="in_out_path", default=True, help="Create in-out paths")
self.OptionParser.add_option("", "--in-out-path-do-not-add-reference-point", action="store", type="inkbool", dest="in_out_path_do_not_add_reference_point", default=False, help="Just add reference in-out point")
self.OptionParser.add_option("", "--in-out-path-point-max-dist", action="store", type="float", dest="in_out_path_point_max_dist", default=10., help="In-out path max distance to reference point")
self.OptionParser.add_option("", "--in-out-path-type", action="store", type="string", dest="in_out_path_type", default="Round", help="In-out path type")
self.OptionParser.add_option("", "--in-out-path-len", action="store", type="float", dest="in_out_path_len", default=10., help="In-out path length")
self.OptionParser.add_option("", "--in-out-path-replace-original-path",action="store", type="inkbool", dest="in_out_path_replace_original_path", default=False, help="Replace original path")
self.OptionParser.add_option("", "--in-out-path-radius", action="store", type="float", dest="in_out_path_radius", default=10., help="In-out path radius for round path")
self.OptionParser.add_option("", "--plasma-prepare-corners", action="store", type="inkbool", dest="plasma_prepare_corners", default=True, help="Prepare corners")
self.OptionParser.add_option("", "--plasma-prepare-corners-distance", action="store", type="float", dest="plasma_prepare_corners_distance", default=10.,help="Stepout distance for corners")
self.OptionParser.add_option("", "--plasma-prepare-corners-tolerance", action="store", type="float", dest="plasma_prepare_corners_tolerance", default=10.,help="Maximum angle for corner (0-180 deg)")
self.default_tool = {
"name": "Default tool",
"id": "default tool",
"diameter":10.,
"shape": "10",
"penetration angle":90.,
"penetration feed":100.,
"depth step":1.,
"feed":400.,
"in trajectotry":"",
"out trajectotry":"",
"gcode before path":"",
"gcode after path":"",
"sog":"",
"spinlde rpm":"",
"CW or CCW":"",
"tool change gcode":" ",
"4th axis meaning": " ",
"4th axis scale": 1.,
"4th axis offset": 0.,
"passing feed":"800",
"fine feed":"800",
}
self.tools_field_order = [
'name',
'id',
'diameter',
'feed',
'shape',
'penetration angle',
'penetration feed',
"passing feed",
'depth step',
"in trajectotry",
"out trajectotry",
"gcode before path",
"gcode after path",
"sog",
"spinlde rpm",
"CW or CCW",
"tool change gcode",
]
def parse_curve(self, p, layer, w = None, f = None):
c = []
if len(p)==0 :
return []
p = self.transform_csp(p, layer)
### Sort to reduce Rapid distance
k = range(1,len(p))
keys = [0]
while len(k)>0:
end = p[keys[-1]][-1][1]
dist = None
for i in range(len(k)):
start = p[k[i]][0][1]
dist = max( ( -( ( end[0]-start[0])**2+(end[1]-start[1])**2 ) ,i) , dist )
keys += [k[dist[1]]]
del k[dist[1]]
for k in keys:
subpath = p[k]
c += [ [ [subpath[0][1][0],subpath[0][1][1]] , 'move', 0, 0] ]
for i in range(1,len(subpath)):
sp1 = [ [subpath[i-1][j][0], subpath[i-1][j][1]] for j in range(3)]
sp2 = [ [subpath[i ][j][0], subpath[i ][j][1]] for j in range(3)]
c += biarc(sp1,sp2,0,0) if w==None else biarc(sp1,sp2,-f(w[k][i-1]),-f(w[k][i]))
# l1 = biarc(sp1,sp2,0,0) if w==None else biarc(sp1,sp2,-f(w[k][i-1]),-f(w[k][i]))
# print_((-f(w[k][i-1]),-f(w[k][i]), [i1[5] for i1 in l1]) )
c += [ [ [subpath[-1][1][0],subpath[-1][1][1]] ,'end',0,0] ]
return c
################################################################################
### Draw csp
################################################################################
def draw_csp(self, csp, layer=None, group=None, fill='none', stroke='#178ade', width=0.354, style=None):
if layer!=None :
csp = self.transform_csp(csp,layer,reverse=True)
if group==None and layer==None:
group = self.document.getroot()
elif group==None and layer!=None :
group = layer
csp = self.apply_transforms(group,csp, reverse=True)
if style!=None :
return draw_csp(csp, group=group, style=style)
else :
return draw_csp(csp, group=group, fill=fill, stroke=stroke, width=width)
def draw_curve(self, curve, layer, group=None, style=styles["biarc_style"]):
self.set_markers()
for i in [0,1]:
style['biarc%s_r'%i] = simplestyle.parseStyle(style['biarc%s'%i])
style['biarc%s_r'%i]["marker-start"] = "url(#DrawCurveMarker_r)"
del(style['biarc%s_r'%i]["marker-end"])
style['biarc%s_r'%i] = simplestyle.formatStyle(style['biarc%s_r'%i])
if group==None:
if "preview_groups" not in dir(self) :
self.preview_groups = { layer: inkex.etree.SubElement( self.layers[min(1,len(self.layers)-1)], inkex.addNS('g','svg'), {"gcodetools": "Preview group"} ) }
elif layer not in self.preview_groups :
self.preview_groups[layer] = inkex.etree.SubElement( self.layers[min(1,len(self.layers)-1)], inkex.addNS('g','svg'), {"gcodetools": "Preview group"} )
group = self.preview_groups[layer]
s, arcn = '', 0
transform = self.get_transforms(group)
if transform != [] :
transform = self.reverse_transform(transform)
transform = simpletransform.formatTransform(transform)
a,b,c = [0.,0.], [1.,0.], [0.,1.]
k = (b[0]-a[0])*(c[1]-a[1])-(c[0]-a[0])*(b[1]-a[1])
a,b,c = self.transform(a, layer, True), self.transform(b, layer, True), self.transform(c, layer, True)
if ((b[0]-a[0])*(c[1]-a[1])-(c[0]-a[0])*(b[1]-a[1]))*k > 0 : reverse_angle = 1
else : reverse_angle = -1
for sk in curve:
si = sk[:]
si[0], si[2] = self.transform(si[0], layer, True), (self.transform(si[2], layer, True) if type(si[2])==type([]) and len(si[2])==2 else si[2])
if s!='':
if s[1] == 'line':
attr = { 'style': style['line'],
'd':'M %s,%s L %s,%s' % (s[0][0], s[0][1], si[0][0], si[0][1]),
"gcodetools": "Preview",
}
if transform != [] :
attr["transform"] = transform
inkex.etree.SubElement( group, inkex.addNS('path','svg'), attr )
elif s[1] == 'arc':
arcn += 1
sp = s[0]
c = s[2]
s[3] = s[3]*reverse_angle
a = ( (P(si[0])-P(c)).angle() - (P(s[0])-P(c)).angle() )%math.pi2 #s[3]
if s[3]*a<0:
if a>0: a = a-math.pi2
else: a = math.pi2+a
r = math.sqrt( (sp[0]-c[0])**2 + (sp[1]-c[1])**2 )
a_st = ( math.atan2(sp[0]-c[0],- (sp[1]-c[1])) - math.pi/2 ) % (math.pi*2)
st = style['biarc%s' % (arcn%2)][:]
if a>0:
a_end = a_st+a
st = style['biarc%s'%(arcn%2)]
else:
a_end = a_st*1
a_st = a_st+a
st = style['biarc%s_r'%(arcn%2)]
attr = {
'style': st,
inkex.addNS('cx','sodipodi'): str(c[0]),
inkex.addNS('cy','sodipodi'): str(c[1]),
inkex.addNS('rx','sodipodi'): str(r),
inkex.addNS('ry','sodipodi'): str(r),
inkex.addNS('start','sodipodi'): str(a_st),
inkex.addNS('end','sodipodi'): str(a_end),
inkex.addNS('open','sodipodi'): 'true',
inkex.addNS('type','sodipodi'): 'arc',
"gcodetools": "Preview",
}
if transform != [] :
attr["transform"] = transform
inkex.etree.SubElement( group, inkex.addNS('path','svg'), attr)
s = si
def check_dir(self):
if self.options.directory[-1] not in ["/","\\"]:
if "\\" in self.options.directory :
self.options.directory += "\\"
else :
self.options.directory += "/"
print_("Checking directory: '%s'"%self.options.directory)
if (os.path.isdir(self.options.directory)):
if (os.path.isfile(self.options.directory+'header')):
f = open(self.options.directory+'header', 'r')
self.header = f.read()
f.close()
else:
self.header = defaults['header']
if (os.path.isfile(self.options.directory+'footer')):
f = open(self.options.directory+'footer','r')
self.footer = f.read()
f.close()
else:
self.footer = defaults['footer']
self.header += self.options.unit + "\n"
else:
self.error(_("Directory does not exist! Please specify existing directory at Preferences tab!"),"error")
return False
if self.options.add_numeric_suffix_to_filename :
dir_list = os.listdir(self.options.directory)
if "." in self.options.file :
r = re.match(r"^(.*)(\..*)$",self.options.file)
ext = r.group(2)
name = r.group(1)
else:
ext = ""
name = self.options.file
max_n = 0
for s in dir_list :
r = re.match(r"^%s_0*(\d+)%s$"%(re.escape(name),re.escape(ext) ), s)
if r :
max_n = max(max_n,int(r.group(1)))
filename = name + "_" + ( "0"*(4-len(str(max_n+1))) + str(max_n+1) ) + ext
self.options.file = filename
if self.options.directory[-1] not in ["/","\\"]:
if "\\" in self.options.directory :
self.options.directory += "\\"
else :
self.options.directory += "/"
try:
f = open(self.options.directory+self.options.file, "w")
f.close()
except:
self.error(_("Can not write to specified file!\n%s"%(self.options.directory+self.options.file)),"error")
return False
return True
################################################################################
###
### Generate Gcode
### Generates Gcode on given curve.
###
### Curve definition [start point, type = {'arc','line','move','end'}, arc center, arc angle, end point, [zstart, zend]]
###
################################################################################
def generate_gcode(self, curve, layer, depth):
Zauto_scale = self.Zauto_scale[layer]
tool = self.tools[layer][0]
g = ""
def c(c):
c = [c[i] if i<len(c) else None for i in range(6)]
if c[5] == 0 : c[5]=None
s,s1 = [" X", " Y", " Z", " I", " J", " K"], ["","","","","",""]
m,a = [1,1,self.options.Zscale*Zauto_scale,1,1,self.options.Zscale*Zauto_scale], [0,0,self.options.Zoffset,0,0,0]
r = ''
for i in range(6):
if c[i]!=None:
r += s[i] + ("%f" % (c[i]*m[i]+a[i])) + s1[i]
return r
def calculate_angle(a, current_a):
return min(
[abs(a-current_a%math.pi2+math.pi2), a+current_a-current_a%math.pi2+math.pi2],
[abs(a-current_a%math.pi2-math.pi2), a+current_a-current_a%math.pi2-math.pi2],
[abs(a-current_a%math.pi2), a+current_a-current_a%math.pi2])[1]
if len(curve)==0 : return ""
try :
self.last_used_tool == None
except :
self.last_used_tool = None
print_("working on curve")
print_(curve)
if tool != self.last_used_tool :
g += ( "(Change tool to %s)\n" % re.sub("\"'\(\)\\\\"," ",tool["name"]) ) + tool["tool change gcode"] + "\n"
lg, zs, f = 'G00', self.options.Zsafe, " F%f"%tool['feed']
current_a = 0
go_to_safe_distance = "G00" + c([None,None,zs]) + "\n"
penetration_feed = " F%s"%tool['penetration feed']
for i in range(1,len(curve)):
# Creating Gcode for curve between s=curve[i-1] and si=curve[i] start at s[0] end at s[4]=si[0]
s, si = curve[i-1], curve[i]
feed = f if lg not in ['G01','G02','G03'] else ''
if s[1] == 'move':
g += go_to_safe_distance + "G00" + c(si[0]) + "\n" + tool['gcode before path'] + "\n"
lg = 'G00'
elif s[1] == 'end':
g += go_to_safe_distance + tool['gcode after path'] + "\n"
lg = 'G00'
elif s[1] == 'line':
if tool['4th axis meaning'] == "tangent knife" :
a = atan2(si[0][0]-s[0][0],si[0][1]-s[0][1])
a = calculate_angle(a, current_a)
g+="G01 A%s\n" % (a*tool['4th axis scale']+tool['4th axis offset'])
current_a = a
if lg=="G00": g += "G01" + c([None,None,s[5][0]+depth]) + penetration_feed +"(Penetrate)\n"
g += "G01" +c(si[0]+[s[5][1]+depth]) + feed + "\n"
lg = 'G01'
elif s[1] == 'arc':
r = [(s[2][0]-s[0][0]), (s[2][1]-s[0][1])]
if tool['4th axis meaning'] == "tangent knife" :
if s[3]<0 : # CW
a1 = atan2(s[2][1]-s[0][1],-s[2][0]+s[0][0]) + math.pi
else: #CCW
a1 = atan2(-s[2][1]+s[0][1],s[2][0]-s[0][0]) + math.pi
a = calculate_angle(a1, current_a)
g+="G01 A%s\n" % (a*tool['4th axis scale']+tool['4th axis offset'])
current_a = a
axis4 = " A%s"%((current_a+s[3])*tool['4th axis scale']+tool['4th axis offset'])
current_a = current_a+s[3]
else : axis4 = ""
if lg=="G00": g += "G01" + c([None,None,s[5][0]+depth]) + penetration_feed + "(Penetrate)\n"
if (r[0]**2 + r[1]**2)>self.options.min_arc_radius**2:
r1, r2 = (P(s[0])-P(s[2])), (P(si[0])-P(s[2]))
if abs(r1.mag()-r2.mag()) < 0.001 :
g += ("G02" if s[3]<0 else "G03") + c(si[0]+[ s[5][1]+depth, (s[2][0]-s[0][0]),(s[2][1]-s[0][1]) ]) + feed + axis4 + "\n"
else:
r = (r1.mag()+r2.mag())/2
g += ("G02" if s[3]<0 else "G03") + c(si[0]+[s[5][1]+depth]) + " R%f" % (r) + feed + axis4 + "\n"
lg = 'G02'
else:
if tool['4th axis meaning'] == "tangent knife" :
a = atan2(si[0][0]-s[0][0],si[0][1]-s[0][1]) + math.pi
a = calculate_angle(a, current_a)
g+="G01 A%s\n" % (a*tool['4th axis scale']+tool['4th axis offset'])
current_a = a
g += "G01" +c(si[0]+[s[5][1]+depth]) + feed + "\n"
lg = 'G01'
if si[1] == 'end':
g += go_to_safe_distance + tool['gcode after path'] + "\n"
return g
def get_transforms(self,g):
root = self.document.getroot()
trans = []
while (g!=root):
if 'transform' in g.keys():
t = g.get('transform')
t = simpletransform.parseTransform(t)
trans = simpletransform.composeTransform(t,trans) if trans != [] else t
print_(trans)
g=g.getparent()
return trans
def reverse_transform(self,transform):
trans = numpy.array(transform + [[0,0,1]])
if numpy.linalg.det(trans)!=0 :
trans = numpy.linalg.inv(trans).tolist()[:2]
return trans
else :
return transform
def apply_transforms(self,g,csp, reverse=False):
trans = self.get_transforms(g)
if trans != []:
if not reverse :
simpletransform.applyTransformToPath(trans, csp)
else :
simpletransform.applyTransformToPath(self.reverse_transform(trans), csp)
return csp
def transform_scalar(self,x,layer,reverse=False):
return self.transform([x,0],layer,reverse)[0] - self.transform([0,0],layer,reverse)[0]
def transform(self,source_point, layer, reverse=False):
if layer not in self.transform_matrix:
for i in range(self.layers.index(layer),-1,-1):
if self.layers[i] in self.orientation_points :
break
if self.layers[i] not in self.orientation_points :
self.error(_("Orientation points for '%s' layer have not been found! Please add orientation points using Orientation tab!") % layer.get(inkex.addNS('label','inkscape')),"no_orientation_points")
elif self.layers[i] in self.transform_matrix :
self.transform_matrix[layer] = self.transform_matrix[self.layers[i]]
self.Zcoordinates[layer] = self.Zcoordinates[self.layers[i]]
else :
orientation_layer = self.layers[i]
if len(self.orientation_points[orientation_layer])>1 :
self.error(_("There are more than one orientation point groups in '%s' layer") % orientation_layer.get(inkex.addNS('label','inkscape')),"more_than_one_orientation_point_groups")
points = self.orientation_points[orientation_layer][0]
if len(points)==2:
points += [ [ [(points[1][0][1]-points[0][0][1])+points[0][0][0], -(points[1][0][0]-points[0][0][0])+points[0][0][1]], [-(points[1][1][1]-points[0][1][1])+points[0][1][0], points[1][1][0]-points[0][1][0]+points[0][1][1]] ] ]
if len(points)==3:
print_("Layer '%s' Orientation points: " % orientation_layer.get(inkex.addNS('label','inkscape')))
for point in points:
print_(point)
# Zcoordinates definition taken from Orientatnion point 1 and 2
self.Zcoordinates[layer] = [max(points[0][1][2],points[1][1][2]), min(points[0][1][2],points[1][1][2])]
matrix = numpy.array([
[points[0][0][0], points[0][0][1], 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, points[0][0][0], points[0][0][1], 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, points[0][0][0], points[0][0][1], 1],
[points[1][0][0], points[1][0][1], 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, points[1][0][0], points[1][0][1], 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, points[1][0][0], points[1][0][1], 1],
[points[2][0][0], points[2][0][1], 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, points[2][0][0], points[2][0][1], 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, points[2][0][0], points[2][0][1], 1]
])
if numpy.linalg.det(matrix)!=0 :
m = numpy.linalg.solve(matrix,
numpy.array(
[[points[0][1][0]], [points[0][1][1]], [1], [points[1][1][0]], [points[1][1][1]], [1], [points[2][1][0]], [points[2][1][1]], [1]]
)
).tolist()
self.transform_matrix[layer] = [[m[j*3+i][0] for i in range(3)] for j in range(3)]
else :
self.error(_("Orientation points are wrong! (if there are two orientation points they should not be the same. If there are three orientation points they should not be in a straight line.)"),"wrong_orientation_points")
else :
self.error(_("Orientation points are wrong! (if there are two orientation points they should not be the same. If there are three orientation points they should not be in a straight line.)"),"wrong_orientation_points")
self.transform_matrix_reverse[layer] = numpy.linalg.inv(self.transform_matrix[layer]).tolist()
print_("\n Layer '%s' transformation matrixes:" % layer.get(inkex.addNS('label','inkscape')) )
print_(self.transform_matrix)
print_(self.transform_matrix_reverse)
###self.Zauto_scale[layer] = math.sqrt( (self.transform_matrix[layer][0][0]**2 + self.transform_matrix[layer][1][1]**2)/2 )
### Zautoscale is absolete
self.Zauto_scale[layer] = 1
print_("Z automatic scale = %s (computed according orientation points)" % self.Zauto_scale[layer])
x,y = source_point[0], source_point[1]
if not reverse :
t = self.transform_matrix[layer]
else :
t = self.transform_matrix_reverse[layer]
return [t[0][0]*x+t[0][1]*y+t[0][2], t[1][0]*x+t[1][1]*y+t[1][2]]
def transform_csp(self, csp_, layer, reverse = False):
csp = [ [ [csp_[i][j][0][:],csp_[i][j][1][:],csp_[i][j][2][:]] for j in range(len(csp_[i])) ] for i in range(len(csp_)) ]
for i in xrange(len(csp)):
for j in xrange(len(csp[i])):
for k in xrange(len(csp[i][j])):
csp[i][j][k] = self.transform(csp[i][j][k],layer, reverse)
return csp
################################################################################
### Errors handling function, notes are just printed into Logfile,
### warnings are printed into log file and warning message is displayed but
### extension continues working, errors causes log and execution is halted
### Notes, warnings adn errors could be assigned to space or comma or dot
### sepparated strings (case is ignoreg).
################################################################################
def error(self, s, type_= "Warning"):
notes = "Note "
warnings = """
Warning tools_warning
orientation_warning
bad_orientation_points_in_some_layers
more_than_one_orientation_point_groups
more_than_one_tool
orientation_have_not_been_defined
tool_have_not_been_defined
selection_does_not_contain_paths
selection_does_not_contain_paths_will_take_all
selection_is_empty_will_comupe_drawing
selection_contains_objects_that_are_not_paths
Continue
"""
errors = """
Error
wrong_orientation_points
area_tools_diameter_error
no_tool_error
active_layer_already_has_tool
active_layer_already_has_orientation_points
"""
s = str(s)
if type_.lower() in re.split("[\s\n,\.]+", errors.lower()) :
print_(s)
inkex.errormsg(s+"\n")
sys.exit()
elif type_.lower() in re.split("[\s\n,\.]+", warnings.lower()) :
print_(s)
inkex.errormsg(s+"\n")
elif type_.lower() in re.split("[\s\n,\.]+", notes.lower()) :
print_(s)
else :
print_(s)
inkex.errormsg(s)
sys.exit()
################################################################################
### Set markers
################################################################################
def set_markers(self) :
self.get_defs()
# Add marker to defs if it doesnot exists
if "CheckToolsAndOPMarker" not in self.defs :
defs = inkex.etree.SubElement( self.document.getroot(), inkex.addNS("defs","svg"))
marker = inkex.etree.SubElement( defs, inkex.addNS("marker","svg"), {"id":"CheckToolsAndOPMarker","orient":"auto","refX":"-4","refY":"-1.687441","style":"overflow:visible"})
inkex.etree.SubElement( marker, inkex.addNS("path","svg"),
{ "d":" m -4.588864,-1.687441 0.0,0.0 L -9.177728,0.0 c 0.73311,-0.996261 0.728882,-2.359329 0.0,-3.374882",
"style": "fill:#000044; fill-rule:evenodd;stroke:none;" }
)
if "DrawCurveMarker" not in self.defs :
defs = inkex.etree.SubElement( self.document.getroot(), inkex.addNS("defs","svg"))
marker = inkex.etree.SubElement( defs, inkex.addNS("marker","svg"), {"id":"DrawCurveMarker","orient":"auto","refX":"-4","refY":"-1.687441","style":"overflow:visible"})
inkex.etree.SubElement( marker, inkex.addNS("path","svg"),
{ "d":"m -4.588864,-1.687441 0.0,0.0 L -9.177728,0.0 c 0.73311,-0.996261 0.728882,-2.359329 0.0,-3.374882",
"style": "fill:#000044; fill-rule:evenodd;stroke:none;" }
)
if "DrawCurveMarker_r" not in self.defs :
defs = inkex.etree.SubElement( self.document.getroot(), inkex.addNS("defs","svg"))
marker = inkex.etree.SubElement( defs, inkex.addNS("marker","svg"), {"id":"DrawCurveMarker_r","orient":"auto","refX":"4","refY":"-1.687441","style":"overflow:visible"})
inkex.etree.SubElement( marker, inkex.addNS("path","svg"),
{ "d":"m 4.588864,-1.687441 0.0,0.0 L 9.177728,0.0 c -0.73311,-0.996261 -0.728882,-2.359329 0.0,-3.374882",
"style": "fill:#000044; fill-rule:evenodd;stroke:none;" }
)
if "InOutPathMarker" not in self.defs :
defs = inkex.etree.SubElement( self.document.getroot(), inkex.addNS("defs","svg"))
marker = inkex.etree.SubElement( defs, inkex.addNS("marker","svg"), {"id":"InOutPathMarker","orient":"auto","refX":"-4","refY":"-1.687441","style":"overflow:visible"})
inkex.etree.SubElement( marker, inkex.addNS("path","svg"),
{ "d":"m -4.588864,-1.687441 0.0,0.0 L -9.177728,0.0 c 0.73311,-0.996261 0.728882,-2.359329 0.0,-3.374882",
"style": "fill:#0072a7; fill-rule:evenodd;stroke:none;" }
)
################################################################################
### Get defs from svg
################################################################################
def get_defs(self) :
self.defs = {}
def recursive(g) :
for i in g:
if i.tag == inkex.addNS("defs","svg") :
for j in i:
self.defs[j.get("id")] = i
if i.tag ==inkex.addNS("g",'svg') :
recursive(i)
recursive(self.document.getroot())
################################################################################
###
### Get Gcodetools info from the svg
###
################################################################################
def get_info(self):
self.selected_paths = {}
self.paths = {}
self.tools = {}
self.orientation_points = {}
self.graffiti_reference_points = {}
self.layers = [self.document.getroot()]
self.Zcoordinates = {}
self.transform_matrix = {}
self.transform_matrix_reverse = {}
self.Zauto_scale = {}
self.in_out_reference_points = []
self.my3Dlayer = None
def recursive_search(g, layer, selected=False):
items = g.getchildren()
items.reverse()
for i in items:
if selected:
self.selected[i.get("id")] = i
if i.tag == inkex.addNS("g",'svg') and i.get(inkex.addNS('groupmode','inkscape')) == 'layer':
if i.get(inkex.addNS('label','inkscape')) == '3D' :
self.my3Dlayer=i
else :
self.layers += [i]
recursive_search(i,i)
elif i.get('gcodetools') == "Gcodetools orientation group" :
points = self.get_orientation_points(i)
if points != None :
self.orientation_points[layer] = self.orientation_points[layer]+[points[:]] if layer in self.orientation_points else [points[:]]
print_("Found orientation points in '%s' layer: %s" % (layer.get(inkex.addNS('label','inkscape')), points))
else :
self.error(_("Warning! Found bad orientation points in '%s' layer. Resulting Gcode could be corrupt!") % layer.get(inkex.addNS('label','inkscape')), "bad_orientation_points_in_some_layers")
#Need to recognise old files ver 1.6.04 and earlier
elif i.get("gcodetools") == "Gcodetools tool definition" or i.get("gcodetools") == "Gcodetools tool defenition" :
tool = self.get_tool(i)
self.tools[layer] = self.tools[layer] + [tool.copy()] if layer in self.tools else [tool.copy()]
print_("Found tool in '%s' layer: %s" % (layer.get(inkex.addNS('label','inkscape')), tool))
elif i.get("gcodetools") == "Gcodetools graffiti reference point" :
point = self.get_graffiti_reference_points(i)
if point != [] :
self.graffiti_reference_points[layer] = self.graffiti_reference_points[layer]+[point[:]] if layer in self.graffiti_reference_points else [point]
else :
self.error(_("Warning! Found bad graffiti reference point in '%s' layer. Resulting Gcode could be corrupt!") % layer.get(inkex.addNS('label','inkscape')), "bad_orientation_points_in_some_layers")
elif i.tag == inkex.addNS('path','svg'):
if "gcodetools" not in i.keys() :
self.paths[layer] = self.paths[layer] + [i] if layer in self.paths else [i]
if i.get("id") in self.selected :
self.selected_paths[layer] = self.selected_paths[layer] + [i] if layer in self.selected_paths else [i]
elif i.get("gcodetools") == "In-out reference point group" :
items_ = i.getchildren()
items_.reverse()
for j in items_ :
if j.get("gcodetools") == "In-out reference point" :
self.in_out_reference_points.append( self.apply_transforms(j,cubicsuperpath.parsePath(j.get("d")))[0][0][1] )
elif i.tag == inkex.addNS("g",'svg'):
recursive_search(i,layer, (i.get("id") in self.selected) )
elif i.get("id") in self.selected :
# xgettext:no-pango-format
self.error(_("This extension works with Paths and Dynamic Offsets and groups of them only! All other objects will be ignored!\nSolution 1: press Path->Object to path or Shift+Ctrl+C.\nSolution 2: Path->Dynamic offset or Ctrl+J.\nSolution 3: export all contours to PostScript level 2 (File->Save As->.ps) and File->Import this file."),"selection_contains_objects_that_are_not_paths")
recursive_search(self.document.getroot(),self.document.getroot())
if len(self.layers) == 1 :
self.error(_("Document has no layers! Add at least one layer using layers panel (Ctrl+Shift+L)"),"Error")
root = self.document.getroot()
if root in self.selected_paths or root in self.paths :
self.error(_("Warning! There are some paths in the root of the document, but not in any layer! Using bottom-most layer for them."), "tools_warning" )
if root in self.selected_paths :
if self.layers[-1] in self.selected_paths :
self.selected_paths[self.layers[-1]] += self.selected_paths[root][:]
else :
self.selected_paths[self.layers[-1]] = self.selected_paths[root][:]
del self.selected_paths[root]
if root in self.paths :
if self.layers[-1] in self.paths :
self.paths[self.layers[-1]] += self.paths[root][:]
else :
self.paths[self.layers[-1]] = self.paths[root][:]
del self.paths[root]
def get_orientation_points(self,g):
items = g.getchildren()
items.reverse()
p2, p3 = [], []
p = None
for i in items:
if i.tag == inkex.addNS("g",'svg') and i.get("gcodetools") == "Gcodetools orientation point (2 points)":
p2 += [i]
if i.tag == inkex.addNS("g",'svg') and i.get("gcodetools") == "Gcodetools orientation point (3 points)":
p3 += [i]
if len(p2)==2 : p=p2
elif len(p3)==3 : p=p3
if p==None : return None
points = []
for i in p :
point = [[],[]]
for node in i :
if node.get('gcodetools') == "Gcodetools orientation point arrow":
point[0] = self.apply_transforms(node,cubicsuperpath.parsePath(node.get("d")))[0][0][1]
if node.get('gcodetools') == "Gcodetools orientation point text":
r = re.match(r'(?i)\s*\(\s*(-?\s*\d*(?:,|\.)*\d*)\s*;\s*(-?\s*\d*(?:,|\.)*\d*)\s*;\s*(-?\s*\d*(?:,|\.)*\d*)\s*\)\s*',get_text(node))
point[1] = [float(r.group(1)),float(r.group(2)),float(r.group(3))]
if point[0]!=[] and point[1]!=[]: points += [point]
if len(points)==len(p2)==2 or len(points)==len(p3)==3 : return points
else : return None
def get_graffiti_reference_points(self,g):
point = [[], '']
for node in g :
if node.get('gcodetools') == "Gcodetools graffiti reference point arrow":
point[0] = self.apply_transforms(node,cubicsuperpath.parsePath(node.get("d")))[0][0][1]
if node.get('gcodetools') == "Gcodetools graffiti reference point text":
point[1] = get_text(node)
if point[0]!=[] and point[1]!='' : return point
else : return []
def get_tool(self, g):
tool = self.default_tool.copy()
tool["self_group"] = g
for i in g:
# Get parameters
if i.get("gcodetools") == "Gcodetools tool background" :
tool["style"] = simplestyle.parseStyle(i.get("style"))
elif i.get("gcodetools") == "Gcodetools tool parameter" :
key = None
value = None
for j in i:
#need to recognise old tools from ver 1.6.04
if j.get("gcodetools") == "Gcodetools tool definition field name" or j.get("gcodetools") == "Gcodetools tool defention field name":
key = get_text(j)
if j.get("gcodetools") == "Gcodetools tool definition field value" or j.get("gcodetools") == "Gcodetools tool defention field value":
value = get_text(j)
if value == "(None)": value = ""
if value == None or key == None: continue
#print_("Found tool parameter '%s':'%s'" % (key,value))
if key in self.default_tool.keys() :
try :
tool[key] = type(self.default_tool[key])(value)
except :
tool[key] = self.default_tool[key]
self.error(_("Warning! Tool's and default tool's parameter's (%s) types are not the same ( type('%s') != type('%s') ).") % (key, value, self.default_tool[key]), "tools_warning")
else :
tool[key] = value
self.error(_("Warning! Tool has parameter that default tool has not ( '%s': '%s' ).") % (key, value), "tools_warning" )
return tool
def set_tool(self,layer):
# print_(("index(layer)=",self.layers.index(layer),"set_tool():layer=",layer,"self.tools=",self.tools))
# for l in self.layers:
# print_(("l=",l))
for i in range(self.layers.index(layer),-1,-1):
# print_(("processing layer",i))
if self.layers[i] in self.tools :
break
if self.layers[i] in self.tools :
if self.layers[i] != layer : self.tools[layer] = self.tools[self.layers[i]]
if len(self.tools[layer])>1 : self.error(_("Layer '%s' contains more than one tool!") % self.layers[i].get(inkex.addNS('label','inkscape')), "more_than_one_tool")
return self.tools[layer]
else :
self.error(_("Can not find tool for '%s' layer! Please add one with Tools library tab!") % layer.get(inkex.addNS('label','inkscape')), "no_tool_error")
################################################################################
###
### Path to Gcode
###
################################################################################
def path_to_gcode(self) :
from functools import partial
def get_boundaries(points):
minx,miny,maxx,maxy=None,None,None,None
out=[[],[],[],[]]
for p in points:
if minx==p[0]:
out[0]+=[p]
if minx==None or p[0]<minx:
minx=p[0]
out[0]=[p]
if miny==p[1]:
out[1]+=[p]
if miny==None or p[1]<miny:
miny=p[1]
out[1]=[p]
if maxx==p[0]:
out[2]+=[p]
if maxx==None or p[0]>maxx:
maxx=p[0]
out[2]=[p]
if maxy==p[1]:
out[3]+=[p]
if maxy==None or p[1]>maxy:
maxy=p[1]
out[3]=[p]
return out
def remove_duplicates(points):
i=0
out=[]
for p in points:
for j in xrange(i,len(points)):
if p==points[j]: points[j]=[None,None]
if p!=[None,None]: out+=[p]
i+=1
return(out)
def get_way_len(points):
l=0
for i in xrange(1,len(points)):
l+=math.sqrt((points[i][0]-points[i-1][0])**2 + (points[i][1]-points[i-1][1])**2)
return l
def sort_dxfpoints(points):
points=remove_duplicates(points)
# print_(get_boundaries(get_boundaries(points)[2])[1])
ways=[
# l=0, d=1, r=2, u=3
[3,0], # ul
[3,2], # ur
[1,0], # dl
[1,2], # dr
[0,3], # lu
[0,1], # ld
[2,3], # ru
[2,1], # rd
]
# print_(("points=",points))
minimal_way=[]
minimal_len=None
minimal_way_type=None
for w in ways:
tpoints=points[:]
cw=[]
# print_(("tpoints=",tpoints))
for j in xrange(0,len(points)):
p=get_boundaries(get_boundaries(tpoints)[w[0]])[w[1]]
# print_(p)
tpoints.remove(p[0])
cw+=p
curlen = get_way_len(cw)
if minimal_len==None or curlen < minimal_len:
minimal_len=curlen
minimal_way=cw
minimal_way_type=w
return minimal_way
def sort_lines(lines):
if len(lines) == 0 : return []
lines = [ [key]+lines[key] for key in range(len(lines))]
keys = [0]
end_point = lines[0][3:]
print_("!!!",lines,"\n",end_point)
del lines[0]
while len(lines)>0:
dist = [ [point_to_point_d2(end_point,lines[i][1:3]),i] for i in range(len(lines))]
i = min(dist)[1]
keys.append(lines[i][0])
end_point = lines[i][3:]
del lines[i]
return keys
def sort_curves(curves):
lines = []
for curve in curves:
lines += [curve[0][0][0] + curve[-1][-1][0]]
return sort_lines(lines)
def print_dxfpoints(points):
gcode=""
for point in points:
gcode +="(drilling dxfpoint)\nG00 Z%f\nG00 X%f Y%f\nG01 Z%f F%f\nG04 P%f\nG00 Z%f\n" % (self.options.Zsafe,point[0],point[1],self.Zcoordinates[layer][1],self.tools[layer][0]["penetration feed"],0.2,self.options.Zsafe)
# print_(("got dxfpoints array=",points))
return gcode
def get_path_properties(node, recursive=True, tags={inkex.addNS('desc','svg'):"Description",inkex.addNS('title','svg'):"Title"} ) :
res = {}
done = False
root = self.document.getroot()
while not done and node != root :
for i in node.getchildren():
if i.tag in tags:
res[tags[i.tag]] = i.text
done = True
node = node.getparent()
return res
if self.selected_paths == {} and self.options.auto_select_paths:
paths=self.paths
self.error(_("No paths are selected! Trying to work on all available paths."),"warning")
else :
paths = self.selected_paths
self.check_dir()
gcode = ""
biarc_group = inkex.etree.SubElement( self.selected_paths.keys()[0] if len(self.selected_paths.keys())>0 else self.layers[0], inkex.addNS('g','svg') )
print_(("self.layers=",self.layers))
print_(("paths=",paths))
colors = {}
for layer in self.layers :
if layer in paths :
print_(("layer",layer))
# transform simple path to get all var about orientation
self.transform_csp([ [ [[0,0],[0,0],[0,0]], [[0,0],[0,0],[0,0]] ] ], layer)
self.set_tool(layer)
curves = []
dxfpoints = []
try :
depth_func = eval('lambda c,d,s: ' + self.options.path_to_gcode_depth_function.strip('"'))
except:
self.error("Bad depth function! Enter correct function at Path to Gcode tab!")
for path in paths[layer] :
if "d" not in path.keys() :
self.error(_("Warning: One or more paths do not have 'd' parameter, try to Ungroup (Ctrl+Shift+G) and Object to Path (Ctrl+Shift+C)!"),"selection_contains_objects_that_are_not_paths")
continue
csp = cubicsuperpath.parsePath(path.get("d"))
csp = self.apply_transforms(path, csp)
id_ = path.get("id")
def set_comment(match, path):
if match.group(1) in path.keys() :
return path.get(match.group(1))
else:
return "None"
if self.options.comment_gcode != "" :
comment = re.sub("\[([A-Za-z_\-\:]+)\]", partial(set_comment, path=path), self.options.comment_gcode)
comment = comment.replace(":newline:","\n")
comment = gcode_comment_str(comment)
else:
comment = ""
if self.options.comment_gcode_from_properties :
tags = get_path_properties(path)
for tag in tags :
comment += gcode_comment_str("%s: %s"%(tag,tags[tag]))
style = simplestyle.parseStyle(path.get("style"))
colors[id_] = simplestyle.parseColor(style['stroke'] if "stroke" in style and style['stroke']!='none' else "#000")
if path.get("dxfpoint") == "1":
tmp_curve=self.transform_csp(csp, layer)
x=tmp_curve[0][0][0][0]
y=tmp_curve[0][0][0][1]
print_("got dxfpoint (scaled) at (%f,%f)" % (x,y))
dxfpoints += [[x,y]]
else:
zd,zs = self.Zcoordinates[layer][1], self.Zcoordinates[layer][0]
c = 1. - float(sum(colors[id_]))/255/3
curves += [
[
[id_, depth_func(c,zd,zs), comment],
[ self.parse_curve([subpath], layer) for subpath in csp ]
]
]
# for c in curves :
# print_(c)
dxfpoints=sort_dxfpoints(dxfpoints)
gcode+=print_dxfpoints(dxfpoints)
for curve in curves :
for subcurve in curve[1] :
self.draw_curve(subcurve, layer)
if self.options.path_to_gcode_order == 'subpath by subpath':
curves_ = []
for curve in curves :
curves_ += [ [curve[0],[subcurve]] for subcurve in curve[1] ]
curves = curves_
self.options.path_to_gcode_order = 'path by path'
if self.options.path_to_gcode_order == 'path by path':
if self.options.path_to_gcode_sort_paths :
keys = sort_curves( [curve[1] for curve in curves] )
else :
keys = range(len(curves))
for key in keys:
d = curves[key][0][1]
for step in range( 0, int(math.ceil( abs((zs-d)/self.tools[layer][0]["depth step"] )) ) ):
z = max(d, zs - abs(self.tools[layer][0]["depth step"]*(step+1)))
gcode += gcode_comment_str("\nStart cutting path id: %s"%curves[key][0][0])
if curves[key][0][2] != "()" :
gcode += curves[key][0][2] # add comment
for curve in curves[key][1]:
gcode += self.generate_gcode(curve, layer, z)
gcode += gcode_comment_str("End cutting path id: %s\n\n"%curves[key][0][0])
else: # pass by pass
mind = min( [curve[0][1] for curve in curves] )
for step in range( 0, int(math.ceil( abs((zs-mind)/self.tools[layer][0]["depth step"] )) ) ):
z = zs - abs(self.tools[layer][0]["depth step"]*(step))
curves_ = []
for curve in curves:
if curve[0][1]<z :
curves_.append(curve)
z = zs - abs(self.tools[layer][0]["depth step"]*(step+1))
gcode += "\n(Pass at depth %s)\n"%z
if self.options.path_to_gcode_sort_paths :
keys = sort_curves( [curve[1] for curve in curves_] )
else :
keys = range(len(curves_))
for key in keys:
gcode += gcode_comment_str("Start cutting path id: %s"%curves[key][0][0])
if curves[key][0][2] != "()" :
gcode += curves[key][0][2] # add comment
for subcurve in curves_[key][1]:
gcode += self.generate_gcode(subcurve, layer, max(z,curves_[key][0][1]))
gcode += gcode_comment_str("End cutting path id: %s\n\n"%curves[key][0][0])
self.export_gcode(gcode)
################################################################################
###
### dxfpoints
###
################################################################################
def dxfpoints(self):
if self.selected_paths == {}:
self.error(_("Nothing is selected. Please select something to convert to drill point (dxfpoint) or clear point sign."),"warning")
for layer in self.layers :
if layer in self.selected_paths :
for path in self.selected_paths[layer]:
# print_(("processing path",path.get('d')))
if self.options.dxfpoints_action == 'replace':
# print_("trying to set as dxfpoint")
path.set("dxfpoint","1")
r = re.match("^\s*.\s*(\S+)",path.get("d"))
if r!=None:
print_(("got path=",r.group(1)))
path.set("d","m %s 2.9375,-6.343750000001 0.8125,1.90625 6.843748640396,-6.84374864039 0,0 0.6875,0.6875 -6.84375,6.84375 1.90625,0.812500000001 z" % r.group(1))
path.set("style",styles["dxf_points"])
if self.options.dxfpoints_action == 'save':
path.set("dxfpoint","1")
if self.options.dxfpoints_action == 'clear' and path.get("dxfpoint") == "1":
path.set("dxfpoint","0")
# for id, node in self.selected.iteritems():
# print_((id,node,node.attrib))
################################################################################
###
### Artefacts
###
################################################################################
def area_artefacts(self) :
if self.selected_paths == {} and self.options.auto_select_paths:
paths=self.paths
self.error(_("No paths are selected! Trying to work on all available paths."),"warning")
else :
paths = self.selected_paths
for layer in paths :
# paths[layer].reverse() # Reverse list of paths to leave their order
for path in paths[layer] :
parent = path.getparent()
style = path.get("style") if "style" in path.keys() else ""
if "d" not in path.keys() :
self.error(_("Warning: One or more paths do not have 'd' parameter, try to Ungroup (Ctrl+Shift+G) and Object to Path (Ctrl+Shift+C)!"),"selection_contains_objects_that_are_not_paths")
continue
csp = cubicsuperpath.parsePath(path.get("d"))
remove = []
for i in range(len(csp)) :
subpath = [ [point[:] for point in points] for points in csp[i]]
subpath = self.apply_transforms(path,[subpath])[0]
bounds = csp_simple_bound([subpath])
if (bounds[2]-bounds[0])**2+(bounds[3]-bounds[1])**2 < self.options.area_find_artefacts_diameter**2:
if self.options.area_find_artefacts_action == "mark with an arrow" :
arrow = cubicsuperpath.parsePath( 'm %s,%s 2.9375,-6.343750000001 0.8125,1.90625 6.843748640396,-6.84374864039 0,0 0.6875,0.6875 -6.84375,6.84375 1.90625,0.812500000001 z' % (subpath[0][1][0],subpath[0][1][1]) )
arrow = self.apply_transforms(path,arrow,True)
inkex.etree.SubElement(parent, inkex.addNS('path','svg'),
{
'd': cubicsuperpath.formatPath(arrow),
'style': styles["area artefact arrow"],
'gcodetools': 'area artefact arrow',
})
elif self.options.area_find_artefacts_action == "mark with style" :
inkex.etree.SubElement(parent, inkex.addNS('path','svg'), {'d': cubicsuperpath.formatPath(csp[i]), 'style': styles["area artefact"]})
remove.append(i)
elif self.options.area_find_artefacts_action == "delete" :
remove.append(i)
print_("Deleted artefact %s" % subpath )
remove.reverse()
for i in remove :
del csp[i]
if len(csp) == 0 :
parent.remove(path)
else :
path.set("d", cubicsuperpath.formatPath(csp))
return
################################################################################
###
### Calculate area curves
###
################################################################################
def area(self) :
if len(self.selected_paths)<=0:
self.error(_("This extension requires at least one selected path."),"warning")
return
for layer in self.layers :
if layer in self.selected_paths :
self.set_tool(layer)
if self.tools[layer][0]['diameter']<=0 :
self.error(_("Tool diameter must be > 0 but tool's diameter on '%s' layer is not!") % layer.get(inkex.addNS('label','inkscape')),"area_tools_diameter_error")
for path in self.selected_paths[layer]:
print_(("doing path", path.get("style"), path.get("d")))
area_group = inkex.etree.SubElement( path.getparent(), inkex.addNS('g','svg') )
d = path.get('d')
print_(d)
if d==None:
print_("omitting non-path")
self.error(_("Warning: omitting non-path"),"selection_contains_objects_that_are_not_paths")
continue
csp = cubicsuperpath.parsePath(d)
if path.get(inkex.addNS('type','sodipodi'))!="inkscape:offset":
print_("Path %s is not an offset. Preparation started." % path.get("id"))
# Path is not offset. Preparation will be needed.
# Finding top most point in path (min y value)
min_x,min_y,min_i,min_j,min_t = csp_true_bounds(csp)[1]
# Reverse path if needed.
if min_y!=float("-inf") :
# Move outline subpath to the begining of csp
subp = csp[min_i]
del csp[min_i]
j = min_j
# Split by the topmost point and join again
if min_t in [0,1]:
if min_t == 0: j=j-1
subp[-1][2], subp[0][0] = subp[-1][1], subp[0][1]
subp = [ [subp[j][1], subp[j][1], subp[j][2]] ] + subp[j+1:] + subp[:j] + [ [subp[j][0], subp[j][1], subp[j][1]] ]
else:
sp1,sp2,sp3 = csp_split(subp[j-1],subp[j],min_t)
subp[-1][2], subp[0][0] = subp[-1][1], subp[0][1]
subp = [ [ sp2[1], sp2[1],sp2[2] ] ] + [sp3] + subp[j+1:] + subp[:j-1] + [sp1] + [[ sp2[0], sp2[1],sp2[1] ]]
csp = [subp] + csp
# reverse path if needed
if csp_subpath_ccw(csp[0]) :
for i in range(len(csp)):
n = []
for j in csp[i]:
n = [ [j[2][:],j[1][:],j[0][:]] ] + n
csp[i] = n[:]
d = cubicsuperpath.formatPath(csp)
print_(("original d=",d))
d = re.sub(r'(?i)(m[^mz]+)',r'\1 Z ',d)
d = re.sub(r'(?i)\s*z\s*z\s*',r' Z ',d)
d = re.sub(r'(?i)\s*([A-Za-z])\s*',r' \1 ',d)
print_(("formatted d=",d))
# scale = sqrt(Xscale**2 + Yscale**2) / sqrt(1**2 + 1**2)
p0 = self.transform([0,0],layer)
p1 = self.transform([0,1],layer)
scale = (P(p0)-P(p1)).mag()
if scale == 0 : scale = 1.
else : scale = 1./scale
print_(scale)
tool_d = self.tools[layer][0]['diameter']*scale
r = self.options.area_inkscape_radius * scale
sign=1 if r>0 else -1
print_("Tool diameter = %s, r = %s" % (tool_d, r))
# avoiding infinite loops
if self.options.area_tool_overlap>0.9 : self.options.area_tool_overlap = .9
for i in range(self.options.max_area_curves):
radius = - tool_d * (i*(1-self.options.area_tool_overlap)+0.5) * sign
if abs(radius)>abs(r):
radius = -r
inkex.etree.SubElement( area_group, inkex.addNS('path','svg'),
{
inkex.addNS('type','sodipodi'): 'inkscape:offset',
inkex.addNS('radius','inkscape'): str(radius),
inkex.addNS('original','inkscape'): d,
'style': styles["biarc_style_i"]['area']
})
print_(("adding curve",area_group,d,styles["biarc_style_i"]['area']))
if radius == -r : break
################################################################################
###
### Polyline to biarc
###
### Converts Polyline to Biarc
################################################################################
def polyline_to_biarc(self):
def biarc(sm, depth=0):
def biarc_split(sp1,sp2, z1, z2, depth):
if depth<options.biarc_max_split_depth:
sp1,sp2,sp3 = csp_split(sp1,sp2)
l1, l2 = cspseglength(sp1,sp2), cspseglength(sp2,sp3)
if l1+l2 == 0 : zm = z1
else : zm = z1+(z2-z1)*l1/(l1+l2)
return biarc(sp1,sp2,z1,zm,depth+1)+biarc(sp2,sp3,zm,z2,depth+1)
else: return [ [sp1[1],'line', 0, 0, sp2[1], [z1,z2]] ]
P0, P4 = P(sp1[1]), P(sp2[1])
TS, TE, v = (P(sp1[2])-P0), -(P(sp2[0])-P4), P0 - P4
tsa, tea, va = TS.angle(), TE.angle(), v.angle()
if TE.mag()<straight_distance_tolerance and TS.mag()<straight_distance_tolerance:
# Both tangents are zerro - line straight
return [ [sp1[1],'line', 0, 0, sp2[1], [z1,z2]] ]
if TE.mag() < straight_distance_tolerance:
TE = -(TS+v).unit()
r = TS.mag()/v.mag()*2
elif TS.mag() < straight_distance_tolerance:
TS = -(TE+v).unit()
r = 1/( TE.mag()/v.mag()*2 )
else:
r=TS.mag()/TE.mag()
TS, TE = TS.unit(), TE.unit()
tang_are_parallel = ((tsa-tea)%math.pi<straight_tolerance or math.pi-(tsa-tea)%math.pi<straight_tolerance )
if ( tang_are_parallel and
((v.mag()<straight_distance_tolerance or TE.mag()<straight_distance_tolerance or TS.mag()<straight_distance_tolerance) or
1-abs(TS*v/(TS.mag()*v.mag()))<straight_tolerance) ):
# Both tangents are parallel and start and end are the same - line straight
# or one of tangents still smaller then tollerance
# Both tangents and v are parallel - line straight
return [ [sp1[1],'line', 0, 0, sp2[1], [z1,z2]] ]
c,b,a = v*v, 2*v*(r*TS+TE), 2*r*(TS*TE-1)
if v.mag()==0:
return biarc_split(sp1, sp2, z1, z2, depth)
asmall, bsmall, csmall = abs(a)<10**-10,abs(b)<10**-10,abs(c)<10**-10
if asmall and b!=0: beta = -c/b
elif csmall and a!=0: beta = -b/a
elif not asmall:
discr = b*b-4*a*c
if discr < 0: raise ValueError, (a,b,c,discr)
disq = discr**.5
beta1 = (-b - disq) / 2 / a
beta2 = (-b + disq) / 2 / a
if beta1*beta2 > 0 : raise ValueError, (a,b,c,disq,beta1,beta2)
beta = max(beta1, beta2)
elif asmall and bsmall:
return biarc_split(sp1, sp2, z1, z2, depth)
alpha = beta * r
ab = alpha + beta
P1 = P0 + alpha * TS
P3 = P4 - beta * TE
P2 = (beta / ab) * P1 + (alpha / ab) * P3
def calculate_arc_params(P0,P1,P2):
D = (P0+P2)/2
if (D-P1).mag()==0: return None, None
R = D - ( (D-P0).mag()**2/(D-P1).mag() )*(P1-D).unit()
p0a, p1a, p2a = (P0-R).angle()%(2*math.pi), (P1-R).angle()%(2*math.pi), (P2-R).angle()%(2*math.pi)
alpha = (p2a - p0a) % (2*math.pi)
if (p0a<p2a and (p1a<p0a or p2a<p1a)) or (p2a<p1a<p0a) :
alpha = -2*math.pi+alpha
if abs(R.x)>1000000 or abs(R.y)>1000000 or (R-P0).mag<options.min_arc_radius**2 :
return None, None
else :
return R, alpha
R1,a1 = calculate_arc_params(P0,P1,P2)
R2,a2 = calculate_arc_params(P2,P3,P4)
if R1==None or R2==None or (R1-P0).mag()<straight_tolerance or (R2-P2).mag()<straight_tolerance : return [ [sp1[1],'line', 0, 0, sp2[1], [z1,z2]] ]
d = csp_to_arc_distance(sp1,sp2, [P0,P2,R1,a1],[P2,P4,R2,a2])
if d > options.biarc_tolerance and depth<options.biarc_max_split_depth : return biarc_split(sp1, sp2, z1, z2, depth)
else:
if R2.mag()*a2 == 0 : zm = z2
else : zm = z1 + (z2-z1)*(abs(R1.mag()*a1))/(abs(R2.mag()*a2)+abs(R1.mag()*a1))
l = (P0-P2).l2()
if l < EMC_TOLERANCE_EQUAL**2 or l<EMC_TOLERANCE_EQUAL**2 * R1.l2() /100 :
# arc should be straight otherwise it could be threated as full circle
arc1 = [ sp1[1], 'line', 0, 0, [P2.x,P2.y], [z1,zm] ]
else :
arc1 = [ sp1[1], 'arc', [R1.x,R1.y], a1, [P2.x,P2.y], [z1,zm] ]
l = (P4-P2).l2()
if l < EMC_TOLERANCE_EQUAL**2 or l<EMC_TOLERANCE_EQUAL**2 * R2.l2() /100 :
# arc should be straight otherwise it could be threated as full circle
arc2 = [ [P2.x,P2.y], 'line', 0, 0, [P4.x,P4.y], [zm,z2] ]
else :
arc2 = [ [P2.x,P2.y], 'arc', [R2.x,R2.y], a2, [P4.x,P4.y], [zm,z2] ]
return [ arc1, arc2 ]
for layer in self.layers :
if layer in self.selected_paths :
for path in self.selected_paths[layer]:
d = path.get('d')
if d==None:
print_("omitting non-path")
self.error(_("Warning: omitting non-path"),"selection_contains_objects_that_are_not_paths")
continue
csp = cubicsuperpath.parsePath(d)
csp = self.apply_transforms(path, csp)
csp = self.transform_csp(csp, layer)
# lets pretend that csp is a polyline
poly = [ [point[1] for point in subpath] for subpath in csp ]
self.draw_csp([ [ [point,point,point] for point in subpoly] for subpoly in poly ],layer)
# lets create biarcs
for subpoly in poly :
# lets split polyline into different smooth parths.
if len(subpoly)>2 :
smooth = [ [subpoly[0],subpoly[1]] ]
for p1,p2,p3 in zip(subpoly,subpoly[1:],subpoly[2:]) :
# normalize p1p2 and p2p3 to get angle
s1,s2 = normalize( p1[0]-p2[0], p1[1]-p2[1]), normalize( p3[0]-p2[0], p3[1]-p2[1])
if cross(s1,s2) > corner_tolerance :
#it's an angle
smooth += [ [p2,p3] ]
else:
smooth[-1].append(p3)
for sm in smooth :
smooth_polyline_to_biarc(sm)
################################################################################
###
### Area fill
###
### Fills area with lines
################################################################################
def area_fill(self):
# convert degrees into rad
self.options.area_fill_angle = self.options.area_fill_angle * math.pi / 180
if len(self.selected_paths)<=0:
self.error(_("This extension requires at least one selected path."),"warning")
return
for layer in self.layers :
if layer in self.selected_paths :
self.set_tool(layer)
if self.tools[layer][0]['diameter']<=0 :
self.error(_("Tool diameter must be > 0 but tool's diameter on '%s' layer is not!") % layer.get(inkex.addNS('label','inkscape')),"area_tools_diameter_error")
tool = self.tools[layer][0]
for path in self.selected_paths[layer]:
lines = []
print_(("doing path", path.get("style"), path.get("d")))
area_group = inkex.etree.SubElement( path.getparent(), inkex.addNS('g','svg') )
d = path.get('d')
if d==None:
print_("omitting non-path")
self.error(_("Warning: omitting non-path"),"selection_contains_objects_that_are_not_paths")
continue
csp = cubicsuperpath.parsePath(d)
csp = self.apply_transforms(path, csp)
csp = csp_close_all_subpaths(csp)
csp = self.transform_csp(csp, layer)
#maxx = max([x,y,i,j,root],maxx)
# rotate the path to get bounds in defined direction.
a = - self.options.area_fill_angle
rotated_path = [ [ [ [point[0]*math.cos(a) - point[1]*math.sin(a), point[0]*math.sin(a)+point[1]*math.cos(a)] for point in sp] for sp in subpath] for subpath in csp ]
bounds = csp_true_bounds(rotated_path)
# Draw the lines
# Get path's bounds
b = [0.0, 0.0, 0.0, 0.0] # [minx,miny,maxx,maxy]
for k in range(4):
i, j, t = bounds[k][2], bounds[k][3], bounds[k][4]
b[k] = csp_at_t(rotated_path[i][j-1],rotated_path[i][j],t)[k%2]
# Zig-zag
r = tool['diameter']*(1-self.options.area_tool_overlap)
if r<=0 :
self.error('Tools diameter must be greater than 0!', 'error')
return
lines += [ [] ]
if self.options.area_fill_method == 'zig-zag' :
i = b[0] - self.options.area_fill_shift*r
top = True
last_one = True
while (i<b[2] or last_one) :
if i>=b[2] : last_one = False
if lines[-1] == [] :
lines[-1] += [ [i,b[3]] ]
if top :
lines[-1] += [ [i,b[1]],[i+r,b[1]] ]
else :
lines[-1] += [ [i,b[3]], [i+r,b[3]] ]
top = not top
i += r
else :
w, h = b[2]-b[0] + self.options.area_fill_shift*r , b[3]-b[1] + self.options.area_fill_shift*r
x,y = b[0] - self.options.area_fill_shift*r, b[1] - self.options.area_fill_shift*r
lines[-1] += [ [x,y] ]
stage = 0
start = True
while w>0 and h>0 :
stage = (stage+1)%4
if stage == 0 :
y -= h
h -= r
elif stage == 1:
x += w
if not start:
w -= r
start = False
elif stage == 2 :
y += h
h -= r
elif stage == 3:
x -= w
w -=r
lines[-1] += [ [x,y] ]
stage = (stage+1)%4
if w <= 0 and h>0 :
y = y-h if stage == 0 else y+h
if h <= 0 and w>0 :
x = x-w if stage == 3 else x+w
lines[-1] += [ [x,y] ]
# Rotate created paths back
a = self.options.area_fill_angle
lines = [ [ [point[0]*math.cos(a) - point[1]*math.sin(a), point[0]*math.sin(a)+point[1]*math.cos(a)] for point in subpath] for subpath in lines ]
# get the intersection points
splitted_line = [ [lines[0][0]] ]
intersections = {}
for l1,l2, in zip(lines[0],lines[0][1:]):
ints = []
if l1[0]==l2[0] and l1[1]==l2[1] : continue
for i in range(len(csp)) :
for j in range(1,len(csp[i])) :
sp1,sp2 = csp[i][j-1], csp[i][j]
roots = csp_line_intersection(l1,l2,sp1,sp2)
for t in roots :
p = tuple(csp_at_t(sp1,sp2,t))
if l1[0]==l2[0] :
t1 = (p[1]-l1[1])/(l2[1]-l1[1])
else :
t1 = (p[0]-l1[0])/(l2[0]-l1[0])
if 0<=t1<=1 :
ints += [[t1, p[0],p[1], i,j,t]]
if p in intersections :
intersections[p] += [ [i,j,t] ]
else :
intersections[p] = [ [i,j,t] ]
#p = self.transform(p,layer,True)
#draw_pointer(p)
ints.sort()
for i in ints:
splitted_line[-1] +=[ [ i[1], i[2]] ]
splitted_line += [ [ [ i[1], i[2]] ] ]
splitted_line[-1] += [ l2 ]
i = 0
print_(splitted_line)
while i < len(splitted_line) :
# check if the middle point of the first lines segment is inside the path.
# and remove the subline if not.
l1,l2 = splitted_line[i][0],splitted_line[i][1]
p = [(l1[0]+l2[0])/2, (l1[1]+l2[1])/2]
if not point_inside_csp(p, csp):
#i +=1
del splitted_line[i]
else :
i += 1
# if we've used spiral method we'll try to save the order of cutting
do_not_change_order = self.options.area_fill_method == 'spiral'
# now let's try connect splitted lines
#while len(splitted_line)>0 :
#TODO
# and apply back transrormations to draw them
csp_line = csp_from_polyline(splitted_line)
csp_line = self.transform_csp(csp_line, layer, True)
self.draw_csp(csp_line, group = area_group)
# draw_csp(lines)
################################################################################
###
### Engraving
###
#LT Notes to self: See wiki.inkscape.org/wiki/index.php/PythonEffectTutorial
# To create anything in the Inkscape document, look at the XML editor for
# details of how such an element looks in XML, then follow this model.
#layer number n appears in XML as <svg:g id="layern" inkscape:label="layername">
#
#to create it, use
#Mylayer=inkex.etree.SubElement(self.document.getroot(), 'g') #Create a generic element
#Mylayer.set(inkex.addNS('label', 'inkscape'), "layername") #Gives it a name
#Mylayer.set(inkex.addNS('groupmode', 'inkscape'), 'layer') #Tells Inkscape it's a layer
#
#group appears in XML as <svg:g id="gnnnnn"> where nnnnn is a number
#
#to create it, use
#Mygroup=inkex.etree.SubElement(parent, inkex.addNS('g','svg'), {"gcodetools":"My group label"})
# where parent may be the layer or a parent group. To get the parent group, you can use
#parent = self.selected_paths[layer][0].getparent()
################################################################################
def engraving(self) :
#global x1,y1,rx,ry
global cspm, wl
global nlLT, i, j
global gcode_3Dleft ,gcode_3Dright
global max_dist #minimum of tool radius and user's requested maximum distance
global eye_dist
eye_dist = 100 #3D constant. Try varying it for your eyes
def bisect((nx1,ny1),(nx2,ny2)) :
"""LT Find angle bisecting the normals n1 and n2
Parameters: Normalised normals
Returns: nx - Normal of bisector, normalised to 1/cos(a)
ny -
sinBis2 - sin(angle turned/2): positive if turning in
Note that bisect(n1,n2) and bisect(n2,n1) give opposite sinBis2 results
If sinturn is less than the user's requested angle tolerance, I return 0
"""
#We can get absolute value of cos(bisector vector)
#Note: Need to use max in case of rounding errors
cosBis = math.sqrt(max(0,(1.0+nx1*nx2-ny1*ny2)/2.0))
#We can get correct sign of the sin, assuming cos is positive
if (abs(ny1-ny2)< engraving_tolerance) or (abs(cosBis) < engraving_tolerance) :
if (abs(nx1-nx2)< engraving_tolerance): return(nx1,ny1,0.0)
sinBis = math.copysign(1,ny1)
else :
sinBis = cosBis*(nx2-nx1)/(ny1-ny2)
#We can correct signs by noting that the dot product
# of bisector and either normal must be >0
costurn=cosBis*nx1+sinBis*ny1
if costurn == 0 : return (ny1*100,-nx1*100,1) #Path doubles back on itself
sinturn=sinBis*nx1-cosBis*ny1
if costurn<0 : sinturn=-sinturn
if 0 < sinturn*114.6 < (180-self.options.engraving_sharp_angle_tollerance) :
sinturn=0 #set to zero if less than the user wants to see.
return (cosBis/costurn,sinBis/costurn, sinturn)
#end bisect
def get_radius_to_line((x1,y1),(nx1,ny1), (nx2,ny2),(x2,y2),(nx23,ny23),(x3,y3),(nx3,ny3)):
"""LT find biggest circle we can engrave here, if constrained by line 2-3
Parameters:
x1,y1,nx1,ny1 coordinates and normal of the line we're currently engraving
nx2,ny2 angle bisector at point 2
x2,y2 coordinates of first point of line 2-3
nx23,ny23 normal to the line 2-3
x3,y3 coordinates of the other end
nx3,ny3 angle bisector at point 3
Returns:
radius or self.options.engraving_max_dist if line doesn't limit radius
This function can be used in three ways:
- With nx1=ny1=0 it finds circle centred at x1,y1
- with nx1,ny1 normalised, it finds circle tangential at x1,y1
- with nx1,ny1 scaled by 1/cos(a) it finds circle centred on an angle bisector
where a is the angle between the bisector and the previous/next normals
If the centre of the circle tangential to the line 2-3 is outside the
angle bisectors at its ends, ignore this line.
# Note that it handles corners in the conventional manner of letter cutting
# by mitering, not rounding.
# Algorithm uses dot products of normals to find radius
# and hence coordinates of centre
"""
global max_dist
#Start by converting coordinates to be relative to x1,y1
x2,y2= x2-x1, y2-y1
x3,y3= x3-x1, y3-y1
#The logic uses vector arithmetic.
#The dot product of two vectors gives the product of their lengths
#multiplied by the cos of the angle between them.
# So, the perpendicular distance from x1y1 to the line 2-3
# is equal to the dot product of its normal and x2y2 or x3y3
#It is also equal to the projection of x1y1-xcyc on the line's normal
# plus the radius. But, as the normal faces inside the path we must negate it.
#Make sure the line in question is facing x1,y1 and vice versa
dist=-x2*nx23-y2*ny23
if dist<0 : return max_dist
denom=1.-nx23*nx1-ny23*ny1
if denom < engraving_tolerance : return max_dist
#radius and centre are:
r=dist/denom
cx=r*nx1
cy=r*ny1
#if c is not between the angle bisectors at the ends of the line, ignore
#Use vector cross products. Not sure if I need the .0001 safety margins:
if (x2-cx)*ny2 > (y2-cy)*nx2 +0.0001 :
return max_dist
if (x3-cx)*ny3 < (y3-cy)*nx3 -0.0001 :
return max_dist
return min(r, max_dist)
#end of get_radius_to_line
def get_radius_to_point((x1,y1),(nx,ny), (x2,y2)):
"""LT find biggest circle we can engrave here, constrained by point x2,y2
This function can be used in three ways:
- With nx=ny=0 it finds circle centred at x1,y1
- with nx,ny normalised, it finds circle tangential at x1,y1
- with nx,ny scaled by 1/cos(a) it finds circle centred on an angle bisector
where a is the angle between the bisector and the previous/next normals
Note that I wrote this to replace find_cutter_centre. It is far less
sophisticated but, I hope, far faster.
It turns out that finding a circle touching a point is harder than a circle
touching a line.
"""
global max_dist
#Start by converting coordinates to be relative to x1,y1
x2,y2= x2-x1, y2-y1
denom=nx**2+ny**2-1
if denom<=engraving_tolerance : #Not a corner bisector
if denom==-1 : #Find circle centre x1,y1
return math.sqrt(x2**2+y2**2)
#if x2,y2 not in front of the normal...
if x2*nx+y2*ny <=0 : return max_dist
#print_("Straight",x1,y1,nx,ny,x2,y2)
return (x2**2+y2**2)/(2*(x2*nx+y2*ny) )
#It is a corner bisector, so..
discriminator = (x2*nx+y2*ny)**2 - denom*(x2**2+y2**2)
if discriminator < 0 :
return max_dist #this part irrelevant
r=(x2*nx+y2*ny -math.sqrt(discriminator))/denom
#print_("Corner",x1,y1,nx,ny,x1+x2,y1+y2,discriminator,r)
return min(r, max_dist)
#end of get_radius_to_point
def bez_divide(a,b,c,d):
"""LT recursively divide a Bezier.
Divides until difference between each
part and a straight line is less than some limit
Note that, as simple as this code is, it is mathematically correct.
Parameters:
a,b,c and d are each a list of x,y real values
Bezier end points a and d, control points b and c
Returns:
a list of Beziers.
Each Bezier is a list with four members,
each a list holding a coordinate pair
Note that the final point of one member is the same as
the first point of the next, and the control points
there are smooth and symmetrical. I use this fact later.
"""
bx=b[0]-a[0]
by=b[1]-a[1]
cx=c[0]-a[0]
cy=c[1]-a[1]
dx=d[0]-a[0]
dy=d[1]-a[1]
limit=8*math.hypot(dx,dy)/self.options.engraving_newton_iterations
#LT This is the only limit we get from the user currently
if abs(dx*by-bx*dy)<limit and abs(dx*cy-cx*dy)<limit :
return [[a,b,c,d]]
abx=(a[0]+b[0])/2.0
aby=(a[1]+b[1])/2.0
bcx=(b[0]+c[0])/2.0
bcy=(b[1]+c[1])/2.0
cdx=(c[0]+d[0])/2.0
cdy=(c[1]+d[1])/2.0
abcx=(abx+bcx)/2.0
abcy=(aby+bcy)/2.0
bcdx=(bcx+cdx)/2.0
bcdy=(bcy+cdy)/2.0
m=[(abcx+bcdx)/2.0,(abcy+bcdy)/2.0]
return bez_divide(a,[abx,aby],[abcx,abcy],m) + bez_divide(m,[bcdx,bcdy],[cdx,cdy],d)
#end of bez_divide
def get_biggest((x1,y1),(nx,ny)):
"""LT Find biggest circle we can draw inside path at point x1,y1 normal nx,ny
Parameters:
point - either on a line or at a reflex corner
normal - normalised to 1 if on a line, to 1/cos(a) at a corner
Returns:
tuple (j,i,r)
..where j and i are indices of limiting segment, r is radius
"""
global max_dist, nlLT, i, j
n1 = nlLT[j][i-1] #current node
jjmin = -1
iimin = -1
r = max_dist
# set limits within which to look for lines
xmin, xmax = x1+r*nx-r, x1+r*nx+r
ymin, ymax = y1+r*ny-r, y1+r*ny+r
for jj in xrange(0,len(nlLT)) : #for every subpath of this object
for ii in xrange(0,len(nlLT[jj])) : #for every point and line
if nlLT[jj][ii-1][2] : #if a point
if jj==j : #except this one
if abs(ii-i)<3 or abs(ii-i)>len(nlLT[j])-3 : continue
t1=get_radius_to_point((x1,y1),(nx,ny),nlLT[jj][ii-1][0] )
#print_("Try pt i,ii,t1,x1,y1",i,ii,t1,x1,y1)
else: #doing a line
if jj==j : #except this one
if abs(ii-i)<2 or abs(ii-i)==len(nlLT[j])-1 : continue
if abs(ii-i)==2 and nlLT[j][(ii+i)/2-1][3]<=0 : continue
if (abs(ii-i)==len(nlLT[j])-2) and nlLT[j][-1][3]<=0 : continue
nx2,ny2 = nlLT[jj][ii-2][1]
x2,y2 = nlLT[jj][ii-1][0]
nx23,ny23 = nlLT[jj][ii-1][1]
x3,y3 = nlLT[jj][ii][0]
nx3,ny3 = nlLT[jj][ii][1]
if nlLT[jj][ii-2][3]>0 : #acute, so use normal, not bisector
nx2=nx23
ny2=ny23
if nlLT[jj][ii][3]>0 : #acute, so use normal, not bisector
nx3=nx23
ny3=ny23
x23min,x23max=min(x2,x3),max(x2,x3)
y23min,y23max=min(y2,y3),max(y2,y3)
#see if line in range
if n1[2]==False and (x23max<xmin or x23min>xmax or y23max<ymin or y23min>ymax) : continue
t1=get_radius_to_line((x1,y1),(nx,ny), (nx2,ny2),(x2,y2),(nx23,ny23), (x3,y3),(nx3,ny3))
#print_("Try line i,ii,t1,x1,y1",i,ii,t1,x1,y1)
if 0<=t1<r :
r = t1
iimin = ii
jjmin = jj
xmin, xmax = x1+r*nx-r, x1+r*nx+r
ymin, ymax = y1+r*ny-r, y1+r*ny+r
#next ii
#next jj
return (jjmin,iimin,r)
#end of get_biggest
def line_divide((x0,y0),j0,i0,(x1,y1),j1,i1,(nx,ny),length):
"""LT recursively divide a line as much as necessary
NOTE: This function is not currently used
By noting which other path segment is touched by the circles at each end,
we can see if anything is to be gained by a further subdivision, since
if they touch the same bit of path we can move linearly between them.
Also, we can handle points correctly.
Parameters:
end points and indices of limiting path, normal, length
Returns:
list of toolpath points
each a list of 3 reals: x, y coordinates, radius
"""
global nlLT, i, j, lmin
x2=(x0+x1)/2
y2=(y0+y1)/2
j2,i2,r2=get_biggest( (x2,y2), (nx,ny))
if length<lmin : return [ [x2, y2, r2] ]
if j2==j0 and i2==i0 : #Same as left end. Don't subdivide this part any more
return [ [x2, y2, r2], line_divide((x2,y2),j2,i2,(x1,y1),j1,i1,(nx,ny),length/2)]
if j2==j1 and i2==i1 : #Same as right end. Don't subdivide this part any more
return [ line_divide((x0,y0),j0,i0,(x2,y2),j2,i2,(nx,ny),length/2), [x2, y2, r2] ]
return [ line_divide((x0,y0),j0,i0,(x2,y2),j2,i2,(nx,ny),length/2), line_divide((x2,y2),j2,i2,(x1,y1),j1,i1,(nx,ny),length/2)]
#end of line_divide()
def save_point((x,y),w,i,j,ii,jj):
"""LT Save this point and delete previous one if linear
The point is, we generate tons of points but many may be in a straight 3D line.
There is no benefit in saving the imtermediate points.
"""
global wl, cspm
x=round(x,4) #round to 4 decimals
y=round(y,4) #round to 4 decimals
w=round(w,4) #round to 4 decimals
if len(cspm)>1 :
xy1a,xy1,xy1b,i1,j1,ii1,jj1=cspm[-1]
w1=wl[-1]
if i==i1 and j==j1 and ii==ii1 and jj==jj1 : #one match
xy1a,xy2,xy1b,i1,j1,ii1,jj1=cspm[-2]
w2=wl[-2]
if i==i1 and j==j1 and ii==ii1 and jj==jj1 : #two matches. Now test linearity
length1=math.hypot(xy1[0]-x,xy1[1]-y)
length2=math.hypot(xy2[0]-x,xy2[1]-y)
length12=math.hypot(xy2[0]-xy1[0],xy2[1]-xy1[1])
#get the xy distance of point 1 from the line 0-2
if length2>length1 and length2>length12 : #point 1 between them
xydist=abs( (xy2[0]-x)*(xy1[1]-y)-(xy1[0]-x)*(xy2[1]-y) )/length2
if xydist<engraving_tolerance : #so far so good
wdist=w2+(w-w2)*length1/length2 -w1
if abs(wdist)<engraving_tolerance :
#print_("pop",j,i,xy1)
cspm.pop()
wl.pop()
cspm+=[ [ [x,y],[x,y],[x,y],i,j,ii,jj ] ]
wl+=[w]
#end of save_point
def draw_point((x0,y0),(x,y),w,t):
"""LT Draw this point as a circle with a 1px dot in the middle (x,y)
and a 3D line from (x0,y0) down to x,y. 3D line thickness should be t/2
Note that points that are subsequently erased as being unneeded do get
displayed, but this helps the user see the total area covered.
"""
global gcode_3Dleft ,gcode_3Dright
if self.options.engraving_draw_calculation_paths :
inkex.etree.SubElement( engraving_group, inkex.addNS('path','svg'),
{"gcodetools": "Engraving calculation toolpath", 'style': "fill:#ff00ff; fill-opacity:0.46; stroke:#000000; stroke-width:0.1;", inkex.addNS('cx','sodipodi'): str(x), inkex.addNS('cy','sodipodi'): str(y), inkex.addNS('rx','sodipodi'): str(1), inkex.addNS('ry','sodipodi'): str(1), inkex.addNS('type','sodipodi'): 'arc'})
#Don't draw zero radius circles
if w:
inkex.etree.SubElement( engraving_group, inkex.addNS('path','svg'),
{"gcodetools": "Engraving calculation paths", 'style': "fill:none; fill-opacity:0.46; stroke:#000000; stroke-width:0.1;", inkex.addNS('cx','sodipodi'): str(x), inkex.addNS('cy','sodipodi'): str(y),inkex.addNS('rx','sodipodi'): str(w), inkex.addNS('ry','sodipodi'): str(w), inkex.addNS('type','sodipodi'): 'arc'})
# Find slope direction for shading
s=math.atan2(y-y0,x-x0) #-pi to pi
# convert to 2 hex digits as a shade of red
s2="#{0:x}0000".format(int(101*(1.5-math.sin(s+0.5))))
inkex.etree.SubElement( gcode_3Dleft , inkex.addNS('path','svg'),
{ "d": "M %f,%f L %f,%f" %(x0-eye_dist,y0,x-eye_dist-0.14*w,y),
'style': "stroke:" + s2 + "; stroke-opacity:1; stroke-width:" + str(t/2) +" ; fill:none",
"gcodetools": "Gcode G1R"
})
inkex.etree.SubElement( gcode_3Dright , inkex.addNS('path','svg'),
{ "d": "M %f,%f L %f,%f" %(x0+eye_dist,y0,x+eye_dist+0.14*r,y),
'style': "stroke:" + s2 + "; stroke-opacity:1; stroke-width:" + str(t/2) +" ; fill:none",
"gcodetools": "Gcode G1L"
})
#end of draw_point
#end of subfunction definitions. engraving() starts here:
gcode = ''
r,w, wmax = 0,0,0 #theoretical and tool-radius-limited radii in pixels
x1,y1,nx,ny =0,0,0,0
cspe =[]
we = []
if len(self.selected_paths)<=0:
self.error(_("Please select at least one path to engrave and run again."),"warning")
return
if not self.check_dir() : return
#Find what units the user uses
unit=" mm"
if self.options.unit == "G20 (All units in inches)" :
unit=" inches"
elif self.options.unit != "G21 (All units in mm)" :
self.error(_("Unknown unit selected. mm assumed"),"warning")
print_("engraving_max_dist mm/inch", self.options.engraving_max_dist )
#LT See if we can use this parameter for line and Bezier subdivision:
bitlen=20/self.options.engraving_newton_iterations
for layer in self.layers :
if layer in self.selected_paths :
#Calculate scale in pixels per user unit (mm or inch)
p1=self.orientation_points[layer][0][0]
p2=self.orientation_points[layer][0][1]
ol=math.hypot(p1[0][0]-p2[0][0],p1[0][1]-p2[0][1])
oluu=math.hypot(p1[1][0]-p2[1][0],p1[1][1]-p2[1][1])
print_("Orientation2 p1 p2 ol oluu",p1,p2,ol,oluu)
orientation_scale = ol/oluu
self.set_tool(layer)
shape = self.tools[layer][0]['shape']
if re.search('w', shape) :
toolshape = eval('lambda w: ' + shape.strip('"'))
else:
self.error(_("Tool '%s' has no shape. 45 degree cone assumed!") % self.tools[layer][0]['name'],"Continue")
toolshape = lambda w: w
#Get tool radius in pixels
toolr=self.tools[layer][0]['diameter'] * orientation_scale/2
print_("tool radius in pixels=", toolr)
#max dist from path to engrave in user's units
max_distuu = min(self.tools[layer][0]['diameter']/2, self.options.engraving_max_dist)
max_dist=max_distuu*orientation_scale
print_("max_dist pixels", max_dist )
engraving_group = inkex.etree.SubElement( self.selected_paths[layer][0].getparent(), inkex.addNS('g','svg') )
if self.options.engraving_draw_calculation_paths and (self.my3Dlayer == None) :
self.my3Dlayer=inkex.etree.SubElement(self.document.getroot(), 'g') #Create a generic element at root level
self.my3Dlayer.set(inkex.addNS('label', 'inkscape'), "3D") #Gives it a name
self.my3Dlayer.set(inkex.addNS('groupmode', 'inkscape'), 'layer') #Tells Inkscape it's a layer
#Create groups for left and right eyes
if self.options.engraving_draw_calculation_paths :
gcode_3Dleft = inkex.etree.SubElement(self.my3Dlayer, inkex.addNS('g','svg'), {"gcodetools":"Gcode 3D L"})
gcode_3Dright = inkex.etree.SubElement(self.my3Dlayer, inkex.addNS('g','svg'), {"gcodetools":"Gcode 3D R"})
for node in self.selected_paths[layer] :
if node.tag == inkex.addNS('path','svg'):
cspi = cubicsuperpath.parsePath(node.get('d'))
#LT: Create my own list. n1LT[j] is for subpath j
nlLT = []
for j in xrange(len(cspi)): #LT For each subpath...
# Remove zero length segments, assume closed path
i = 0 #LT was from i=1
while i<len(cspi[j]):
if abs(cspi[j][i-1][1][0]-cspi[j][i][1][0])<engraving_tolerance and abs(cspi[j][i-1][1][1]-cspi[j][i][1][1])<engraving_tolerance:
cspi[j][i-1][2] = cspi[j][i][2]
del cspi[j][i]
else:
i += 1
for csp in cspi: #LT6a For each subpath...
#Create copies in 3D layer
print_("csp is zz ",csp)
cspl=[]
cspr=[]
#create list containing lines and points, starting with a point
# line members: [x,y],[nx,ny],False,i
# x,y is start of line. Normal on engraved side.
# Normal is normalised (unit length)
#Note that Y axis increases down the page
# corner members: [x,y],[nx,ny],True,sin(halfangle)
# if halfangle>0: radius 0 here. normal is bisector
# if halfangle<0. reflex angle. normal is bisector
# corner normals are divided by cos(halfangle)
#so that they will engrave correctly
print_("csp is",csp)
nlLT.append ([])
for i in range(0,len(csp)): #LT for each point
#n = []
sp0, sp1, sp2 = csp[i-2], csp[i-1], csp[i]
if self.options.engraving_draw_calculation_paths:
#Copy it to 3D layer objects
spl=[]
spr=[]
for j in range(0,3) :
pl=[sp2[j][0]-eye_dist,sp2[j][1]]
pr=[sp2[j][0]+eye_dist,sp2[j][1]]
spl+=[pl]
spr+=[pr]
cspl+=[spl]
cspr+=[spr]
#LT find angle between this and previous segment
x0,y0 = sp1[1]
nx1,ny1 = csp_normalized_normal(sp1,sp2,0)
#I don't trust this function, so test result
if abs(1-math.hypot(nx1,ny1))> 0.00001 :
print_("csp_normalised_normal error t=0",nx1,ny1,sp1,sp2)
self.error(_("csp_normalised_normal error. See log."),"warning")
nx0, ny0 = csp_normalized_normal(sp0,sp1,1)
if abs(1-math.hypot(nx0,ny0))> 0.00001 :
print_("csp_normalised_normal error t=1",nx0,ny0,sp1,sp2)
self.error(_("csp_normalised_normal error. See log."),"warning")
bx,by,s=bisect((nx0,ny0),(nx1,ny1))
#record x,y,normal,ifCorner, sin(angle-turned/2)
nlLT[-1] += [[ [x0,y0],[bx,by], True, s]]
#LT now do the line
if sp1[1]==sp1[2] and sp2[0]==sp2[1] : #straightline
nlLT[-1]+=[[sp1[1],[nx1,ny1],False,i]]
else : #Bezier. First, recursively cut it up:
nn=bez_divide(sp1[1],sp1[2],sp2[0],sp2[1])
first=True #Flag entry to divided Bezier
for bLT in nn : #save as two line segments
for seg in range(3) :
if seg>0 or first :
nx1=bLT[seg][1]-bLT[seg+1][1]
ny1=bLT[seg+1][0]-bLT[seg][0]
l1=math.hypot(nx1,ny1)
if l1<engraving_tolerance :
continue
nx1=nx1/l1 #normalise them
ny1=ny1/l1
nlLT[-1]+=[[bLT[seg],[nx1,ny1], False,i]]
first=False
if seg<2 : #get outgoing bisector
nx0=nx1
ny0=ny1
nx1=bLT[seg+1][1]-bLT[seg+2][1]
ny1=bLT[seg+2][0]-bLT[seg+1][0]
l1=math.hypot(nx1,ny1)
if l1<engraving_tolerance :
continue
nx1=nx1/l1 #normalise them
ny1=ny1/l1
#bisect
bx,by,s=bisect((nx0,ny0),(nx1,ny1))
nlLT[-1] += [[bLT[seg+1],[bx,by], True, 0.]]
#LT for each segment - ends here.
print_(("engraving_draw_calculation_paths=",self.options.engraving_draw_calculation_paths))
if self.options.engraving_draw_calculation_paths:
#Copy complete paths to 3D layer
#print_("cspl",cspl)
cspl+=[cspl[0]] #Close paths
cspr+=[cspr[0]] #Close paths
inkex.etree.SubElement( gcode_3Dleft , inkex.addNS('path','svg'),
{ "d": cubicsuperpath.formatPath([cspl]),
'style': "stroke:#808080; stroke-opacity:1; stroke-width:0.6; fill:none",
"gcodetools": "G1L outline"
})
inkex.etree.SubElement( gcode_3Dright , inkex.addNS('path','svg'),
{ "d": cubicsuperpath.formatPath([cspr]),
'style': "stroke:#808080; stroke-opacity:1; stroke-width:0.6; fill:none",
"gcodetools": "G1L outline"
})
for p in nlLT[-1]: #For last sub-path
if p[2]: inkex.etree.SubElement( engraving_group, inkex.addNS('path','svg'),
{ "d": "M %f,%f L %f,%f" %(p[0][0],p[0][1],p[0][0]+p[1][0]*10,p[0][1]+p[1][1]*10),
'style': "stroke:#f000af; stroke-opacity:0.46; stroke-width:0.1; fill:none",
"gcodetools": "Engraving normals"
})
else: inkex.etree.SubElement( engraving_group, inkex.addNS('path','svg'),
{ "d": "M %f,%f L %f,%f" %(p[0][0],p[0][1],p[0][0]+p[1][0]*10,p[0][1]+p[1][1]*10),
'style': "stroke:#0000ff; stroke-opacity:0.46; stroke-width:0.1; fill:none",
"gcodetools": "Engraving bisectors"
})
#LT6a build nlLT[j] for each subpath - ends here
#for nnn in nlLT :
#print_("nlLT",nnn) #LT debug stuff
# Calculate offset points
reflex=False
for j in xrange(len(nlLT)): #LT6b for each subpath
cspm=[] #Will be my output. List of csps.
wl=[] #Will be my w output list
w = r = 0 #LT initial, as first point is an angle
for i in xrange(len(nlLT[j])) : #LT for each node
#LT Note: Python enables wrapping of array indices
# backwards to -1, -2, but not forwards. Hence:
n0 = nlLT[j][i-2] #previous node
n1 = nlLT[j][i-1] #current node
n2 = nlLT[j][i] #next node
#if n1[2] == True and n1[3]==0 : # A straight angle
#continue
x1a,y1a = n1[0] #this point/start of this line
nx,ny = n1[1]
x1b,y1b = n2[0] #next point/end of this line
if n1[2] == True : # We're at a corner
bits=1
bit0=0
#lastr=r #Remember r from last line
lastw=w #Remember w from last line
w = max_dist
if n1[3]>0 : #acute. Limit radius
len1=math.hypot( (n0[0][0]-n1[0][0]),( n0[0][1]-n1[0][1]) )
if i<(len(nlLT[j])-1) :
len2=math.hypot( (nlLT[j][i+1][0][0]-n1[0][0]),(nlLT[j][i+1][0][1]-n1[0][1]) )
else:
len2=math.hypot( (nlLT[j][0][0][0]-n1[0][0]),(nlLT[j][0][0][1]-n1[0][1]) )
#set initial r value, not to be exceeded
w = math.sqrt(min(len1,len2))/n1[3]
else: #line. Cut it up if long.
if n0[3]>0 and not self.options.engraving_draw_calculation_paths :
bit0=r*n0[3] #after acute corner
else : bit0=0.0
length=math.hypot((x1b-x1a),(y1a-y1b))
bit0=(min(length,bit0))
bits=int((length-bit0)/bitlen)
#split excess evenly at both ends
bit0+=(length-bit0-bitlen*bits)/2
#print_("j,i,r,bit0,bits",j,i,w,bit0,bits)
for b in xrange(bits) : #divide line into bits
x1=x1a+ny*(b*bitlen+bit0)
y1=y1a-nx*(b*bitlen+bit0)
jjmin,iimin,w=get_biggest( (x1,y1), (nx,ny))
print_("i,j,jjmin,iimin,w",i,j,jjmin,iimin,w)
#w = min(r, toolr)
wmax=max(wmax,w)
if reflex : #just after a reflex corner
reflex = False
if w<lastw : #need to adjust it
draw_point((x1,y1),(n0[0][0]+n0[1][0]*w,n0[0][1]+n0[1][1]*w),w, (lastw-w)/2)
save_point((n0[0][0]+n0[1][0]*w,n0[0][1]+n0[1][1]*w),w,i,j,iimin,jjmin)
if n1[2] == True : # We're at a corner
if n1[3]>0 : #acute
save_point((x1+nx*w,y1+ny*w),w,i,j,iimin,jjmin)
draw_point((x1,y1),(x1,y1),0,0)
save_point((x1,y1),0,i,j,iimin,jjmin)
elif n1[3]<0 : #reflex
if w>lastw :
draw_point((x1,y1),(x1+nx*lastw,y1+ny*lastw),w, (w-lastw)/2)
wmax=max(wmax,w)
save_point((x1+nx*w,y1+ny*w),w,i,j,iimin,jjmin)
elif b>0 and n2[3]>0 and not self.options.engraving_draw_calculation_paths : #acute corner coming up
if jjmin==j and iimin==i+2 : break
draw_point((x1,y1),(x1+nx*w,y1+ny*w),w, bitlen)
save_point((x1+nx*w,y1+ny*w),w,i,j,iimin,jjmin)
#LT end of for each bit of this line
if n1[2] == True and n1[3]<0 : #reflex angle
reflex=True
lastw = w #remember this w
#LT next i
cspm+=[cspm[0]]
print_("cspm",cspm)
wl+=[wl[0]]
print_("wl",wl)
#Note: Original csp_points was a list, each element
#being 4 points, with the first being the same as the
#last of the previous set.
#Each point is a list of [cx,cy,r,w]
#I have flattened it to a flat list of points.
if self.options.engraving_draw_calculation_paths==True:
node = inkex.etree.SubElement( engraving_group, inkex.addNS('path','svg'), {
"d": cubicsuperpath.formatPath([cspm]),
'style': styles["biarc_style_i"]['biarc1'],
"gcodetools": "Engraving calculation paths",
})
for i in xrange(len(cspm)):
inkex.etree.SubElement( engraving_group, inkex.addNS('path','svg'),
{"gcodetools": "Engraving calculation paths", 'style': "fill:none; fill-opacity:0.46; stroke:#000000; stroke-width:0.1;", inkex.addNS('cx','sodipodi'): str(cspm[i][1][0]), inkex.addNS('cy','sodipodi'): str(cspm[i][1][1]),inkex.addNS('rx','sodipodi'): str(wl[i]), inkex.addNS('ry','sodipodi'): str(wl[i]), inkex.addNS('type','sodipodi'): 'arc'})
cspe += [cspm]
wluu = [] #width list in user units: mm/inches
for w in wl :
wluu+=[ w / orientation_scale ]
print_("wl in pixels",wl)
print_("wl in user units",wluu)
#LT previously, we was in pixels so gave wrong depth
we += [wluu]
#LT6b For each subpath - ends here
#LT5 if it is a path - ends here
#print_("cspe",cspe)
#print_("we",we)
#LT4 for each selected object in this layer - ends here
if cspe!=[]:
curve = self.parse_curve(cspe, layer, we, toolshape) #convert to lines
self.draw_curve(curve, layer, engraving_group)
gcode += self.generate_gcode(curve, layer, self.options.Zsurface)
#LT3 for layers loop ends here
if gcode!='' :
self.header+="(Tool diameter should be at least "+str(2*wmax/orientation_scale)+unit+ ")\n"
self.header+="(Depth, as a function of radius w, must be "+ self.tools[layer][0]['shape']+ ")\n"
self.header+="(Rapid feeds use safe Z="+ str(self.options.Zsafe) + unit + ")\n"
self.header+="(Material surface at Z="+ str(self.options.Zsurface) + unit + ")\n"
self.export_gcode(gcode)
else : self.error(_("No need to engrave sharp angles."),"warning")
################################################################################
###
### Orientation
###
################################################################################
def orientation(self, layer=None) :
if layer == None :
layer = self.current_layer if self.current_layer is not None else self.document.getroot()
transform = self.get_transforms(layer)
if transform != [] :
transform = self.reverse_transform(transform)
transform = simpletransform.formatTransform(transform)
if self.options.orientation_points_count == "graffiti" :
print_(self.graffiti_reference_points)
print_("Inserting graffiti points")
if layer in self.graffiti_reference_points: graffiti_reference_points_count = len(self.graffiti_reference_points[layer])
else: graffiti_reference_points_count = 0
axis = ["X","Y","Z","A"][graffiti_reference_points_count%4]
attr = {'gcodetools': "Gcodetools graffiti reference point"}
if transform != [] :
attr["transform"] = transform
g = inkex.etree.SubElement(layer, inkex.addNS('g','svg'), attr)
inkex.etree.SubElement( g, inkex.addNS('path','svg'),
{
'style': "stroke:none;fill:#00ff00;",
'd':'m %s,%s 2.9375,-6.343750000001 0.8125,1.90625 6.843748640396,-6.84374864039 0,0 0.6875,0.6875 -6.84375,6.84375 1.90625,0.812500000001 z z' % (graffiti_reference_points_count*100, 0),
'gcodetools': "Gcodetools graffiti reference point arrow"
})
draw_text(axis,graffiti_reference_points_count*100+10,-10, group = g, gcodetools_tag = "Gcodetools graffiti reference point text")
elif self.options.orientation_points_count == "in-out reference point" :
draw_pointer(group = self.current_layer, x = self.view_center, figure="arrow", pointer_type = "In-out reference point", text = "In-out point")
else :
print_("Inserting orientation points")
if layer in self.orientation_points:
self.error(_("Active layer already has orientation points! Remove them or select another layer!"),"active_layer_already_has_orientation_points")
attr = {"gcodetools":"Gcodetools orientation group"}
if transform != [] :
attr["transform"] = transform
orientation_group = inkex.etree.SubElement(layer, inkex.addNS('g','svg'), attr)
doc_height = self.unittouu(self.document.getroot().get('height'))
if self.document.getroot().get('height') == "100%" :
doc_height = 1052.3622047
print_("Overruding height from 100 percents to %s" % doc_height)
if self.options.unit == "G21 (All units in mm)" :
points = [[0.,0.,self.options.Zsurface],[100.,0.,self.options.Zdepth],[0.,100.,0.]]
orientation_scale = 3.5433070660
print_("orientation_scale < 0 ===> switching to mm units=%0.10f"%orientation_scale )
elif self.options.unit == "G20 (All units in inches)" :
points = [[0.,0.,self.options.Zsurface],[5.,0.,self.options.Zdepth],[0.,5.,0.]]
orientation_scale = 90
print_("orientation_scale < 0 ===> switching to inches units=%0.10f"%orientation_scale )
if self.options.orientation_points_count == "2" :
points = points[:2]
print_(("using orientation scale",orientation_scale,"i=",points))
for i in points :
si = [i[0]*orientation_scale, i[1]*orientation_scale]
g = inkex.etree.SubElement(orientation_group, inkex.addNS('g','svg'), {'gcodetools': "Gcodetools orientation point (%s points)" % self.options.orientation_points_count})
inkex.etree.SubElement( g, inkex.addNS('path','svg'),
{
'style': "stroke:none;fill:#000000;",
'd':'m %s,%s 2.9375,-6.343750000001 0.8125,1.90625 6.843748640396,-6.84374864039 0,0 0.6875,0.6875 -6.84375,6.84375 1.90625,0.812500000001 z z' % (si[0], -si[1]+doc_height),
'gcodetools': "Gcodetools orientation point arrow"
})
draw_text("(%s; %s; %s)" % (i[0],i[1],i[2]), (si[0]+10), (-si[1]-10+doc_height), group = g, gcodetools_tag = "Gcodetools orientation point text")
################################################################################
###
### Tools library
###
################################################################################
def tools_library(self, layer=None) :
# Add a tool to the drawing
if layer == None :
layer = self.current_layer if self.current_layer is not None else self.document.getroot()
if layer in self.tools:
self.error(_("Active layer already has a tool! Remove it or select another layer!"),"active_layer_already_has_tool")
if self.options.tools_library_type == "cylinder cutter" :
tool = {
"name": "Cylindrical cutter",
"id": "Cylindrical cutter 0001",
"diameter":10,
"penetration angle":90,
"feed":"400",
"penetration feed":"100",
"depth step":"1",
"tool change gcode":" "
}
elif self.options.tools_library_type == "lathe cutter" :
tool = {
"name": "Lathe cutter",
"id": "Lathe cutter 0001",
"diameter":10,
"penetration angle":90,
"feed":"400",
"passing feed":"800",
"fine feed":"100",
"penetration feed":"100",
"depth step":"1",
"tool change gcode":" "
}
elif self.options.tools_library_type == "cone cutter":
tool = {
"name": "Cone cutter",
"id": "Cone cutter 0001",
"diameter":10,
"shape":"w",
"feed":"400",
"penetration feed":"100",
"depth step":"1",
"tool change gcode":" "
}
elif self.options.tools_library_type == "tangent knife":
tool = {
"name": "Tangent knife",
"id": "Tangent knife 0001",
"feed":"400",
"penetration feed":"100",
"depth step":"100",
"4th axis meaning": "tangent knife",
"4th axis scale": 1.,
"4th axis offset": 0,
"tool change gcode":" "
}
elif self.options.tools_library_type == "plasma cutter":
tool = {
"name": "Plasma cutter",
"id": "Plasma cutter 0001",
"diameter":10,
"penetration feed":100,
"feed":400,
"gcode before path":"""G31 Z-100 F500 (find metal)
G92 Z0 (zero z)
G00 Z10 F500 (going up)
M03 (turn on plasma)
G04 P0.2 (pause)
G01 Z1 (going to cutting z)\n""",
"gcode after path":"M05 (turn off plasma)\n",
}
elif self.options.tools_library_type == "graffiti":
tool = {
"name": "Graffiti",
"id": "Graffiti 0001",
"diameter":10,
"penetration feed":100,
"feed":400,
"gcode before path":"""M03 S1(Turn spray on)\n """,
"gcode after path":"M05 (Turn spray off)\n ",
"tool change gcode":"(Add G00 here to change sprayer if needed)\n",
}
else :
tool = self.default_tool
tool_num = sum([len(self.tools[i]) for i in self.tools])
colors = ["00ff00","0000ff","ff0000","fefe00","00fefe", "fe00fe", "fe7e00", "7efe00", "00fe7e", "007efe", "7e00fe", "fe007e"]
tools_group = inkex.etree.SubElement(layer, inkex.addNS('g','svg'), {'gcodetools': "Gcodetools tool definition"})
bg = inkex.etree.SubElement( tools_group, inkex.addNS('path','svg'),
{'style': "fill:#%s;fill-opacity:0.5;stroke:#444444; stroke-width:1px;"%colors[tool_num%len(colors)], "gcodetools":"Gcodetools tool background"})
y = 0
keys = []
for key in self.tools_field_order:
if key in tool: keys += [key]
for key in tool:
if key not in keys: keys += [key]
for key in keys :
g = inkex.etree.SubElement(tools_group, inkex.addNS('g','svg'), {'gcodetools': "Gcodetools tool parameter"})
draw_text(key, 0, y, group = g, gcodetools_tag = "Gcodetools tool definition field name", font_size = 10 if key!='name' else 20)
param = tool[key]
if type(param)==str and re.match("^\s*$",param) : param = "(None)"
draw_text(param, 150, y, group = g, gcodetools_tag = "Gcodetools tool definition field value", font_size = 10 if key!='name' else 20)
v = str(param).split("\n")
y += 15*len(v) if key!='name' else 20*len(v)
bg.set('d',"m -20,-20 l 400,0 0,%f -400,0 z " % (y+50))
tool = []
tools_group.set("transform", simpletransform.formatTransform([ [1,0,self.view_center[0]-150 ], [0,1,self.view_center[1]] ] ))
################################################################################
###
### Check tools and OP asignment
###
################################################################################
def check_tools_and_op(self):
if len(self.selected)<=0 :
self.error(_("Selection is empty! Will compute whole drawing."),"selection_is_empty_will_comupe_drawing")
paths = self.paths
else :
paths = self.selected_paths
# Set group
group = inkex.etree.SubElement( self.selected_paths.keys()[0] if len(self.selected_paths.keys())>0 else self.layers[0], inkex.addNS('g','svg') )
trans_ = [[1,0.3,0],[0,0.5,0]]
self.set_markers()
bounds = [float('inf'),float('inf'),float('-inf'),float('-inf')]
tools_bounds = {}
for layer in self.layers :
if layer in paths :
self.set_tool(layer)
tool = self.tools[layer][0]
tools_bounds[layer] = tools_bounds[layer] if layer in tools_bounds else [float("inf"),float("-inf")]
style = simplestyle.formatStyle(tool["style"])
for path in paths[layer] :
style = "fill:%s; fill-opacity:%s; stroke:#000044; stroke-width:1; marker-mid:url(#CheckToolsAndOPMarker);" % (
tool["style"]["fill"] if "fill" in tool["style"] else "#00ff00",
tool["style"]["fill-opacity"] if "fill-opacity" in tool["style"] else "0.5")
group.insert( 0, inkex.etree.Element(path.tag, path.attrib))
new = group.getchildren()[0]
new.set("style", style)
trans = self.get_transforms(path)
trans = simpletransform.composeTransform( trans_, trans if trans != [] else [[1.,0.,0.],[0.,1.,0.]])
csp = cubicsuperpath.parsePath(path.get("d"))
simpletransform.applyTransformToPath(trans,csp)
path_bounds = csp_simple_bound(csp)
trans = simpletransform.formatTransform(trans)
bounds = [min(bounds[0],path_bounds[0]), min(bounds[1],path_bounds[1]), max(bounds[2],path_bounds[2]), max(bounds[3],path_bounds[3])]
tools_bounds[layer] = [min(tools_bounds[layer][0], path_bounds[1]), max(tools_bounds[layer][1], path_bounds[3])]
new.set("transform", trans)
trans_[1][2] += 20
trans_[1][2] += 100
for layer in self.layers :
if layer in self.tools :
if layer in tools_bounds :
tool = self.tools[layer][0]
g = copy.deepcopy(tool["self_group"])
g.attrib["gcodetools"] = "Check tools and OP asignment"
trans = [[1,0.3,bounds[2]],[0,0.5,tools_bounds[layer][0]]]
g.set("transform",simpletransform.formatTransform(trans))
group.insert( 0, g )
################################################################################
### TODO Launch browser on help tab
################################################################################
def help(self):
self.error(_("""Tutorials, manuals and support can be found at\nEnglish support forum:\n http://www.cnc-club.ru/gcodetools\nand Russian support forum:\n http://www.cnc-club.ru/gcodetoolsru"""),"warning")
return
################################################################################
### Lathe
################################################################################
def generate_lathe_gcode(self, subpath, layer, feed_type) :
if len(subpath) <2 : return ""
feed = " F %f" % self.tool[feed_type]
x,z = self.options.lathe_x_axis_remap, self.options.lathe_z_axis_remap
flip_angle = -1 if x.lower()+z.lower() in ["xz", "yx", "zy"] else 1
alias = {"X":"I", "Y":"J", "Z":"K", "x":"i", "y":"j", "z":"k"}
i_, k_ = alias[x], alias[z]
c = [ [subpath[0][1], "move", 0, 0, 0] ]
#draw_csp(self.transform_csp([subpath],layer,True), color = "Orange", width = .1)
for sp1,sp2 in zip(subpath,subpath[1:]) :
c += biarc(sp1,sp2,0,0)
for i in range(1,len(c)) : # Just in case check end point of each segment
c[i-1][4] = c[i][0][:]
c += [ [subpath[-1][1], "end", 0, 0, 0] ]
self.draw_curve(c, layer, style = styles["biarc_style_lathe_%s" % feed_type])
gcode = ("G01 %s %f %s %f" % (x, c[0][4][0], z, c[0][4][1]) ) + feed + "\n" # Just in case move to the start...
for s in c :
if s[1] == 'line':
gcode += ("G01 %s %f %s %f" % (x, s[4][0], z, s[4][1]) ) + feed + "\n"
elif s[1] == 'arc':
r = [(s[2][0]-s[0][0]), (s[2][1]-s[0][1])]
if (r[0]**2 + r[1]**2)>self.options.min_arc_radius**2:
r1, r2 = (P(s[0])-P(s[2])), (P(s[4])-P(s[2]))
if abs(r1.mag()-r2.mag()) < 0.001 :
gcode += ("G02" if s[3]*flip_angle<0 else "G03") + (" %s %f %s %f %s %f %s %f" % (x,s[4][0],z,s[4][1],i_,(s[2][0]-s[0][0]), k_, (s[2][1]-s[0][1]) ) ) + feed + "\n"
else:
r = (r1.mag()+r2.mag())/2
gcode += ("G02" if s[3]*flip_angle<0 else "G03") + (" %s %f %s %f" % (x,s[4][0],z,y[4][1]) ) + " R%f"%r + feed + "\n"
return gcode
def lathe(self):
if not self.check_dir() : return
x,z = self.options.lathe_x_axis_remap, self.options.lathe_z_axis_remap
x = re.sub("^\s*([XYZxyz])\s*$",r"\1",x)
z = re.sub("^\s*([XYZxyz])\s*$",r"\1",z)
if x not in ["X", "Y", "Z", "x", "y", "z"] or z not in ["X", "Y", "Z", "x", "y", "z"] :
self.error(_("Lathe X and Z axis remap should be 'X', 'Y' or 'Z'. Exiting..."),"warning")
return
if x.lower() == z.lower() :
self.error(_("Lathe X and Z axis remap should be the same. Exiting..."),"warning")
return
if x.lower()+z.lower() in ["xy","yx"] : gcode_plane_selection = "G17 (Using XY plane)\n"
if x.lower()+z.lower() in ["xz","zx"] : gcode_plane_selection = "G18 (Using XZ plane)\n"
if x.lower()+z.lower() in ["zy","yz"] : gcode_plane_selection = "G19 (Using YZ plane)\n"
self.options.lathe_x_axis_remap, self.options.lathe_z_axis_remap = x, z
paths = self.selected_paths
self.tool = []
gcode = ""
for layer in self.layers :
if layer in paths :
self.set_tool(layer)
if self.tool != self.tools[layer][0] :
self.tool = self.tools[layer][0]
self.tool["passing feed"] = float(self.tool["passing feed"] if "passing feed" in self.tool else self.tool["feed"])
self.tool["feed"] = float(self.tool["feed"])
self.tool["fine feed"] = float(self.tool["fine feed"] if "fine feed" in self.tool else self.tool["feed"])
gcode += ( "(Change tool to %s)\n" % re.sub("\"'\(\)\\\\"," ",self.tool["name"]) ) + self.tool["tool change gcode"] + "\n"
for path in paths[layer]:
csp = self.transform_csp(cubicsuperpath.parsePath(path.get("d")),layer)
for subpath in csp :
# Offset the path if fine cut is defined.
fine_cut = subpath[:]
if self.options.lathe_fine_cut_width>0 :
r = self.options.lathe_fine_cut_width
if self.options.lathe_create_fine_cut_using == "Move path" :
subpath = [ [ [i2[0],i2[1]+r] for i2 in i1] for i1 in subpath]
else :
# Close the path to make offset correct
bound = csp_simple_bound([subpath])
minx,miny,maxx,maxy = csp_true_bounds([subpath])
offsetted_subpath = csp_subpath_line_to(subpath[:], [ [subpath[-1][1][0], miny[1]-r*10 ], [subpath[0][1][0], miny[1]-r*10 ], [subpath[0][1][0], subpath[0][1][1] ] ])
left,right = subpath[-1][1][0], subpath[0][1][0]
if left>right : left, right = right,left
offsetted_subpath = csp_offset([offsetted_subpath], r if not csp_subpath_ccw(offsetted_subpath) else -r )
offsetted_subpath = csp_clip_by_line(offsetted_subpath, [left,10], [left,0] )
offsetted_subpath = csp_clip_by_line(offsetted_subpath, [right,0], [right,10] )
offsetted_subpath = csp_clip_by_line(offsetted_subpath, [0, miny[1]-r], [10, miny[1]-r] )
#draw_csp(self.transform_csp(offsetted_subpath,layer,True), color = "Green", width = 1)
# Join offsetted_subpath together
# Hope there wont be any cicles
subpath = csp_join_subpaths(offsetted_subpath)[0]
# Create solid object from path and lathe_width
bound = csp_simple_bound([subpath])
top_start, top_end = [subpath[0][1][0], self.options.lathe_width+self.options.Zsafe+self.options.lathe_fine_cut_width], [subpath[-1][1][0], self.options.lathe_width+self.options.Zsafe+self.options.lathe_fine_cut_width]
gcode += ("G01 %s %f F %f \n" % (z, top_start[1], self.tool["passing feed"]) )
gcode += ("G01 %s %f %s %f F %f \n" % (x, top_start[0], z, top_start[1], self.tool["passing feed"]) )
subpath = csp_concat_subpaths(csp_subpath_line_to([],[top_start,subpath[0][1]]), subpath)
subpath = csp_subpath_line_to(subpath,[top_end,top_start])
width = max(0, self.options.lathe_width - max(0, bound[1]) )
step = self.tool['depth step']
steps = int(math.ceil(width/step))
for i in range(steps+1):
current_width = self.options.lathe_width - step*i
intersections = []
for j in range(1,len(subpath)) :
sp1,sp2 = subpath[j-1], subpath[j]
intersections += [[j,k] for k in csp_line_intersection([bound[0]-10,current_width], [bound[2]+10,current_width], sp1, sp2)]
intersections += [[j,k] for k in csp_line_intersection([bound[0]-10,current_width+step], [bound[2]+10,current_width+step], sp1, sp2)]
parts = csp_subpath_split_by_points(subpath,intersections)
for part in parts :
minx,miny,maxx,maxy = csp_true_bounds([part])
y = (maxy[1]+miny[1])/2
if y > current_width+step :
gcode += self.generate_lathe_gcode(part,layer,"passing feed")
elif current_width <= y <= current_width+step :
gcode += self.generate_lathe_gcode(part,layer,"feed")
else :
# full step cut
part = csp_subpath_line_to([], [part[0][1], part[-1][1]] )
gcode += self.generate_lathe_gcode(part,layer,"feed")
top_start, top_end = [fine_cut[0][1][0], self.options.lathe_width+self.options.Zsafe+self.options.lathe_fine_cut_width], [fine_cut[-1][1][0], self.options.lathe_width+self.options.Zsafe+self.options.lathe_fine_cut_width]
gcode += "\n(Fine cutting start)\n(Calculating fine cut using %s)\n"%self.options.lathe_create_fine_cut_using
for i in range(self.options.lathe_fine_cut_count) :
width = self.options.lathe_fine_cut_width*(1-float(i+1)/self.options.lathe_fine_cut_count )
if width == 0 :
current_pass = fine_cut
else :
if self.options.lathe_create_fine_cut_using == "Move path" :
current_pass = [ [ [i2[0],i2[1]+width] for i2 in i1] for i1 in fine_cut]
else :
minx,miny,maxx,maxy = csp_true_bounds([fine_cut])
offsetted_subpath = csp_subpath_line_to(fine_cut[:], [ [fine_cut[-1][1][0], miny[1]-r*10 ], [fine_cut[0][1][0], miny[1]-r*10 ], [fine_cut[0][1][0], fine_cut[0][1][1] ] ])
left,right = fine_cut[-1][1][0], fine_cut[0][1][0]
if left>right : left, right = right,left
offsetted_subpath = csp_offset([offsetted_subpath], width if not csp_subpath_ccw(offsetted_subpath) else -width )
offsetted_subpath = csp_clip_by_line(offsetted_subpath, [left,10], [left,0] )
offsetted_subpath = csp_clip_by_line(offsetted_subpath, [right,0], [right,10] )
offsetted_subpath = csp_clip_by_line(offsetted_subpath, [0, miny[1]-r], [10, miny[1]-r] )
current_pass = csp_join_subpaths(offsetted_subpath)[0]
gcode += "\n(Fine cut %i-th cicle start)\n"%(i+1)
gcode += ("G01 %s %f %s %f F %f \n" % (x, top_start[0], z, top_start[1], self.tool["passing feed"]) )
gcode += ("G01 %s %f %s %f F %f \n" % (x, current_pass[0][1][0], z, current_pass[0][1][1]+self.options.lathe_fine_cut_width, self.tool["passing feed"]) )
gcode += ("G01 %s %f %s %f F %f \n" % (x, current_pass[0][1][0], z, current_pass[0][1][1], self.tool["fine feed"]) )
gcode += self.generate_lathe_gcode(current_pass,layer,"fine feed")
gcode += ("G01 %s %f F %f \n" % (z, top_start[1], self.tool["passing feed"]) )
gcode += ("G01 %s %f %s %f F %f \n" % (x, top_start[0], z, top_start[1], self.tool["passing feed"]) )
self.export_gcode(gcode)
################################################################################
###
### Lathe modify path
### Modifies path to fit current cutter. As for now straight rect cutter.
###
################################################################################
def lathe_modify_path(self):
if self.selected_paths == {} and self.options.auto_select_paths:
paths=self.paths
self.error(_("No paths are selected! Trying to work on all available paths."),"warning")
else :
paths = self.selected_paths
for layer in self.layers :
if layer in paths :
width = self.options.lathe_rectangular_cutter_width
#self.set_tool(layer)
for path in paths[layer]:
csp = self.transform_csp(cubicsuperpath.parsePath(path.get("d")),layer)
new_csp = []
for subpath in csp:
orientation = subpath[-1][1][0]>subpath[0][1][0]
last_n = None
last_o = 0
new_subpath = []
# Split segment at x' and y' == 0
for sp1, sp2 in zip(subpath[:],subpath[1:]):
ax,ay,bx,by,cx,cy,dx,dy = csp_parameterize(sp1,sp2)
roots = cubic_solver_real(0, 3*ax, 2*bx, cx)
roots += cubic_solver_real(0, 3*ay, 2*by, cy)
new_subpath = csp_concat_subpaths(new_subpath, csp_seg_split(sp1,sp2,roots))
subpath = new_subpath
new_subpath = []
first_seg = True
for sp1, sp2 in zip(subpath[:],subpath[1:]):
n = csp_normalized_normal(sp1,sp2,0)
a = math.atan2(n[0],n[1])
if a == 0 or a == math.pi :
n = csp_normalized_normal(sp1,sp2,1)
a = math.atan2(n[0],n[1])
if a!=0 and a!=math.pi:
o = 0 if 0<a<=math.pi/2 or -math.pi<a<-math.pi/2 else 1
if not orientation: o = 1-o
# Add first horisontal straight line if needed
if not first_seg and new_subpath==[] : new_subpath = [ [[subpath[0][i][0] - width*o ,subpath[0][i][1]] for i in range(3)] ]
new_subpath = csp_concat_subpaths(
new_subpath,
[
[[sp1[i][0] - width*o ,sp1[i][1]] for i in range(3)],
[[sp2[i][0] - width*o ,sp2[i][1]] for i in range(3)]
]
)
first_seg = False
# Add last horisontal straigth line if needed
if a==0 or a==math.pi :
new_subpath += [ [[subpath[-1][i][0] - width*o ,subpath[-1][i][1]] for i in range(3)] ]
new_csp += [new_subpath]
self.draw_csp(new_csp,layer)
#
# o = (1 if cross(n, [0,1])>0 else -1)*orientation
# new_subpath += [ [sp1[i][0] - width*o,sp1[i][1]] for i in range(3) ]
# n = csp_normalized_normal(sp1,sp2,1)
# o = (1 if cross(n, [0,1])>0 else -1)*orientation
# new_subpath += [ [sp2[i][0] - width*o,sp2[i][1]] for i in range(3) ]
################################################################################
###
### Update function
###
### Gets file containing version information from the web and compaares it with.
### current version.
################################################################################
def update(self) :
try :
import urllib
f = urllib.urlopen("http://www.cnc-club.ru/gcodetools_latest_version", proxies = urllib.getproxies())
a = f.read()
for s in a.split("\n") :
r = re.search(r"Gcodetools\s+latest\s+version\s*=\s*(.*)",s)
if r :
ver = r.group(1).strip()
if ver != gcodetools_current_version :
self.error("There is a newer version of Gcodetools you can get it at: \nhttp://www.cnc-club.ru/gcodetools (English version). \nhttp://www.cnc-club.ru/gcodetools_ru (Russian version). ","Warning")
else :
self.error("You are currently using latest stable version of Gcodetools.","Warning")
return
self.error("Can not check the latest version. You can check it manualy at \nhttp://www.cnc-club.ru/gcodetools (English version). \nhttp://www.cnc-club.ru/gcodetools_ru (Russian version). \nCurrent version is Gcodetools %s"%gcodetools_current_version,"Warning")
except :
self.error("Can not check the latest version. You can check it manualy at \nhttp://www.cnc-club.ru/gcodetools (English version). \nhttp://www.cnc-club.ru/gcodetools_ru (Russian version). \nCurrent version is Gcodetools %s"%gcodetools_current_version,"Warning")
################################################################################
### Graffiti function generates Gcode for graffiti drawer
################################################################################
def graffiti(self) :
# Get reference points.
def get_gcode_coordinates(point,layer):
gcode = ''
pos = []
for ref_point in self.graffiti_reference_points[layer] :
c = math.sqrt((point[0]-ref_point[0][0])**2 + (point[1]-ref_point[0][1])**2)
gcode += " %s %f"%(ref_point[1], c)
pos += [c]
return pos, gcode
def graffiti_preview_draw_point(x1,y1,color,radius=.5):
self.graffiti_preview = self.graffiti_preview
r,g,b,a_ = color
for x in range(int(x1-1-math.ceil(radius)), int(x1+1+math.ceil(radius)+1)):
for y in range(int(y1-1-math.ceil(radius)), int(y1+1+math.ceil(radius)+1)):
if x>=0 and y>=0 and y<len(self.graffiti_preview) and x*4<len(self.graffiti_preview[0]) :
d = math.sqrt( (x1-x)**2 +(y1-y)**2 )
a = float(a_)*( max(0,(1-(d-radius))) if d>radius else 1 )/256
self.graffiti_preview[y][x*4] = int(r*a + (1-a)*self.graffiti_preview[y][x*4])
self.graffiti_preview[y][x*4+1] = int(g*a + (1-a)*self.graffiti_preview[y][x*4+1])
self.graffiti_preview[y][x*4+2] = int(g*b + (1-a)*self.graffiti_preview[y][x*4+2])
self.graffiti_preview[y][x*4+3] = min(255,int(self.graffiti_preview[y][x*4+3]+a*256))
def graffiti_preview_transform(x,y):
tr = self.graffiti_preview_transform
d = max(tr[2]-tr[0]+2,tr[3]-tr[1]+2)
return [(x-tr[0]+1)*self.options.graffiti_preview_size/d, self.options.graffiti_preview_size - (y-tr[1]+1)*self.options.graffiti_preview_size/d]
def draw_graffiti_segment(layer,start,end,feed,color=(0,255,0,40),emmit=1000):
# Emit = dots per second
l = math.sqrt(sum([(start[i]-end[i])**2 for i in range(len(start))]))
time_ = l/feed
c1,c2 = self.graffiti_reference_points[layer][0][0],self.graffiti_reference_points[layer][1][0]
d = math.sqrt( (c1[0]-c2[0])**2 + (c1[1]-c2[1])**2 )
if d == 0 : raise ValueError, "Error! Reference points should not be the same!"
for i in range(int(time_*emmit+1)) :
t = i/(time_*emmit)
r1,r2 = start[0]*(1-t) + end[0]*t, start[1]*(1-t) + end[1]*t
a = (r1**2-r2**2+d**2)/(2*d)
h = math.sqrt(r1**2 - a**2)
xa = c1[0] + a*(c2[0]-c1[0])/d
ya = c1[1] + a*(c2[1]-c1[1])/d
x1 = xa + h*(c2[1]-c1[1])/d
x2 = xa - h*(c2[1]-c1[1])/d
y1 = ya - h*(c2[0]-c1[0])/d
y2 = ya + h*(c2[0]-c1[0])/d
x = x1 if y1<y2 else x2
y = min(y1,y2)
x,y = graffiti_preview_transform(x,y)
graffiti_preview_draw_point(x,y,color)
def create_connector(p1,p2,t1,t2):
P1,P2 = P(p1), P(p2)
N1, N2 = P(rotate_ccw(t1)), P(rotate_ccw(t2))
r = self.options.graffiti_min_radius
C1,C2 = P1+N1*r, P2+N2*r
# Get closest possible centers of arcs, also we define that arcs are both ccw or both not.
dc, N1, N2, m = (
(
(((P2-N1*r) - (P1-N2*r)).l2(),-N1,-N2, 1)
if vectors_ccw(t1,t2) else
(((P2+N1*r) - (P1+N2*r)).l2(), N1, N2,-1)
)
if vectors_ccw((P1-C1).to_list(),t1) == vectors_ccw((P2-C2).to_list(),t2) else
(
(((P2+N1*r) - (P1-N2*r)).l2(), N1,-N2, 1)
if vectors_ccw(t1,t2) else
(((P2-N1*r) - (P1+N2*r)).l2(),-N1, N2, 1)
)
)
dc = math.sqrt(dc)
C1,C2 = P1+N1*r, P2+N2*r
Dc = C2-C1
if dc == 0 :
# can be joined by one arc
return csp_from_arc(p1, p2, C1.to_list(), r, t1)
cos, sin = Dc.x/dc, Dc.y/dc
#draw_csp(self.transform_csp([[ [[C1.x-r*sin,C1.y+r*cos]]*3,[[C2.x-r*sin,C2.y+r*cos]]*3 ]],layer,reverse=True), color = "#00ff00;" )
#draw_pointer(self.transform(C1.to_list(),layer,reverse=True))
#draw_pointer(self.transform(C2.to_list(),layer,reverse=True))
p1_end = [C1.x-r*sin*m,C1.y+r*cos*m]
p2_st = [C2.x-r*sin*m,C2.y+r*cos*m]
if point_to_point_d2(p1,p1_end)<0.0001 and point_to_point_d2(p2,p2_st)<0.0001 :
return ([[p1,p1,p1],[p2,p2,p2]])
arc1 = csp_from_arc(p1, p1_end, C1.to_list(), r, t1)
arc2 = csp_from_arc(p2_st, p2, C2.to_list(), r, [cos,sin])
return csp_concat_subpaths(arc1,arc2)
if not self.check_dir() : return
if self.selected_paths == {} and self.options.auto_select_paths:
paths=self.paths
self.error(_("No paths are selected! Trying to work on all available paths."),"warning")
else :
paths = self.selected_paths
self.tool = []
gcode = """(Header)
(Generated by gcodetools from Inkscape.)
(Using graffiti extension.)
(Header end.)"""
minx,miny,maxx,maxy = float("inf"),float("inf"),float("-inf"),float("-inf")
# Get all reference points and path's bounds to make preview
for layer in self.layers :
if layer in paths :
# Set reference points
if layer not in self.graffiti_reference_points:
reference_points = None
for i in range(self.layers.index(layer),-1,-1):
if self.layers[i] in self.graffiti_reference_points :
reference_points = self.graffiti_reference_points[self.layers[i]]
self.graffiti_reference_points[layer] = self.graffiti_reference_points[self.layers[i]]
break
if reference_points == None :
self.error('There are no graffiti reference points for layer %s'%layer,"error")
# Transform reference points
for i in range(len(self.graffiti_reference_points[layer])):
self.graffiti_reference_points[layer][i][0] = self.transform(self.graffiti_reference_points[layer][i][0], layer)
point = self.graffiti_reference_points[layer][i]
gcode += "(Reference point %f;%f for %s axis)\n"%(point[0][0],point[0][1],point[1])
if self.options.graffiti_create_preview :
for point in self.graffiti_reference_points[layer]:
minx,miny,maxx,maxy = min(minx,point[0][0]), min(miny,point[0][1]), max(maxx,point[0][0]), max(maxy,point[0][1])
for path in paths[layer]:
csp = cubicsuperpath.parsePath(path.get("d"))
csp = self.apply_transforms(path, csp)
csp = self.transform_csp(csp, layer)
bounds = csp_simple_bound(csp)
minx,miny,maxx,maxy = min(minx,bounds[0]), min(miny,bounds[1]), max(maxx,bounds[2]), max(maxy,bounds[3])
if self.options.graffiti_create_preview :
self.graffiti_preview = list([ [255]*(4*self.options.graffiti_preview_size) for i in range(self.options.graffiti_preview_size)])
self.graffiti_preview_transform = [minx,miny,maxx,maxy]
for layer in self.layers :
if layer in paths :
r = re.match("\s*\(\s*([0-9\-,.]+)\s*;\s*([0-9\-,.]+)\s*\)\s*",self.options.graffiti_start_pos)
if r :
start_point = [float(r.group(1)),float(r.group(2))]
else :
start_point = [0.,0.]
last_sp1 = [[start_point[0],start_point[1]-10] for i in range(3)]
last_sp2 = [start_point for i in range(3)]
self.set_tool(layer)
self.tool = self.tools[layer][0]
# Change tool every layer. (Probably layer = color so it'll be
# better to change it even if the tool has not been changed)
gcode += ( "(Change tool to %s)\n" % re.sub("\"'\(\)\\\\"," ",self.tool["name"]) ) + self.tool["tool change gcode"] + "\n"
subpaths = []
for path in paths[layer]:
# Rebuild the paths to polyline.
csp = cubicsuperpath.parsePath(path.get("d"))
csp = self.apply_transforms(path, csp)
csp = self.transform_csp(csp, layer)
subpaths += csp
polylines = []
while len(subpaths)>0:
i = min( [( point_to_point_d2(last_sp2[1],subpaths[i][0][1]),i) for i in range(len(subpaths))] )[1]
subpath = subpaths[i][:]
del subpaths[i]
polylines += [
['connector', create_connector(
last_sp2[1],
subpath[0][1],
csp_normalized_slope(last_sp1,last_sp2,1.),
csp_normalized_slope(subpath[0],subpath[1],0.),
)]
]
polyline = []
spl = None
# remove zerro length segments
i = 0
while i<len(subpath)-1:
if (cspseglength(subpath[i],subpath[i+1])<0.00000001 ) :
subpath[i][2] = subpath[i+1][2]
del subpath[i+1]
else :
i += 1
for sp1, sp2 in zip(subpath,subpath[1:]) :
if spl != None and abs(cross( csp_normalized_slope(spl,sp1,1.),csp_normalized_slope(sp1,sp2,0.) )) > 0.1 : # TODO add coefficient into inx
# We've got sharp angle at sp1.
polyline += [sp1]
polylines += [['draw',polyline[:]]]
polylines += [
['connector', create_connector(
sp1[1],
sp1[1],
csp_normalized_slope(spl,sp1,1.),
csp_normalized_slope(sp1,sp2,0.),
)]
]
polyline = []
# max_segment_length
polyline += [ sp1 ]
print_(polyline)
print_(sp1)
spl = sp1
polyline += [ sp2 ]
polylines += [ ['draw',polyline[:]] ]
last_sp1, last_sp2 = sp1,sp2
# Add return to start_point
if polylines == [] : continue
polylines += [ ["connect1", [ [polylines[-1][1][-1][1] for i in range(3)],[start_point for i in range(3)] ] ] ]
# Make polilynes from polylines. They are still csp.
for i in range(len(polylines)) :
polyline = []
l = 0
print_("polylines",polylines)
print_(polylines[i])
for sp1,sp2 in zip(polylines[i][1],polylines[i][1][1:]) :
print_(sp1,sp2)
l = cspseglength(sp1,sp2)
if l>0.00000001 :
polyline += [sp1[1]]
parts = int(math.ceil(l/self.options.graffiti_max_seg_length))
for j in range(1,parts):
polyline += [csp_at_length(sp1,sp2,float(j)/parts) ]
if l>0.00000001 :
polyline += [sp2[1]]
print_(i)
polylines[i][1] = polyline
t = 0
last_state = None
for polyline_ in polylines:
polyline = polyline_[1]
# Draw linearization
if self.options.graffiti_create_linearization_preview :
t += 1
csp = [ [polyline[i],polyline[i],polyline[i]] for i in range(len(polyline))]
draw_csp(self.transform_csp([csp],layer,reverse=True), color = "#00cc00;" if polyline_[0]=='draw' else "#ff5555;")
# Export polyline to gcode
# we are making trnsform from XYZA coordinates to R1...Rn
# where R1...Rn are radius vectors from grafiti reference points
# to current (x,y) point. Also we need to assign custom feed rate
# for each segment. And we'll use only G01 gcode.
last_real_pos, g = get_gcode_coordinates(polyline[0],layer)
last_pos = polyline[0]
if polyline_[0] == "draw" and last_state!="draw":
gcode += self.tool['gcode before path']+"\n"
for point in polyline :
real_pos, g = get_gcode_coordinates(point,layer)
real_l = sum([(real_pos[i]-last_real_pos[i])**2 for i in range(len(last_real_pos))])
l = (last_pos[0]-point[0])**2 + (last_pos[1]-point[1])**2
if l!=0:
feed = self.tool['feed']*math.sqrt(real_l/l)
gcode += "G01 " + g + " F %f\n"%feed
if self.options.graffiti_create_preview :
draw_graffiti_segment(layer,real_pos,last_real_pos,feed,color=(0,0,255,200) if polyline_[0] == "draw" else (255,0,0,200),emmit=self.options.graffiti_preview_emmit)
last_real_pos = real_pos
last_pos = point[:]
if polyline_[0] == "draw" and last_state!="draw" :
gcode += self.tool['gcode after path']+"\n"
last_state = polyline_[0]
self.export_gcode(gcode, no_headers=True)
if self.options.graffiti_create_preview :
try :
# Draw reference points
for layer in self.graffiti_reference_points:
for point in self.graffiti_reference_points[layer] :
x, y = graffiti_preview_transform(point[0][0],point[0][1])
graffiti_preview_draw_point(x,y,(0,255,0,255),radius=5)
import png
writer = png.Writer(width=self.options.graffiti_preview_size, height=self.options.graffiti_preview_size, size=None, greyscale=False, alpha=True, bitdepth=8, palette=None, transparent=None, background=None, gamma=None, compression=None, interlace=False, bytes_per_sample=None, planes=None, colormap=None, maxval=None, chunk_limit=1048576)
f = open(self.options.directory+self.options.file+".png", 'wb')
writer.write(f,self.graffiti_preview)
f.close()
except :
self.error("Png module have not been found!","warning")
################################################################################
###
### Effect
###
### Main function of Gcodetools class
###
################################################################################
def effect(self) :
start_time = time.time()
global options
options = self.options
options.self = self
options.doc_root = self.document.getroot()
# define print_ function
global print_
if self.options.log_create_log :
try :
if os.path.isfile(self.options.log_filename) : os.remove(self.options.log_filename)
f = open(self.options.log_filename,"a")
f.write("Gcodetools log file.\nStarted at %s.\n%s\n" % (time.strftime("%d.%m.%Y %H:%M:%S"),options.log_filename))
f.write("%s tab is active.\n" % self.options.active_tab)
f.close()
except :
print_ = lambda *x : None
else : print_ = lambda *x : None
if self.options.active_tab == '"help"' :
self.help()
return
elif self.options.active_tab == '"about"' :
self.help()
return
elif self.options.active_tab == '"test"' :
self.test()
elif self.options.active_tab not in ['"dxfpoints"','"path-to-gcode"', '"area_fill"', '"area"', '"area_artefacts"', '"engraving"', '"orientation"', '"tools_library"', '"lathe"', '"offset"', '"arrangement"', '"update"', '"graffiti"', '"lathe_modify_path"', '"plasma-prepare-path"']:
self.error(_("Select one of the action tabs - Path to Gcode, Area, Engraving, DXF points, Orientation, Offset, Lathe or Tools library.\n Current active tab id is %s" % self.options.active_tab),"error")
else:
# Get all Gcodetools data from the scene.
self.get_info()
if self.options.active_tab in ['"dxfpoints"','"path-to-gcode"', '"area_fill"', '"area"', '"area_artefacts"', '"engraving"', '"lathe"', '"graffiti"', '"plasma-prepare-path"']:
if self.orientation_points == {} :
self.error(_("Orientation points have not been defined! A default set of orientation points has been automatically added."),"warning")
self.orientation( self.layers[min(1,len(self.layers)-1)] )
self.get_info()
if self.tools == {} :
self.error(_("Cutting tool has not been defined! A default tool has been automatically added."),"warning")
self.options.tools_library_type = "default"
self.tools_library( self.layers[min(1,len(self.layers)-1)] )
self.get_info()
if self.options.active_tab == '"path-to-gcode"':
self.path_to_gcode()
elif self.options.active_tab == '"area_fill"':
self.area_fill()
elif self.options.active_tab == '"area"':
self.area()
elif self.options.active_tab == '"area_artefacts"':
self.area_artefacts()
elif self.options.active_tab == '"dxfpoints"':
self.dxfpoints()
elif self.options.active_tab == '"engraving"':
self.engraving()
elif self.options.active_tab == '"orientation"':
self.orientation()
elif self.options.active_tab == '"graffiti"':
self.graffiti()
elif self.options.active_tab == '"tools_library"':
if self.options.tools_library_type != "check":
self.tools_library()
else :
self.check_tools_and_op()
elif self.options.active_tab == '"lathe"':
self.lathe()
elif self.options.active_tab == '"lathe_modify_path"':
self.lathe_modify_path()
elif self.options.active_tab == '"update"':
self.update()
elif self.options.active_tab == '"offset"':
if self.options.offset_just_get_distance :
for layer in self.selected_paths :
if len(self.selected_paths[layer]) == 2 :
csp1, csp2 = cubicsuperpath.parsePath(self.selected_paths[layer][0].get("d")), cubicsuperpath.parsePath(self.selected_paths[layer][1].get("d"))
dist = csp_to_csp_distance(csp1,csp2)
print_(dist)
draw_pointer( list(csp_at_t(csp1[dist[1]][dist[2]-1],csp1[dist[1]][dist[2]],dist[3]))
+list(csp_at_t(csp2[dist[4]][dist[5]-1],csp2[dist[4]][dist[5]],dist[6])),"red","line", comment = math.sqrt(dist[0]))
return
if self.options.offset_step == 0 : self.options.offset_step = self.options.offset_radius
if self.options.offset_step*self.options.offset_radius <0 : self.options.offset_step *= -1
time_ = time.time()
offsets_count = 0
for layer in self.selected_paths :
for path in self.selected_paths[layer] :
offset = self.options.offset_step/2
while abs(offset) <= abs(self.options.offset_radius) :
offset_ = csp_offset(cubicsuperpath.parsePath(path.get("d")), offset)
offsets_count += 1
if offset_ != [] :
for iii in offset_ :
draw_csp([iii], color="Green", width=1)
#print_(offset_)
else :
print_("------------Reached empty offset at radius %s"% offset )
break
offset += self.options.offset_step
print_()
print_("-----------------------------------------------------------------------------------")
print_("-----------------------------------------------------------------------------------")
print_("-----------------------------------------------------------------------------------")
print_()
print_("Done in %s"%(time.time()-time_))
print_("Total offsets count %s"%offsets_count)
elif self.options.active_tab == '"arrangement"':
self.arrangement()
elif self.options.active_tab == '"plasma-prepare-path"':
self.plasma_prepare_path()
print_("------------------------------------------")
print_("Done in %f seconds"%(time.time()-start_time))
print_("End at %s."%time.strftime("%d.%m.%Y %H:%M:%S"))
#
gcodetools = Gcodetools()
gcodetools.affect()
