diff options
Diffstat (limited to 'share/extensions/gcodetools.py')
| -rwxr-xr-x | share/extensions/gcodetools.py | 5921 |
1 files changed, 5921 insertions, 0 deletions
diff --git a/share/extensions/gcodetools.py b/share/extensions/gcodetools.py new file mode 100755 index 0000000..90a41a7 --- /dev/null +++ b/share/extensions/gcodetools.py @@ -0,0 +1,5921 @@ +#!/usr/bin/env python +# coding=utf-8 +# +# Copyright (C) 2005 Aaron Spike, aaron@ekips.org (super paths et al) +# 2007 hugomatic... (gcode.py) +# 2009 Nick Drobchenko, nick@cnc-club.ru (main developer) +# 2011 Chris Lusby Taylor, clusbytaylor@enterprise.net (engraving functions) +# +# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# +""" +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) +24 Jan 2017 Removed hard-coded scale values from orientation point calculation +TODO Change line division to be recursive, depending on what line is touched. See line_divide +""" + +__version__ = '1.7' + +import cmath +import copy +import math +import os +import re +import sys +import time +from functools import partial + +import numpy + +import inkex +from inkex.bezier import bezierlength, bezierparameterize, beziertatlength +from inkex import Transform, PathElement, TextElement, Tspan, Group, Layer, Marker, CubicSuperPath, Style + +if sys.version_info[0] > 2: + xrange = range + unicode = str + +def ireplace(self, old, new, count=0): + pattern = re.compile(re.escape(old), re.I) + return re.sub(pattern, new, self, count) + + +################################################################################ +# +# Styles and additional parameters +# +################################################################################ + +TAU = 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 + +def marker_style(stroke, marker='DrawCurveMarker', width=1): + """Set a marker style with some basic defaults""" + return Style(stroke=stroke, fill='none', stroke_width=width, + marker_end='url(#{})'.format(marker)) + +MARKER_STYLE = { + "in_out_path_style": marker_style('#0072a7', 'InOutPathMarker'), + "loft_style": { + 'main curve': marker_style('#88f', 'Arrow2Mend'), + }, + "biarc_style": { + 'biarc0': marker_style('#88f'), + 'biarc1': marker_style('#8f8'), + 'line': marker_style('#f88'), + 'area': marker_style('#777', width=0.1), + }, + "biarc_style_dark": { + 'biarc0': marker_style('#33a'), + 'biarc1': marker_style('#3a3'), + 'line': marker_style('#a33'), + 'area': marker_style('#222', width=0.3), + }, + "biarc_style_dark_area": { + 'biarc0': marker_style('#33a', width=0.1), + 'biarc1': marker_style('#3a3', width=0.1), + 'line': marker_style('#a33', width=0.1), + 'area': marker_style('#222', width=0.3), + }, + "biarc_style_i": { + 'biarc0': marker_style('#880'), + 'biarc1': marker_style('#808'), + 'line': marker_style('#088'), + 'area': marker_style('#999', width=0.3), + }, + "biarc_style_dark_i": { + 'biarc0': marker_style('#dd5'), + 'biarc1': marker_style('#d5d'), + 'line': marker_style('#5dd'), + 'area': marker_style('#aaa', width=0.3), + }, + "biarc_style_lathe_feed": { + 'biarc0': marker_style('#07f', width=0.4), + 'biarc1': marker_style('#0f7', width=0.4), + 'line': marker_style('#f44', width=0.4), + 'area': marker_style('#aaa', width=0.3), + }, + "biarc_style_lathe_passing feed": { + 'biarc0': marker_style('#07f', width=0.4), + 'biarc1': marker_style('#0f7', width=0.4), + 'line': marker_style('#f44', width=0.4), + 'area': marker_style('#aaa', width=0.3), + }, + "biarc_style_lathe_fine feed": { + 'biarc0': marker_style('#7f0', width=0.4), + 'biarc1': marker_style('#f70', width=0.4), + 'line': marker_style('#744', width=0.4), + 'area': marker_style('#aaa', width=0.3), + }, + "area artefact": Style(stroke='#ff0000', fill='#ffff00', stroke_width=1), + "area artefact arrow": Style(stroke='#ff0000', fill='#ffff00', stroke_width=1), + "dxf_points": Style(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 _ in range(3)] for point in subline] for subline in line] + + +def csp_remove_zero_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 assign any value to on_the_path, by default 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 = subpath[i - 1] + sp2 = 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 won't 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 should have considered this case previously. + if t == 1: + # we have to check the next segment 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 = subpath[(i - 1 + j) % len(subpath)] + sp22 = 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 _ 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 = None + miny = None + maxx = None + maxy = None + + for subpath in csp: + for sp in subpath: + for p in sp: + minx = min(minx, p[0]) if minx is not None else p[0] + miny = min(miny, p[1]) if miny is not None else p[1] + maxx = max(maxx, p[0]) if maxx is not None else p[0] + maxy = max(maxy, p[1]) if maxy is not None else p[1] + return minx, miny, maxx, maxy + + +def csp_segment_to_bez(sp1, sp2): + return sp1[1:] + sp2[:2] + + +def csp_to_point_distance(csp, p, dist_bounds=(0, 1e100)): + 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) + if d[0] < dist_bounds[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): + ax, ay, bx, by, cx, cy, dx, dy = csp_parameterize(sp1, sp2) + dx = dx - p[0] + dy = 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 = t ** 2 + t3 = 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) + dist += [0.] + if dist[0] <= dist_bounds[0]: + return dist + d = csp_seg_to_point_distance(sp1, sp2, sp4[1], sample_points) + 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) + 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) + 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 = float(k + 1) / (sample_points + 1) + t2 = float(j) / (sample_points + 1) + + t12 = t1 * t1 + t13 = t1 * t1 * t1 + t22 = t2 * t2 + t23 = t2 * t2 * t2 + i = 0 + + F1 = [0, 0] + F2 = [[0, 0], [0, 0]] + F = 1e100 + x = ax1 * t13 + bx1 * t12 + cx1 * t1 + dx1 - (ax2 * t23 + bx2 * t22 + cx2 * t2 + dx2) + y = 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: + 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 is not None: + t1 -= (F2[0][0] * F1[0] + F2[0][1] * F1[1]) + t2 -= (F2[1][0] * F1[0] + F2[1][1] * F1[1]) + t12 = t1 * t1 + t13 = t1 * t1 * t1 + t22 = t2 * t2 + t23 = t2 * t2 * t2 + x = ax1 * t13 + bx1 * t12 + cx1 * t1 + dx1 - (ax2 * t23 + bx2 * t22 + cx2 * t2 + dx2) + y = 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 + + +def csp_split(sp1, sp2, t=.5): + [x1, y1] = sp1[1] + [x2, y2] = sp1[2] + [x3, y3] = sp2[0] + [x4, y4] = 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 = 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 containing all intersections between two segments 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 = csp_segment_to_bez(sp1, sp2) + b = csp_segment_to_bez(sp3, sp4) + + def polish_intersection(a, b, ta, tb, tolerance=INTERSECTION_TOLERANCE): + ax, ay, bx, by, cx, cy, dx, dy = bezierparameterize(a) + ax1, ay1, bx1, by1, cx1, cy1, dx1, dy1 = bezierparameterize(b) + i = 0 + F = [.0, .0] + F1 = [[.0, .0], [.0, .0]] + while i == 0 or (abs(F[0]) ** 2 + abs(F[1]) ** 2 > tolerance and i < 10): + ta3 = ta ** 3 + ta2 = ta ** 2 + tb3 = tb ** 3 + tb2 = 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 = (ta0 + ta1) / 2 + tbm = (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 subdivided enough. 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 containing [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 = 0 + F = 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 = 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 won't influence anything... + return csp_curvature_at_t(sp1, sp2, t * 1.004, depth - 1) + return 1e100 + + +def csp_subpath_ccw(subpath): + # Remove all zero length segments + s = 0 + 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 = sp1[1][0] + bx = sp1[2][0] + cx = sp2[0][0] + dx = sp2[1][0] + + ay = sp1[1][1] + by = sp1[2][1] + cy = sp2[0][1] + dy = sp2[1][1] + + x1 = ax + (bx - ax) * t + y1 = ay + (by - ay) * t + + x2 = bx + (cx - bx) * t + y2 = by + (cy - by) * t + + x3 = cx + (dx - cx) * t + y3 = cy + (dy - cy) * t + + x4 = x1 + (x2 - x1) * t + y4 = y1 + (y2 - y1) * t + + x5 = x2 + (x3 - x2) * t + y5 = y2 + (y3 - y2) * t + + x = x4 + (x5 - x4) * t + y = 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 = beziertatlength(bez, l, tolerance) + return csp_at_t(sp1, sp2, t) + + +def cspseglength(sp1, sp2, tolerance=0.01): + bez = (sp1[1][:], sp1[2][:], sp2[0][:], sp2[1][:]) + return bezierlength(bez, tolerance) + + +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 = 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, t1) + 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_ = math.cos(alpha) + sin_ = 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])) % TAU + + sectors = int(abs(alpha) * 2 / math.pi) + 1 + alpha_start = atan2(start[0] - center[0], start[1] - center[1]) + cos_ = math.cos(alpha_start) + sin_ = 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 -= TAU + else: + alpha += TAU + 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_ = math.cos(alpha_start + alpha * i / sectors) + sin_ = 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 + 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 - TAU + else: + alpha = TAU + 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 = (p - P0).mag() + d2 = (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 = 10 + i = 0 + d = (0, [0, 0]) + d1 = (0, [0, 0]) + dl = 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_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] = bez[i - 1] + [x1, y1] = 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 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 = 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 bezierparameterize(csp_segment_to_bez(sp1, sp2)) + + +def csp_concat_subpaths(*s): + def concat(s1, s2): + if not s1: + return s2 + if not 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 = sp1[1][:] + b = sp1[2][:] + c = sp2[0][:] + d = 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 = abc * abd > 0 + m2 = abc * bcd > 0 + m3 = 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 happened which is something that shouldn't 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(xy1, xy2, t): + (x1, y1) = xy1 + (x2, y2) = xy2 + return [x1 + t * (x2 - x1), y1 + t * (y2 - y1)] + + +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]] + + +################################################################################ +# Some vector functions +################################################################################ + +def normalize(xy): + (x, y) = xy + 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 + + +################################################################################ +# Common functions +################################################################################ + +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])) % TAU + elif len(arg) == 2: + return (math.pi / 2 - math.atan2(arg[0], arg[1])) % TAU + else: + raise ValueError("Bad argumets for atan! ({})".format(*arg)) + + +def draw_text(text, x, y, group=None, style=None, font_size=10, gcodetools_tag=None): + if style is 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:{:f}px;".format(font_size) + attributes = {'x': str(x), 'y': str(y), 'style': style} + if gcodetools_tag is not None: + attributes["gcodetools"] = str(gcodetools_tag) + + if group is None: + group = options.doc_root + + text_elem = group.add(TextElement(**attributes)) + text_elem.set("xml:space", "preserve") + text = str(text).split("\n") + for string in text: + span = text_elem.add(Tspan(x=str(x), y=str(y))) + span.set('sodipodi:role', 'line') + y += font_size + span.text = str(string) + + +def draw_csp(csp, stroke="#f00", fill="none", comment="", width=0.354, group=None, style=None): + if group is None: + group = options.doc_root + node = group.add(PathElement()) + + node.style = style if style is not None else \ + {'fill': fill, 'fill-opacity': 1, 'stroke': stroke, 'stroke-width': width} + + node.path = CubicSuperPath(csp) + + if comment != '': + node.set('comment', comment) + + return node + + +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 is None: + attrib = {} + if pointer_type is None: + pointer_type = "Pointer" + attrib["gcodetools"] = pointer_type + if group is None: + group = options.self.svg.get_current_layer() + if text is not None: + if font_size is None: + font_size = 7 + group = group.add(Group(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 += " {}, {} ".format(x[i * 2], x[i * 2 + 1]) + attrib.update({"d": "M {},{} L {}".format(x[0], x[1], s), "style": "fill:none;stroke:{};stroke-width:{:f};".format(color, width), "comment": str(comment)}) + elif figure == "arrow": + if fill is None: + fill = "#12b3ff" + fill_opacity = "0.8" + d = "m {},{} ".format(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:{};stroke:none;fill-opacity:{};".format(fill, fill_opacity), "comment": str(comment)}) + else: + attrib.update({"d": "m {},{} l {:f},{:f} {:f},{:f} {:f},{:f} {:f},{:f} , {:f},{:f}".format(x[0], x[1], size, size, -2 * size, -2 * size, size, size, size, -size, -2 * size, 2 * size), "style": "fill:none;stroke:{};stroke-width:{:f};".format(color, width), "comment": str(comment)}) + group.add(PathElement(**attrib)) + + +def straight_segments_intersection(a, b, true_intersection=True): # (True intersection means check ta and tb are in [0,1]) + ax = a[0][0] + bx = a[1][0] + cx = b[0][0] + dx = b[1][0] + ay = a[0][1] + by = a[1][1] + cy = b[0][1] + dy = 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 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): + with open(options.log_filename, "ab") as f: + for s in arg: + s = unicode(s).encode('unicode_escape') + b" " + f.write(s) + f.write(b"\n") + + +################################################################################ +# Point (x,y) operations +################################################################################ +class P(object): + def __init__(self, x, y=None): + if not y is None: + self.x = float(x) + self.y = float(y) + else: + self.x = float(x[0]) + self.y = 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 __truediv__(self, other): + return self.__div__(other) + + def mag(self): + return math.hypot(self.x, self.y) + + def unit(self): + h_mag = self.mag() + if h_mag: + return self / h_mag + 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}'.format(self.x, self.y) + + def pr(self): + return "{:.2f},{:.2f}".format(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 Line(object): + 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 {},{} L {},{}'.format(st[0], st[1], end[0], end[1]), + "gcodetools": "Preview", + } + if transform: + attr["transform"] = transform + group.add(PathElement(**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(str((x, t1, t2))) + if 0 <= t1 <= 1 and 0 <= t2 <= 1: + return [self.st + v1 * t1] + else: + return [] + else: + return [] + + +################################################################################ +# +# 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 {}".format(time_)) + print_("Offset radius {}".format(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 not 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 # ??? + return result + + def create_offset_segment(sp1, sp2, r): + # See Gernot Hoffmann "Bezier Curves" p.34 -> 7.1 Bezier Offset Curves + p0 = P(sp1[1]) + p1 = P(sp1[2]) + p2 = P(sp2[0]) + p3 = P(sp2[1]) + + s0 = p1 - p0 + s1 = p2 - p1 + s3 = 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 = p0 + r * n0 + q3 = 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 = s1[-i - 1] + sp12 = s1[-i] + for j in range(1, len(s2)): + sp21 = s2[j - 1] + sp22 = 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 not 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:] + # Clip next by arc + if not 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:] + + 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: + 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: + 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 self-intersecting and very nasty. + + print_("Offset prepared the path in {}".format(time.time() - time_)) + print_("Path length = {}".format(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)] + + intersection = [[] for i in xrange(csp_len)] + for i in xrange(csp_len): + subpath = csp[i] + subpath_offset = [] + for sp1, sp2 in zip(subpath, subpath[1:]): + segment_offset = csp_offset_segment(sp1, sp2, r) + if not 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) + + subpath_offset = csp_concat_subpaths(subpath_offset[:-prev_l + 1], prev, arc, next) + prev_l = len(next) + sp1_l = sp1[:] + sp2_l = 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) + + # Collect subpath's offset and save it to unclipped offset list. + unclipped_offset[i] = subpath_offset[:] + + print_("Offsetted path in {}".format(time.time() - time_)) + time_ = time.time() + + ############################################################################ + # Now to the clipping. + ############################################################################ + # First of all find all intersection's between all segments of all offset 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]]] + + 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 {}".format(time.time() - time_)) + print_("Examined {} segments".format(summ)) + print_("found {} intersections".format(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[:]] + + print_("Split in {}".format(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], 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 + + 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], 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 {}".format(time.time() - time_)) + + ######################################################################## + # Now to the Dummy clipping: remove parts from split offset if their + # centers are closer to the original path than offset radius. + ######################################################################## + + if abs(r * .01) < 1: + r1 = (0.99 * r) ** 2 + r2 = (1.01 * r) ** 2 + else: + r1 = (abs(r) - 1) ** 2 + r2 = (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]) + 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 {}".format(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 = cspseglength(sp1, sp2) + l2 = 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 = P(sp1[1]) + P4 = P(sp2[1]) + TS = (P(sp1[2]) - P0) + TE = -(P(sp2[0]) - P4) + v = P0 - P4 + tsa = TS.angle() + tea = TE.angle() + va = v.angle() + if TE.mag() < STRAIGHT_DISTANCE_TOLERANCE and TS.mag() < STRAIGHT_DISTANCE_TOLERANCE: + # Both tangents are zero - 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 = TS.unit() + TE = 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 tolerance + + # Both tangents and v are parallel - line straight + return [[sp1[1], 'line', 0, 0, sp2[1], [z1, z2]]] + + c = v * v + b = 2 * v * (r * TS + TE) + a = 2 * r * (TS * TE - 1) + if v.mag() == 0: + return biarc_split(sp1, sp2, z1, z2, depth) + asmall = abs(a) < 10 ** -10 + bsmall = abs(b) < 10 ** -10 + csmall = 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 = (P0 - R).angle() % (2 * math.pi) + p1a = (P1 - R).angle() % (2 * math.pi) + p2a = (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 is None or R2 is 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 treated 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 treated 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] + + +class Postprocessor(object): + 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: '{}')".format(command), "error") + function = r.group(1).lower() + parameters = r.group(2) + if function in self.functions: + print_("Postprocessor: executing function {}({})".format(function, parameters)) + self.functions[function](parameters) + else: + self.error("Unrecognized function '{}' while postprocessing.\n(Command: '{}')".format(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({},line)".format(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: '{}')\n {}".format(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: '{}')".format(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{}:#:#:".format(i)) + else: + self.gcode = self.gcode.replace(pattern[i], ":#:#:remap_pattern{}:#:#:".format(i)) + + for i in range(len(remap)): + self.gcode = self.gcode.replace(":#:#:remap_pattern{}:#:#:".format(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.") + 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.") + 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.") + 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}".format(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}".format(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 += "{} = 0 ({} axis offset)\n".format(offset[c], c.upper()) + + # Add scale parametrization + if not 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 ({} Scale factor)\n".format({"g17": "XY", "g18": "XZ", "g19": "YZ"}[planes[0]]) + gcode += "#11 = 1 ({} Scale factor)\n".format({"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 += "{} = {:f} (Feed definition)\n".format(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 [{}]".format(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*{}+{}]".format(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*{}]".format(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: '{}')".format(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: '{}')".format(parameters), "error") + scale[i] = float(parameters[i]) + except: + self.error("Bad parameters for scale.\n(Parameters: '{}')".format(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: '{}')".format(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: '{}')".format(parameters), "error") + axis[p] = -axis[p] + self.scale("{:f},{:f},{:f},{:f}".format(axis["x"], axis["y"], axis["z"], axis["a"])) + + +################################################################################ +# Polygon class +################################################################################ +class Polygon(object): + def __init__(self, polygon=None): + self.polygon = [] if polygon is 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 = 1e400 + miny = 1e400 + maxx = -1e400 + maxy = -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 = math.cos(a) + sin = 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 = direction[0] + cos = -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 = 0 + cy = 0 + a = 0 + for i in range(len(poly)): + [x1, y1] = poly[i - 1] + [x2, y2] = 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 = 0 + cy = 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 = poly[i - 1] + end = 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 = poly1[i1 - 1] + end = 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 + 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, 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 = poly[i - 1] + end = 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 right end + c = (p[1] - st[1]) * (end[0] - st[0]) - (end[1] - st[1]) * (p[0] - st[0]) + 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 = poly1[j1 - 1] + e = poly1[j1] + poly_ += [s] + + # Check self intersections + for j2 in range(j1 + 1, len(poly1)): + s1 = poly1[j2 - 1] + e1 = 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 = poly2[j2 - 1] + e1 = 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 = tuple(poly[i - 1]) + e = tuple(poly[i]) + if point_to_point_d2(e, s) < 0.000001: + continue + break_s = False + break_e = 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]] + 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]] + else: + edges[e] = [[e, s, l]] + 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]] + else: + edges[s] = [[s, e, l]] + + 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: + + cur = [(p[1][0] - p[0][0]) / p[2], (p[1][1] - p[0][1]) / p[2]] + cos = dot(cur, last_edge) + sin = cross(cur, last_edge) + + if angle_is_less(sin, cos, min_angle[0], min_angle[1]): + min_angle = [sin, cos] + next = p + + 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) + + 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) + + +################################################################################ +# +# Gcodetools class +# +################################################################################ + +class Gcodetools(inkex.EffectExtension): + multi_inx = True # XXX Remove this after refactoring + + 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 + + with open(os.path.join(self.options.directory, self.options.file), "w") as f: + f.write(postprocessor.gcode) + + ################################################################################ + # In/out paths: + # TODO move it to the bottom + ################################################################################ + def plasma_prepare_path(self): + self.get_info_plus() + + 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! Extension is not said to do anything! Enable one of Create in-out paths or Prepare corners checkboxes or disable Do not add in-out reference 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!") + + 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.") + + if self.selected_paths == {}: + self.error("Nothing is selected. Please select something.") + 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, path.path.to_superpath()) + csp = csp_remove_zero_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]) + 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 = subpath[j - 2] + sp2 = subpath[j - 1] + sp3 = subpath[j] + if point_to_point_d2(sp2[1], p_) < max_dist ** 2: + s1 = csp_normalized_slope(sp1, sp2, 1.) + s2 = 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] is not 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 = csp_normalized_slope(sp1, sp2, 1.) + s2 = csp_normalized_slope(sp2, sp3, 0.) + if cross(s1, s2) > corner_tolerance: + # got a corner to process + S1 = P(s1) + S2 = 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.path = CubicSuperPath(self.apply_transforms(path, res, True)) + else: + draw_csp(res, width=1, style=MARKER_STYLE["in_out_path_style"]) + + def add_arguments(self, pars): + add_argument = pars.add_argument + add_argument("-d", "--directory", default="/home/", help="Directory for gcode file") + add_argument("-f", "--filename", dest="file", default="-1.0", help="File name") + add_argument("--add-numeric-suffix-to-filename", type=inkex.Boolean, default=True, help="Add numeric suffix to filename") + add_argument("--Zscale", type=float, default="1.0", help="Scale factor Z") + add_argument("--Zoffset", type=float, default="0.0", help="Offset along Z") + add_argument("-s", "--Zsafe", type=float, default="0.5", help="Z above all obstacles") + add_argument("-z", "--Zsurface", type=float, default="0.0", help="Z of the surface") + add_argument("-c", "--Zdepth", type=float, default="-0.125", help="Z depth of cut") + add_argument("--Zstep", type=float, default="-0.125", help="Z step of cutting") + add_argument("-p", "--feed", type=float, default="4.0", help="Feed rate in unit/min") + + add_argument("--biarc-tolerance", type=float, default="1", help="Tolerance used when calculating biarc interpolation.") + add_argument("--biarc-max-split-depth", type=int, default="4", help="Defines maximum depth of splitting while approximating using biarcs.") + add_argument("--path-to-gcode-order", default="path by path", help="Defines cutting order path by path or layer by layer.") + add_argument("--path-to-gcode-depth-function", default="zd", help="Path to gcode depth function.") + add_argument("--path-to-gcode-sort-paths", type=inkex.Boolean, default=True, help="Sort paths to reduce rapid distance.") + add_argument("--comment-gcode", default="", help="Comment Gcode") + add_argument("--comment-gcode-from-properties", type=inkex.Boolean, default=False, help="Get additional comments from Object Properties") + + add_argument("--tool-diameter", type=float, default="3", help="Tool diameter used for area cutting") + add_argument("--max-area-curves", type=int, default="100", help="Maximum area curves for each area") + add_argument("--area-inkscape-radius", type=float, default="0", help="Area curves overlapping (depends on tool diameter [0, 0.9])") + add_argument("--area-tool-overlap", type=float, default="-10", help="Radius for preparing curves using inkscape") + add_argument("--unit", default="G21 (All units in mm)", help="Units") + add_argument("--active-tab", type=self.arg_method('tab'), default=self.tab_help, help="Defines which tab is active") + + add_argument("--area-fill-angle", type=float, default="0", help="Fill area with lines heading this angle") + add_argument("--area-fill-shift", type=float, default="0", help="Shift the lines by tool d * shift") + add_argument("--area-fill-method", default="zig-zag", help="Filling method either zig-zag or spiral") + + add_argument("--area-find-artefacts-diameter", type=float, default="1", help="Artefacts seeking radius") + add_argument("--area-find-artefacts-action", default="mark with an arrow", help="Artefacts action type") + + add_argument("--auto_select_paths", type=inkex.Boolean, default=True, help="Select all paths if nothing is selected.") + + add_argument("--loft-distances", default="10", help="Distances between paths.") + add_argument("--loft-direction", default="crosswise", help="Direction of loft's interpolation.") + add_argument("--loft-interpolation-degree", type=float, default="2", help="Which interpolation use to loft the paths smooth interpolation or staright.") + + add_argument("--min-arc-radius", type=float, default=".1", help="All arc having radius less than minimum will be considered as straight line") + + add_argument("--engraving-sharp-angle-tollerance", type=float, default="150", help="All angles thar are less than engraving-sharp-angle-tollerance will be thought sharp") + add_argument("--engraving-max-dist", type=float, default="10", help="Distance from original path where engraving is not needed (usually it's cutting tool diameter)") + add_argument("--engraving-newton-iterations", type=int, default="4", help="Number of sample points used to calculate distance") + add_argument("--engraving-draw-calculation-paths", type=inkex.Boolean, default=False, help="Draw additional graphics to debug engraving path") + add_argument("--engraving-cutter-shape-function", default="w", help="Cutter shape function z(w). Ex. cone: w. ") + + add_argument("--lathe-width", type=float, default=10., help="Lathe width") + add_argument("--lathe-fine-cut-width", type=float, default=1., help="Fine cut width") + add_argument("--lathe-fine-cut-count", type=int, default=1., help="Fine cut count") + add_argument("--lathe-create-fine-cut-using", default="Move path", help="Create fine cut using") + add_argument("--lathe-x-axis-remap", default="X", help="Lathe X axis remap") + add_argument("--lathe-z-axis-remap", default="Z", help="Lathe Z axis remap") + + add_argument("--lathe-rectangular-cutter-width", type=float, default="4", help="Rectangular cutter width") + + add_argument("--create-log", type=inkex.Boolean, dest="log_create_log", default=False, help="Create log files") + add_argument("--log-filename", default='', help="Create log files") + + add_argument("--orientation-points-count", default="2", help="Orientation points count") + add_argument("--tools-library-type", default='cylinder cutter', help="Create tools definition") + + add_argument("--dxfpoints-action", default='replace', help="dxfpoint sign toggle") + + add_argument("--help-language", default='http://www.cnc-club.ru/forum/viewtopic.php?f=33&t=35', help="Open help page in webbrowser.") + + add_argument("--offset-radius", type=float, default=10., help="Offset radius") + add_argument("--offset-step", type=float, default=10., help="Offset step") + add_argument("--offset-draw-clippend-path", type=inkex.Boolean, default=False, help="Draw clipped path") + add_argument("--offset-just-get-distance", type=inkex.Boolean, default=False, help="Don't do offset just get distance") + + add_argument("--postprocessor", default='', help="Postprocessor command.") + add_argument("--postprocessor-custom", default='', help="Postprocessor custom command.") + + add_argument("--graffiti-max-seg-length", type=float, default=1., help="Graffiti maximum segment length.") + add_argument("--graffiti-min-radius", type=float, default=10., help="Graffiti minimal connector's radius.") + add_argument("--graffiti-start-pos", default="(0;0)", help="Graffiti Start position (x;y).") + add_argument("--graffiti-create-linearization-preview", type=inkex.Boolean, default=True, help="Graffiti create linearization preview.") + add_argument("--graffiti-create-preview", type=inkex.Boolean, default=True, help="Graffiti create preview.") + add_argument("--graffiti-preview-size", type=int, default=800, help="Graffiti preview's size.") + add_argument("--graffiti-preview-emmit", type=int, default=800, help="Preview's paint emmit (pts/s).") + + add_argument("--in-out-path", type=inkex.Boolean, default=True, help="Create in-out paths") + add_argument("--in-out-path-do-not-add-reference-point", type=inkex.Boolean, default=False, help="Just add reference in-out point") + add_argument("--in-out-path-point-max-dist", type=float, default=10., help="In-out path max distance to reference point") + add_argument("--in-out-path-type", default="Round", help="In-out path type") + add_argument("--in-out-path-len", type=float, default=10., help="In-out path length") + add_argument("--in-out-path-replace-original-path", type=inkex.Boolean, default=False, help="Replace original path") + add_argument("--in-out-path-radius", type=float, default=10., help="In-out path radius for round path") + + add_argument("--plasma-prepare-corners", type=inkex.Boolean, default=True, help="Prepare corners") + add_argument("--plasma-prepare-corners-distance", type=float, default=10., help="Stepout distance for corners") + add_argument("--plasma-prepare-corners-tolerance", type=float, default=10., help="Maximum angle for corner (0-180 deg)") + + def __init__(self): + super(Gcodetools, self).__init__() + 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 = list(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 is None else biarc(sp1, sp2, -f(w[k][i - 1]), -f(w[k][i])) + 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 is not None: + csp = self.transform_csp(csp, layer, reverse=True) + if group is None and layer is None: + group = self.document.getroot() + elif group is None and layer is not None: + group = layer + csp = self.apply_transforms(group, csp, reverse=True) + if style is not 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=MARKER_STYLE["biarc_style"]): + self.set_markers() + + for i in [0, 1]: + sid = 'biarc{}_r'.format(i) + style[sid] = style['biarc{}'.format(i)].copy() + style[sid]["marker-start"] = "url(#DrawCurveMarker_r)" + del style[sid]["marker-end"] + + if group is None: + group = self.layers[min(1, len(self.layers) - 1)].add(Group(gcodetools="Preview group")) + if not hasattr(self, "preview_groups"): + self.preview_groups = {layer: group} + elif layer not in self.preview_groups: + self.preview_groups[layer] = group + group = self.preview_groups[layer] + + s = '' + arcn = 0 + + transform = self.get_transforms(group) + if transform: + transform = self.reverse_transform(transform) + transform = str(Transform(transform)) + + a = [0., 0.] + b = [1., 0.] + c = [0., 1.] + k = (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]) + a = self.transform(a, layer, True) + b = self.transform(b, layer, True) + c = 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] = self.transform(si[0], layer, True) + si[2] = 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': + elem = group.add(PathElement(gcodetools="Preview")) + elem.transform = transform + elem.style = style['line'] + elem.path = 'M {},{} L {},{}'.format(s[0][0], s[0][1], si[0][0], si[0][1]) + 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()) % TAU # s[3] + if s[3] * a < 0: + if a > 0: + a = a - TAU + else: + a = TAU + 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) + if a > 0: + a_end = a_st + a + st = style['biarc{}'.format(arcn % 2)] + else: + a_end = a_st * 1 + a_st = a_st + a + st = style['biarc{}_r'.format(arcn % 2)] + + elem = group.add(PathElement.arc(c, r, start=a_st, end=a_end, + open=True, gcodetools="Preview")) + elem.transform = transform + elem.style = st + + s = si + + def check_dir(self): + print_("Checking directory: '{}'".format(self.options.directory)) + if os.path.isdir(self.options.directory): + if os.path.isfile(os.path.join(self.options.directory, 'header')): + with open(os.path.join(self.options.directory, 'header')) as f: + self.header = f.read() + else: + self.header = defaults['header'] + if os.path.isfile(os.path.join(self.options.directory, 'footer')): + with open(os.path.join(self.options.directory, 'footer')) as f: + self.footer = f.read() + 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"^{}_0*(\d+){}$".format(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 + + try: + with open(os.path.join(self.options.directory, self.options.file), "w") as f: + pass + except: + self.error("Can not write to specified file!\n{}".format(os.path.join(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 = [" X", " Y", " Z", " I", " J", " K"] + s1 = ["", "", "", "", "", ""] + m = [1, 1, self.options.Zscale * Zauto_scale, 1, 1, self.options.Zscale * Zauto_scale] + a = [0, 0, self.options.Zoffset, 0, 0, 0] + r = '' + for i in range(6): + if c[i] is not None: + r += s[i] + ("{:f}".format(c[i] * m[i] + a[i])) + s1[i] + return r + + def calculate_angle(a, current_a): + return min( + [abs(a - current_a % TAU + TAU), a + current_a - current_a % TAU + TAU], + [abs(a - current_a % TAU - TAU), a + current_a - current_a % TAU - TAU], + [abs(a - current_a % TAU), a + current_a - current_a % TAU])[1] + + if len(curve) == 0: + return "" + + try: + self.last_used_tool is None + except: + self.last_used_tool = None + print_("working on curve") + print_(curve) + + if tool != self.last_used_tool: + g += ("(Change tool to {})\n".format(re.sub("\"'\\(\\)\\\\", " ", tool["name"]))) + tool["tool change gcode"] + "\n" + + lg = 'G00' + zs = self.options.Zsafe + f = " F{:f}".format(tool['feed']) + current_a = 0 + go_to_safe_distance = "G00" + c([None, None, zs]) + "\n" + penetration_feed = " F{}".format(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 = curve[i - 1] + si = 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{}\n".format(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{}\n".format(a * tool['4th axis scale'] + tool['4th axis offset']) + current_a = a + axis4 = " A{}".format((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 = (P(s[0]) - P(s[2])) + r2 = (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}".format(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{}\n".format(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 = Transform(t).matrix + trans = (Transform(t) * Transform(trans)).matrix 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: + # TODO: This was applyTransformToPath but was deprecated. Candidate for refactoring. + for comp in csp: + for ctl in comp: + for pt in ctl: + pt[0], pt[1] = Transform(trans).apply_to_point(pt) + + else: + # TODO: This was applyTransformToPath but was deprecated. Candidate for refactoring. + for comp in csp: + for ctl in comp: + for pt in ctl: + pt[0], pt[1] = Transform(self.reverse_transform(trans)).apply_to_point(pt) + 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 '{}' layer have not been found! Please add orientation points using Orientation tab!".format(layer.label), "error") + 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 '{}' layer".format(orientation_layer.label)) + 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 '{orientation_layer.label}' Orientation points: ") + 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.)", "error") + 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.)", "error") + + self.transform_matrix_reverse[layer] = numpy.linalg.inv(self.transform_matrix[layer]).tolist() + print_("\n Layer '{}' transformation matrixes:".format(layer.label)) + print_(self.transform_matrix) + print_(self.transform_matrix_reverse) + + # Zautoscale is obsolete + self.Zauto_scale[layer] = 1 + print_("Z automatic scale = {} (computed according orientation points)".format(self.Zauto_scale[layer])) + + x = source_point[0] + y = 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 + + def error(self, s, msg_type="warning"): + """ + Errors handling function + warnings are printed into log file and warning message is displayed but + extension continues working, + errors causes log and execution is halted + """ + if msg_type == "warning": + print_(s) + inkex.errormsg(s + "\n") + + elif msg_type == "error": + print_(s) + raise inkex.AbortExtension(s) + + else: + print_("Unknown message type: {}".format(msg_type)) + print_(s) + raise inkex.AbortExtension(s) + + ################################################################################ + # Set markers + ################################################################################ + def set_markers(self): + """Make sure all markers are available""" + def ensure_marker(elem_id, x=-4, polA='', polB='-', fill='#000044'): + if self.svg.getElementById(elem_id) is None: + marker = self.svg.defs.add(Marker( + id=elem_id, orient="auto", refX=str(x), refY="-1.687441", + style="overflow:visible")) + path = marker.add(PathElement( + d="m {0}4.588864,-1.687441 0.0,0.0 L {0}9.177728,0.0 "\ + "c {1}0.73311,-0.996261 {1}0.728882,-2.359329 0.0,-3.374882"\ + .format(polA, polB))) + path.style = "fill:{};fill-rule:evenodd;stroke:none;".format(fill) + + ensure_marker("CheckToolsAndOPMarker") + ensure_marker("DrawCurveMarker") + ensure_marker("DrawCurveMarker_r", x=4, polA='-', polB='') + ensure_marker("InOutPathMarker", fill='#0072a7') + + def get_info(self): + """Get Gcodetools info from the svg""" + 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.svg.selected[i.get("id")] = i + if isinstance(i, Layer): + if i.label == '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 is not None: + self.orientation_points[layer] = self.orientation_points[layer] + [points[:]] if layer in self.orientation_points else [points[:]] + print_("Found orientation points in '{}' layer: {}".format(layer.label, points)) + else: + self.error("Warning! Found bad orientation points in '{}' layer. Resulting Gcode could be corrupt!".format(layer.label)) + + # Need to recognise old files ver 1.6.04 and earlier + elif i.get("gcodetools") == "Gcodetools tool definition" or i.get("gcodetools") == "Gcodetools tool definition": + 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 '{}' layer: {}".format(layer.label, 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 '{}' layer. Resulting Gcode could be corrupt!".format(layer.label)) + + elif isinstance(i, inkex.PathElement): + 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.svg.selected.ids: + 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, j.path.to_superpath())[0][0][1]) + + elif isinstance(i, inkex.Group): + recursive_search(i, layer, (i.get("id") in self.svg.selected)) + + elif i.get("id") in self.svg.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!\n" + "Solution 1: press Path->Object to path or Shift+Ctrl+C.\n" + "Solution 2: Path->Dynamic offset or Ctrl+J.\n" + "Solution 3: export all contours to PostScript level 2 (File->Save As->.ps) and File->Import this file.") + + 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.") + + 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 isinstance(i, inkex.Group): + if i.get("gcodetools") == "Gcodetools orientation point (2 points)": + p2 += [i] + if i.get("gcodetools") == "Gcodetools orientation point (3 points)": + p3 += [i] + if len(p2) == 2: + p = p2 + elif len(p3) == 3: + p = p3 + if p is None: + return None + points = [] + for i in p: + point = [[], []] + for node in i: + if node.get('gcodetools') == "Gcodetools orientation point arrow": + csp = node.path.transform(node.composed_transform()).to_superpath() + point[0] = csp[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*', node.get_text()) + 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, node.path.to_superpath())[0][0][1] + if node.get('gcodetools') == "Gcodetools graffiti reference point text": + point[1] = node.get_text() + 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"] = dict(inkex.Style.parse_str(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 = j.get_text() + if j.get("gcodetools") == "Gcodetools tool definition field value" or j.get("gcodetools") == "Gcodetools tool defention field value": + value = j.get_text() + if value == "(None)": + value = "" + if value is None or key is None: + continue + 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 ({}) types are not the same ( type('{}') != type('{}') ).".format(key, value, self.default_tool[key])) + else: + tool[key] = value + self.error("Warning! Tool has parameter that default tool has not ( '{}': '{}' ).".format(key, value)) + return tool + + def set_tool(self, layer): + for i in range(self.layers.index(layer), -1, -1): + 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: + label = self.layers[i].label + self.error("Layer '{}' contains more than one tool!".format(label)) + return self.tools[layer] + else: + self.error("Can not find tool for '{}' layer! Please add one with Tools library tab!".format(layer.label), "error") + + ################################################################################ + # + # Path to Gcode + # + ################################################################################ + def tab_path_to_gcode(self): + self.get_info_plus() + def get_boundaries(points): + minx = None + miny = None + maxx = None + maxy = None + out = [[], [], [], []] + for p in points: + if minx == p[0]: + out[0] += [p] + if minx is None or p[0] < minx: + minx = p[0] + out[0] = [p] + + if miny == p[1]: + out[1] += [p] + if miny is None or p[1] < miny: + miny = p[1] + out[1] = [p] + + if maxx == p[0]: + out[2] += [p] + if maxx is None or p[0] > maxx: + maxx = p[0] + out[2] = [p] + + if maxy == p[1]: + out[3] += [p] + if maxy is 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) + 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 + ] + minimal_way = [] + minimal_len = None + for w in ways: + tpoints = points[:] + cw = [] + for j in xrange(0, len(points)): + p = get_boundaries(get_boundaries(tpoints)[w[0]])[w[1]] + tpoints.remove(p[0]) + cw += p + curlen = get_way_len(cw) + if minimal_len is None or curlen < minimal_len: + minimal_len = curlen + minimal_way = cw + + 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".format(self.options.Zsafe, point[0], point[1], self.Zcoordinates[layer][1], self.tools[layer][0]["penetration feed"], 0.2, self.options.Zsafe) + return gcode + + def get_path_properties(node): + res = {} + done = False + while not done and node != self.svg: + for i in node.getchildren(): + if isinstance(i, inkex.Desc): + res["Description"] = i.text + elif isinstance(i, inkex.Title): + res["Title"] = 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.") + else: + paths = self.selected_paths + self.check_dir() + gcode = "" + + parent = list(self.selected_paths)[0] if self.selected_paths else self.layers[0] + biarc_group = parent.add(Group()) + 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)!") + continue + csp = path.path.to_superpath() + 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("{}: {}".format(tag, tags[tag])) + + style = dict(inkex.Style.parse_str(path.get("style"))) + colors[id_] = inkex.Color(style['stroke'] if "stroke" in style and style['stroke'] != 'none' else "#000").to_rgb() + 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})".format(x, y)) + dxfpoints += [[x, y]] + else: + + zd = self.Zcoordinates[layer][1] + zs = 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] + ] + ] + 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, 1 + 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: {}".format(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: {}\n\n".format(curves[key][0][0])) + + else: # pass by pass + mind = min([curve[0][1] for curve in curves]) + for step in range(0, 1 + 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 {})\n".format(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: {}".format(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: {}\n\n".format(curves[key][0][0])) + + self.export_gcode(gcode) + + ################################################################################ + # + # dxfpoints + # + ################################################################################ + def tab_dxfpoints(self): + self.get_info_plus() + if self.selected_paths == {}: + self.error("Nothing is selected. Please select something to convert to drill point (dxfpoint) or clear point sign.") + for layer in self.layers: + if layer in self.selected_paths: + for path in self.selected_paths[layer]: + if self.options.dxfpoints_action == 'replace': + + path.set("dxfpoint", "1") + r = re.match("^\\s*.\\s*(\\S+)", path.get("d")) + if r is not None: + print_(("got path=", r.group(1))) + path.set("d", "m {} 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".format(r.group(1))) + path.set("style", MARKER_STYLE["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") + + ################################################################################ + # + # Artefacts + # + ################################################################################ + def tab_area_artefacts(self): + self.get_info_plus() + 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.") + else: + paths = self.selected_paths + for layer in paths: + for path in paths[layer]: + parent = path.getparent() + 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)!") + continue + csp = path.path.to_superpath() + 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 = Path('m {},{} 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'.format(subpath[0][1][0], subpath[0][1][1])).to_superpath() + arrow = self.apply_transforms(path, arrow, True) + node = parent.add(PathElement()) + node.path = CubicSuperPath(arrow) + node.style = MARKER_STYLE["area artefact arrow"] + node.set('gcodetools', 'area artefact arrow') + elif self.options.area_find_artefacts_action == "mark with style": + node = parent.add(PathElement()) + node.path = CubicSuperPath(csp[i]) + node.style = MARKER_STYLE["area artefact"] + remove.append(i) + elif self.options.area_find_artefacts_action == "delete": + remove.append(i) + print_("Deleted artefact {}".format(subpath)) + remove.reverse() + for i in remove: + del csp[i] + if len(csp) == 0: + parent.remove(path) + else: + path.path = CubicSuperPath(csp) + + return + + def tab_area(self): + """Calculate area curves""" + self.get_info_plus() + if len(self.selected_paths) <= 0: + self.error("This extension requires at least one selected path.") + 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 '{}' layer is not!".format(layer.label), "error") + + for path in self.selected_paths[layer]: + print_(("doing path", path.get("style"), path.get("d"))) + + area_group = path.getparent().add(Group()) + + csp = path.path.to_superpath() + print_(csp) + if not csp: + print_("omitting non-path") + self.error("Warning: omitting non-path") + continue + + if path.get('sodipodi:type') != "inkscape:offset": + print_("Path {} is not an offset. Preparation started.".format(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 beginning 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[:] + + # What the absolute fudge is this doing? Closing paths? Ugh. + d = str(CubicSuperPath(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)) + 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 = {}, r = {}".format(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 + + elem = area_group.add(PathElement(style=MARKER_STYLE["biarc_style_i"]['area'])) + elem.set('sodipodi:type', 'inkscape:offset') + elem.set('inkscape:radius', radius) + elem.set('inkscape:original', d) + print_(("adding curve", area_group, d, MARKER_STYLE["biarc_style_i"]['area'])) + if radius == -r: + break + + def tab_area_fill(self): + """Fills area with lines""" + self.get_info_plus() + # 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.") + 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 '{}' layer is not!".format(layer.label), "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 = path.getparent().add(Group()) + csp = path.path.to_superpath() + if not csp: + print_("omitting non-path") + self.error("Warning: omitting non-path") + continue + csp = self.apply_transforms(path, csp) + csp = csp_close_all_subpaths(csp) + csp = self.transform_csp(csp, layer) + + # 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 = bounds[k][2] + j = bounds[k][3] + t = 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 not 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 = b[2] - b[0] + self.options.area_fill_shift * r + h = b[3] - b[1] + self.options.area_fill_shift * r + x = b[0] - self.options.area_fill_shift * r + y = 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 = csp[i][j - 1] + sp2 = 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]] + + 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 = splitted_line[i][0] + l2 = splitted_line[i][1] + p = [(l1[0] + l2[0]) / 2, (l1[1] + l2[1]) / 2] + if not point_inside_csp(p, csp): + del splitted_line[i] + else: + i += 1 + + # 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) + + ################################################################################ + # + # 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 = self.svg.add(Layer.new('layername')) + # + # group appears in XML as <svg:g id="gnnnnn"> where nnnnn is a number + # + # to create it, use + # Mygroup = parent.add(Group(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 tab_engraving(self): + self.get_info_plus() + global cspm + global wl + global nlLT + global i + global j + global gcode_3Dleft + global 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(nxy1, nxy2): + """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 + """ + (nx1, ny1) = nxy1 + (nx2, ny2) = nxy2 + 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(xy1, n_xy1, n_xy2, xy2, n_xy23, xy3, n_xy3): + """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 + """ + (x1, y1) = xy1 + (nx1, ny1) = n_xy1 + (nx2, ny2) = n_xy2 + (x2, y2) = xy2 + (nx23, ny23) = n_xy23 + (x3, y3) = xy3 + (nx3, ny3) = n_xy3 + 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(xy1, n_xy, xy2): + """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. + """ + (x1, y1) = xy1 + (nx, ny) = n_xy + (x2, y2) = xy2 + global max_dist + + # Start by converting coordinates to be relative to x1,y1 + x2 = x2 - x1 + y2 = 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 + 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 + 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(nxy1, nxy2): + """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 + """ + (x1, y1) = nxy1 + (nx, ny) = nxy2 + global max_dist + global nlLT + global i + global j + + n1 = nlLT[j][i - 1] # current node + jjmin = -1 + iimin = -1 + r = max_dist + # set limits within which to look for lines + xmin = x1 + r * nx - r + xmax = x1 + r * nx + r + ymin = y1 + r * ny - r + ymax = 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]) + 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 = min(x2, x3) + x23max = max(x2, x3) + y23min = min(y2, y3) + y23max = 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)) + if 0 <= t1 < r: + r = t1 + iimin = ii + jjmin = jj + xmin = x1 + r * nx - r + xmax = x1 + r * nx + r + ymin = y1 + r * ny - r + ymax = y1 + r * ny + r + # next ii + # next jj + return jjmin, iimin, r + # end of get_biggest + + def line_divide(xy0, j0, i0, xy1, j1, i1, n_xy, 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 + + """ + (x0, y0) = xy0 + (x1, y1) = xy1 + (nx, ny) = n_xy + global nlLT + global i + global j + global 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(xy, 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 intermediate points. + """ + (x, y) = xy + global wl + global 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: + cspm.pop() + wl.pop() + cspm += [[[x, y], [x, y], [x, y], i, j, ii, jj]] + wl += [w] + # end of save_point + + def draw_point(xy0, xy, 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. + """ + (x0, y0) = xy0 + (x, y) = xy + global gcode_3Dleft + global gcode_3Dright + if self.options.engraving_draw_calculation_paths: + elem = engraving_group.add(PathElement.arc((x, y), 1)) + elem.set('gcodetools', "Engraving calculation toolpath") + elem.style = "fill:#ff00ff; fill-opacity:0.46; stroke:#000000; stroke-width:0.1;" + + # Don't draw zero radius circles + if w: + elem = engraving_group.add(PathElement.arc((x, y), w)) + elem.set('gcodetools', "Engraving calculation paths") + elem.style = "fill:none; fill-opacity:0.46; stroke:#000000; stroke-width:0.1;" + + # 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)))) + style = "stroke:{}; stroke-opacity:1;stroke-width:{};fill:none".format(s2, t/2) + right = gcode_3Dleft.add(PathElement(style=style, gcodetools="Gcode G1R")) + right.path = "M {:f},{:f} L {:f},{:f}".format( + x0 - eye_dist, y0, x - eye_dist - 0.14 * w, y) + left = gcode_3Dright.add(PathElement(style=style, gcodetools="Gcode G1L")) + left.path = "M {:f},{:f} L {:f},{:f}".format( + x0 + eye_dist, y0, x + eye_dist + 0.14 * r, y) + + # end of subfunction definitions. engraving() starts here: + gcode = '' + r = 0 # theoretical and tool-radius-limited radii in pixels + w = 0 + wmax = 0 + cspe = [] + we = [] + if not self.selected_paths: + self.error("Please select at least one path to engrave and run again.") + 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") + 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 and layer in self.orientation_points: + # 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 '{}' has no shape. 45 degree cone assumed!".format(self.tools[layer][0]['name'])) + 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 = self.selected_paths[layer][0].getparent().add(Group()) + if self.options.engraving_draw_calculation_paths and (self.my3Dlayer is None): + self.svg.add(Layer.new("3D")) + # Create groups for left and right eyes + if self.options.engraving_draw_calculation_paths: + gcode_3Dleft = self.my3Dlayer.add(Group(gcodetools="Gcode 3D L")) + gcode_3Dright = self.my3Dlayer.add(Group(gcodetools="Gcode 3D R")) + + for node in self.selected_paths[layer]: + if isinstance(node, inkex.PathElement): + cspi = node.path.to_superpath() + # 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 + sp0 = csp[i - 2] + sp1 = csp[i - 1] + sp2 = 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.") + + 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.") + 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 + cspl += [cspl[0]] # Close paths + cspr += [cspr[0]] # Close paths + style = "stroke:#808080; stroke-opacity:1; stroke-width:0.6; fill:none" + elem = gcode_3Dleft.add(PathElement(style=style, gcodetools="G1L outline")) + elem.path = CubicSuperPath([cspl]) + elem = gcode_3Dright.add(Pathelement(style=style, gcodetools="G1R outline")) + elem.path = CubicSuperPath([cspr]) + + for p in nlLT[-1]: # For last sub-path + if p[2]: + elem = engraving_group.add(PathElement(gcodetools="Engraving normals")) + elem.path = "M {:f},{:f} L {:f},{:f}".format(p[0][0], p[0][1], + p[0][0] + p[1][0] * 10, p[0][1] + p[1][1] * 10) + elem.style = "stroke:#f000af; stroke-opacity:0.46; stroke-width:0.1; fill:none" + else: + elem = engraving_group.add(PathElement(gcodetools="Engraving bisectors")) + elem.path = "M {:f},{:f} L {:f},{:f}".format(p[0][0], p[0][1], + p[0][0] + p[1][0] * 10, p[0][1] + p[1][1] * 10) + elem.style = "stroke:#0000ff; stroke-opacity:0.46; stroke-width:0.1; fill:none" + + # LT6a build nlLT[j] for each subpath - ends here + # 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]: # 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 + 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) + 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]: # 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: + node = engraving_group.add(PathElement( + gcodetools="Engraving calculation paths", + style=MARKER_STYLE["biarc_style_i"]['biarc1'])) + node.path = CubicSuperPath([cspm]) + for i in xrange(len(cspm)): + elem = engraving_group.add(PathElement.arc(cspm[i][1], wl[i])) + elem.set('gcodetools', "Engraving calculation paths") + elem.style = "fill:none;fill-opacity:0.46;stroke:#000000;stroke-width:0.1;" + 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 + # 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.") + + ################################################################################ + # + # Orientation + # + ################################################################################ + def tab_orientation(self, layer=None): + self.get_info() + + if layer is None: + layer = self.svg.get_current_layer() if self.svg.get_current_layer() is not None else self.document.getroot() + + transform = self.get_transforms(layer) + if transform: + transform = self.reverse_transform(transform) + transform = str(Transform(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 + group = layer.add(Group(**attr)) + elem = group.add(PathElement(style="stroke:none;fill:#00ff00;")) + elem.set('gcodetools', "Gcodetools graffiti reference point arrow") + elem.path = 'm {},{} 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.8125000000'\ + '01 z z'.format(graffiti_reference_points_count * 100, 0) + + 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.svg.get_current_layer(), x=self.svg.namedview.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!", "error") + + attr = {"gcodetools": "Gcodetools orientation group"} + if transform: + attr["transform"] = transform + + orientation_group = layer.add(Group(**attr)) + doc_height = self.svg.unittouu(self.document.getroot().get('height')) + if self.document.getroot().get('height') == "100%": + doc_height = 1052.3622047 + print_("Overriding height from 100 percents to {}".format(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.]] + elif self.options.unit == "G20 (All units in inches)": + points = [[0., 0., self.options.Zsurface], [5., 0., self.options.Zdepth], [0., 5., 0.]] + if self.options.orientation_points_count == "2": + points = points[:2] + for i in points: + name = "Gcodetools orientation point ({} points)".format( + self.options.orientation_points_count) + grp = orientation_group.add(Group(gcodetools=name)) + elem = grp.add(PathElement(style="stroke:none;fill:#000000;")) + elem.set('gcodetools', "Gcodetools orientation point arrow") + elem.path = 'm {},{} 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.812500000'\ + '001 z'.format(i[0], -i[1] + doc_height) + + draw_text("({}; {}; {})".format(i[0], i[1], i[2]), (i[0] + 10), (-i[1] - 10 + doc_height), group=grp, gcodetools_tag="Gcodetools orientation point text") + + ################################################################################ + # + # Tools library + # + ################################################################################ + def tab_tools_library(self, layer=None): + self.get_info() + + if self.options.tools_library_type == "check": + return self.check_tools_and_op() + + # Add a tool to the drawing + if layer is None: + layer = self.svg.get_current_layer() if self.svg.get_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!", "error") + + 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 = layer.add(Group(gcodetools="Gcodetools tool definition")) + bg = tools_group.add(PathElement(gcodetools="Gcodetools tool background")) + bg.style = "fill-opacity:0.5;stroke:#444444;" + bg.style['fill'] = colors[tool_num % len(colors)] + + 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 = tools_group.add(Group(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 ".format(y + 50)) + tools_group.transform.add_translate(*self.svg.namedview.center) + tools_group.transform.add_translate(-150, 0) + + ################################################################################ + # + # Check tools and OP assignment + # + ################################################################################ + def check_tools_and_op(self): + if len(self.svg.selected) <= 0: + self.error("Selection is empty! Will compute whole drawing.") + paths = self.paths + else: + paths = self.selected_paths + # Set group + parent = self.selected_paths.keys()[0] if len(self.selected_paths.keys()) > 0 else self.layers[0] + group = parent.add(Group()) + 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")] + for path in paths[layer]: + group.insert(0, PathElement(**path.attrib)) + new = group.getchildren()[0] + new.style = Style( + stroke='#000044', stroke_width=1, + marker_mid='url(#CheckToolsAndOPMarker)', + fill=tool["style"].get('fill', '#00ff00'), + fill_opacity=tool["style"].get('fill-opacity', 0.5)) + + trans = trans_ * self.get_transforms(path) + csp = path.path.transform(trans).to_superpath() + + path_bounds = csp_simple_bound(csp) + trans = str(Transform(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 assignment" + trans = [[1, 0.3, bounds[2]], [0, 0.5, tools_bounds[layer][0]]] + g.set("transform", str(Transform(trans))) + group.insert(0, g) + + ################################################################################ + # TODO Launch browser on help tab + ################################################################################ + def tab_help(self): + self.error("Tutorials, manuals and support can be found at\n" + " English support forum:\n" + " http://www.cnc-club.ru/gcodetools\n" + "and Russian support forum:\n" + " http://www.cnc-club.ru/gcodetoolsru") + return + + def tab_about(self): + return self.tab_help() + + def tab_preferences(self): + return self.tab_help() + + ################################################################################ + # Lathe + ################################################################################ + def generate_lathe_gcode(self, subpath, layer, feed_type): + if len(subpath) < 2: + return "" + feed = " F {:f}".format(self.tool[feed_type]) + x = self.options.lathe_x_axis_remap + z = 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_ = alias[x] + k_ = alias[z] + c = [[subpath[0][1], "move", 0, 0, 0]] + 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=MARKER_STYLE["biarc_style_lathe_{}".format(feed_type)]) + + gcode = ("G01 {} {:f} {} {:f}".format(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 {} {:f} {} {:f}".format(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 = (P(s[0]) - P(s[2])) + r2 = (P(s[4]) - P(s[2])) + if abs(r1.mag() - r2.mag()) < 0.001: + gcode += ("G02" if s[3] * flip_angle < 0 else "G03") + (" {} {:f} {} {:f} {} {:f} {} {:f}".format(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") + (" {} {:f} {} {:f}".format(x, s[4][0], z, s[4][1])) + " R{:f}".format(r) + feed + "\n" + return gcode + + def tab_lathe(self): + self.get_info_plus() + if not self.check_dir(): + return + x = self.options.lathe_x_axis_remap + z = 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...") + return + if x.lower() == z.lower(): + self.error("Lathe X and Z axis remap should be the same. Exiting...") + 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 = x + self.options.lathe_z_axis_remap = 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 {})\n".format(re.sub("\"'\\(\\)\\\\", " ", self.tool["name"]))) + self.tool["tool change gcode"] + "\n" + + for path in paths[layer]: + csp = self.transform_csp(path.path.to_superpath(), 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 = subpath[-1][1][0] + right = 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]) + # Join offsetted_subpath together + # Hope there won't be any circles + subpath = csp_join_subpaths(offsetted_subpath)[0] + + # Create solid object from path and lathe_width + bound = csp_simple_bound([subpath]) + top_start = [subpath[0][1][0], self.options.lathe_width + self.options.Zsafe + self.options.lathe_fine_cut_width] + top_end = [subpath[-1][1][0], self.options.lathe_width + self.options.Zsafe + self.options.lathe_fine_cut_width] + + gcode += ("G01 {} {:f} F {:f} \n".format(z, top_start[1], self.tool["passing feed"])) + gcode += ("G01 {} {:f} {} {:f} F {:f} \n".format(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 = subpath[j - 1] + sp2 = 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 = [fine_cut[0][1][0], self.options.lathe_width + self.options.Zsafe + self.options.lathe_fine_cut_width] + top_end = [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 {})\n".format(self.options.lathe_create_fine_cut_using) + for i in range(int(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 = fine_cut[-1][1][0] + right = 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 {:d}-th cicle start)\n".format(i + 1) + gcode += ("G01 {} {:f} {} {:f} F {:f} \n".format(x, top_start[0], z, top_start[1], self.tool["passing feed"])) + gcode += ("G01 {} {:f} {} {:f} F {:f} \n".format(x, current_pass[0][1][0], z, current_pass[0][1][1] + self.options.lathe_fine_cut_width, self.tool["passing feed"])) + gcode += ("G01 {} {:f} {} {:f} F {:f} \n".format(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 {} {:f} F {:f} \n".format(z, top_start[1], self.tool["passing feed"])) + gcode += ("G01 {} {:f} {} {:f} F {:f} \n".format(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 tab_lathe_modify_path(self): + self.get_info() + 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.") + else: + paths = self.selected_paths + + for layer in self.layers: + if layer in paths: + width = self.options.lathe_rectangular_cutter_width + for path in paths[layer]: + csp = self.transform_csp(path.path.to_superpath(), layer) + new_csp = [] + for subpath in csp: + orientation = subpath[-1][1][0] > subpath[0][1][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 horizontal 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 horizontal straight 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) + + ################################################################################ + # Graffiti function generates Gcode for graffiti drawer + ################################################################################ + def tab_graffiti(self): + self.get_info_plus() + # 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 += " {} {:f}".format(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 = self.graffiti_reference_points[layer][0][0] + c2 = 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 = start[0] * (1 - t) + end[0] * t + r2 = 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 = P(p1) + P2 = P(p2) + N1 = P(rotate_ccw(t1)) + N2 = P(rotate_ccw(t2)) + r = self.options.graffiti_min_radius + C1 = P1 + N1 * r + C2 = 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 = P1 + N1 * r + C2 = 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 = Dc.x / dc + sin = Dc.y / dc + + 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.") + else: + paths = self.selected_paths + self.tool = [] + gcode = """(Header) +(Generated by gcodetools from Inkscape.) +(Using graffiti extension.) +(Header end.)""" + + minx = float("inf") + miny = float("inf") + maxx = float("-inf") + maxy = 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 is None: + self.error('There are no graffiti reference points for layer {}'.format(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 {} axis)\n".format(point[0][0], point[0][1], point[1]) + + if self.options.graffiti_create_preview: + for point in self.graffiti_reference_points[layer]: + minx = min(minx, point[0][0]) + miny = min(miny, point[0][1]) + maxx = max(maxx, point[0][0]) + maxy = max(maxy, point[0][1]) + for path in paths[layer]: + csp = path.path.to_superpath() + csp = self.apply_transforms(path, csp) + csp = self.transform_csp(csp, layer) + bounds = csp_simple_bound(csp) + minx = min(minx, bounds[0]) + miny = min(miny, bounds[1]) + maxx = max(maxx, bounds[2]) + maxy = max(maxy, bounds[3]) + + if self.options.graffiti_create_preview: + self.graffiti_preview = list([[255] * (4 * self.options.graffiti_preview_size) for _ 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 _ in range(3)] + last_sp2 = [start_point for _ 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 {})\n".format(re.sub("\"'\\(\\)\\\\", " ", self.tool["name"]))) + self.tool["tool change gcode"] + "\n" + + subpaths = [] + for path in paths[layer]: + # Rebuild the paths to polyline. + csp = path.path.to_superpath() + 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 is not 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 = sp1 + last_sp2 = sp2 + + # Add return to start_point + if not polylines: + continue + polylines += [["connect1", [[polylines[-1][1][-1][1] for _ in range(3)], [start_point for _ in range(3)]]]] + + # Make polylines 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)) + + # Export polyline to gcode + # we are making transform from XYZA coordinates to R1...Rn + # where R1...Rn are radius vectors from graffiti 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".format(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) + with open(os.path.join(self.options.directory, self.options.file + ".png"), 'wb') as f: + writer.write(f, self.graffiti_preview) + + except: + self.error("Png module have not been found!") + + def get_info_plus(self): + """Like get_info(), but checks some of the values""" + self.get_info() + if self.orientation_points == {}: + self.error("Orientation points have not been defined! A default set of orientation points has been automatically added.") + self.tab_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.") + self.options.tools_library_type = "default" + self.tab_tools_library(self.layers[min(1, len(self.layers) - 1)]) + self.get_info() + + ################################################################################ + # + # 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) + with open(self.options.log_filename, "a") as fhl: + fhl.write("""Gcodetools log file. +Started at {}. +{} +""".format(time.strftime("%d.%m.%Y %H:%M:%S"), options.log_filename)) + except: + print_ = lambda *x: None + else: + print_ = lambda *x: None + + # This automatically calls any `tab_{tab_name_in_inx}` which in this + # extension is A LOT of different functions. So see all method prefixed + # with tab_ to find out what's supported here. + self.options.active_tab() + + print_("------------------------------------------") + print_("Done in {:f} seconds".format(time.time() - start_time)) + print_("End at {}.".format(time.strftime("%d.%m.%Y %H:%M:%S"))) + + + def tab_offset(self): + self.get_info() + if self.options.offset_just_get_distance: + for layer in self.selected_paths: + if len(self.selected_paths[layer]) == 2: + csp1 = self.selected_paths[layer][0].path.to_superpath() + csp2 = self.selected_paths[layer][1].path.to_superpath() + 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(path.path.to_superpath(), offset) + offsets_count += 1 + if offset_: + for iii in offset_: + draw_csp([iii], width=1) + else: + print_("------------Reached empty offset at radius {}".format(offset)) + break + offset += self.options.offset_step + print_() + print_("-----------------------------------------------------------------------------------") + print_("-----------------------------------------------------------------------------------") + print_("-----------------------------------------------------------------------------------") + print_() + print_("Done in {}".format(time.time() - time_)) + print_("Total offsets count {}".format(offsets_count)) + + +if __name__ == '__main__': + Gcodetools().run() |