FabLab_Chemnitz/mightyscape-1.1-deprecated
FabLab_Chemnitz/mightyscape-1.1-deprecated
Archived
1
0
Fork 0
Code Issues Pull Requests Releases Activity
This repository has been archived on 2023-03-25. You can view files and clone it, but cannot push or open issues or pull requests.
d95e0ce262
mightyscape-1.1-deprecated/extensions/fablabchemnitz/path2flex/path2flex.py

1355 lines
62 KiB
Python
Raw Normal View History

Initial commit
2020-07-30 01:16:18 +02:00
#!/usr/bin/env python3
# paths2flex.py
# This is an Inkscape extension to generate boxes with sides as flex which follow a path selected in inkscape
# The Inkscape objects must first be converted to paths (Path > Object to Path).
# Some paths may not work well -- if the curves are too small for example.
# Written by Thierry Houdoin (thierry@fablab-lannion.org), december 2018
# This work is largely inspred from path2openSCAD.py, written by Daniel C. Newman
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import math
import os.path
import inkex
import re
from lxml import etree
from inkex import bezier
from inkex.paths import Path, CubicSuperPath
DEFAULT_WIDTH = 100
DEFAULT_HEIGHT = 100
objStyle = str(inkex.Style(
{'stroke': '#000000',
'stroke-width': 0.1,
'fill': 'none'
}))
objStyleStart = str(inkex.Style(
{'stroke': '#FF0000',
'stroke-width': 0.1,
'fill': 'none'
}))
class inkcape_draw_cartesian:
def __init__(self, Offset, group):
self.offsetX = Offset[0]
self.offsetY = Offset[1]
self.Path = ''
self.group = group
def MoveTo(self, x, y):
#Retourne chaine de caractères donnant la position du point avec des coordonnées cartesiennes
self.Path += ' M ' + str(round(x-self.offsetX, 3)) + ',' + str(round(y-self.offsetY, 3))
def LineTo(self, x, y):
#Retourne chaine de caractères donnant la position du point avec des coordonnées cartesiennes
self.Path += ' L ' + str(round(x-self.offsetX, 3)) + ',' + str(round(y-self.offsetY, 3))
def Line(self, x1, y1, x2, y2):
#Retourne chaine de caractères donnant la position du point avec des coordonnées cartesiennes
self.Path += ' M ' + str(round(x1-self.offsetX, 3)) + ',' + str(round(y1-self.offsetY, 3)) + ' L ' + str(round(x2-self.offsetX, 3)) + ',' + str(round(y2-self.offsetY, 3))
def GenPath(self):
line_attribs = {'style': objStyle, 'd': self.Path}
etree.SubElement(self.group, inkex.addNS('path', 'svg'), line_attribs)
def GenPathStart(self):
line_attribs = {'style': objStyleStart, 'd': self.Path}
etree.SubElement(self.group, inkex.addNS('path', 'svg'), line_attribs)
class Line:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def __str__(self):
return "Line a="+str(self.a)+" b="+str(self.b)+" c="+str(self.c)
def Intersect(self, Line2):
''' Return the point which is at the intersection between the two lines
'''
det = Line2.a * self.b - self.a*Line2.b;
if abs(det) < 1e-6: # Line are parallel, return None
return None
return ((Line2.b*self.c - Line2.c*self.b)/det, (self.a*Line2.c - Line2.a*self.c)/det)
def square_line_distance(self, pt):
'''
Compute the distance between point and line
Distance between point and line is (a * pt.x + b * pt.y + c)*(a * pt.x + b * pt.y + c)/(a*a + b*b)
'''
return (self.a * pt[0] + self.b * pt[1] + self.c)*(self.a * pt[0]+ self.b * pt[1] + self.c)/(self.a*self.a + self.b*self.b)
class Segment(Line):
def __init__(self, A, B):
self.xA = A[0]
self.xB = B[0]
self.yA = A[1]
self.yB = B[1]
self.xm = min(self.xA, self.xB)
self.xM = max(self.xA, self.xB)
self.ym = min(self.yA, self.yB)
self.yM = max(self.yA, self.yB)
Line.__init__(self, A[1] - B[1], B[0] - A[0], A[0] * B[1] - B[0] * A[1])
def __str__(self):
return "Segment "+str([A,B])+ " a="+str(self.a)+" b="+str(self.b)+" c="+str(self.c)
def InSegment(self, Pt):
if Pt[0] < self.xm or Pt[0] > self.xM:
return 0 # Impossible lower than xmin or greater than xMax
if Pt[1] < self.ym or Pt[1] > self.yM:
return 0 # Impossible lower than ymin or greater than yMax
return 1
def __str__(self):
return "Seg"+str([(self.xA, self.yA), (self.xB, self.yB)])+" Line a="+str(self.a)+" b="+str(self.b)+" c="+str(self.c)
def pointInBBox(pt, bbox):
'''
Determine if the point pt=[x, y] lies on or within the bounding
box bbox=[xmin, xmax, ymin, ymax].
'''
# if (x < xmin) or (x > xmax) or (y < ymin) or (y > ymax)
if (pt[0] < bbox[0]) or (pt[0] > bbox[1]) or \
(pt[1] < bbox[2]) or (pt[1] > bbox[3]):
return False
else:
return True
def bboxInBBox(bbox1, bbox2):
'''
Determine if the bounding box bbox1 lies on or within the
bounding box bbox2. NOTE: we do not test for strict enclosure.
Structure of the bounding boxes is
bbox1 = [ xmin1, xmax1, ymin1, ymax1 ]
bbox2 = [ xmin2, xmax2, ymin2, ymax2 ]
'''
# if (xmin1 < xmin2) or (xmax1 > xmax2) or (ymin1 < ymin2) or (ymax1 > ymax2)
if (bbox1[0] < bbox2[0]) or (bbox1[1] > bbox2[1]) or \
(bbox1[2] < bbox2[2]) or (bbox1[3] > bbox2[3]):
return False
else:
return True
def pointInPoly(p, poly, bbox=None):
'''
Use a ray casting algorithm to see if the point p = [x, y] lies within
the polygon poly = [[x1,y1],[x2,y2],...]. Returns True if the point
is within poly, lies on an edge of poly, or is a vertex of poly.
'''
if (p is None) or (poly is None):
return False
# Check to see if the point lies outside the polygon's bounding box
if not bbox is None:
if not pointInBBox(p, bbox):
return False
# Check to see if the point is a vertex
if p in poly:
return True
# Handle a boundary case associated with the point
# lying on a horizontal edge of the polygon
x = p[0]
y = p[1]
p1 = poly[0]
p2 = poly[1]
for i in range(len(poly)):
if i != 0:
p1 = poly[i-1]
p2 = poly[i]
if (y == p1[1]) and (p1[1] == p2[1]) and \
(x > min(p1[0], p2[0])) and (x < max(p1[0], p2[0])):
return True
n = len(poly)
inside = False
p1_x,p1_y = poly[0]
for i in range(n + 1):
p2_x,p2_y = poly[i % n]
if y > min(p1_y, p2_y):
if y <= max(p1_y, p2_y):
if x <= max(p1_x, p2_x):
if p1_y != p2_y:
intersect = p1_x + (y - p1_y) * (p2_x - p1_x) / (p2_y - p1_y)
if x <= intersect:
inside = not inside
else:
inside = not inside
p1_x,p1_y = p2_x,p2_y
return inside
def polyInPoly(poly1, bbox1, poly2, bbox2):
'''
Determine if polygon poly2 = [[x1,y1],[x2,y2],...]
contains polygon poly1.
The bounding box information, bbox=[xmin, xmax, ymin, ymax]
is optional. When supplied it can be used to perform rejections.
Note that one bounding box containing another is not sufficient
to imply that one polygon contains another. It's necessary, but
not sufficient.
'''
# See if poly1's bboundin box is NOT contained by poly2's bounding box
# if it isn't, then poly1 cannot be contained by poly2.
if (not bbox1 is None) and (not bbox2 is None):
if not bboxInBBox(bbox1, bbox2):
return False
# To see if poly1 is contained by poly2, we need to ensure that each
# vertex of poly1 lies on or within poly2
for p in poly1:
if not pointInPoly(p, poly2, bbox2):
return False
# Looks like poly1 is contained on or in Poly2
return True
def subdivideCubicPath(sp, flat, i=1):
'''
[ Lifted from eggbot.py with impunity ]
Break up a bezier curve into smaller curves, each of which
is approximately a straight line within a given tolerance
(the "smoothness" defined by [flat]).
This is a modified version of cspsubdiv.cspsubdiv(): rewritten
because recursion-depth errors on complicated line segments
could occur with cspsubdiv.cspsubdiv().
'''
while True:
while True:
if i >= len(sp):
return
p0 = sp[i - 1][1]
p1 = sp[i - 1][2]
p2 = sp[i][0]
p3 = sp[i][1]
b = (p0, p1, p2, p3)
if bezier.maxdist(b) > flat:
break
i += 1
one, two = bezier.beziersplitatt(b, 0.5)
sp[i - 1][2] = one[1]
sp[i][0] = two[2]
p = [one[2], one[3], two[1]]
sp[i:1] = [p]
# Second degree equation solver.
# Return a tuple with the two real solutions, raise an error if there is no real solution
def Solve2nd(a, b, c):
delta = b**2 - 4*a*c
if (delta < 0):
print("No real solution")
return none
x1 = (-b + math.sqrt(delta))/(2*a)
x2 = (-b - math.sqrt(delta))/(2*a)
return (x1, x2)
# Compute distance between two points
def distance2points(x0, y0, x1, y1):
return math.hypot(x0-x1,y0-y1)
class Path2Flex(inkex.Effect):
def __init__(self):
inkex.Effect.__init__(self)
self.knownUnits = ['in', 'pt', 'px', 'mm', 'cm', 'm', 'km', 'pc', 'yd', 'ft']
self.arg_parser.add_argument('--unit', default = 'mm', help = 'Unit, should be one of ')
self.arg_parser.add_argument('--thickness', type = float, default = '3.0', help = 'Material thickness')
self.arg_parser.add_argument('--zc', type = float, default = '50.0', help = 'Flex height')
self.arg_parser.add_argument('--notch_interval', type = int, default = '2', help = 'Interval between notches')
self.arg_parser.add_argument('--max_size_flex', type = float, default = '1000.0', help = 'Max size of a single band of flex, above this limit it will be cut')
self.arg_parser.add_argument('--Mode_Debug', type = inkex.Boolean, default = 'false', help = 'Output Debug information in file')
# Dictionary of paths we will construct. It's keyed by the SVG node
# it came from. Such keying isn't too useful in this specific case,
# but it can be useful in other applications when you actually want
# to go back and update the SVG document
self.paths = {}
self.flexnotch = []
# Debug Output file
self.fDebug = None
# Dictionary of warnings issued. This to prevent from warning
# multiple times about the same problem
self.warnings = {}
#Get bounding rectangle
self.xmin, self.xmax = (1.0E70, -1.0E70)
self.ymin, self.ymax = (1.0E70, -1.0E70)
self.cx = float(DEFAULT_WIDTH) / 2.0
self.cy = float(DEFAULT_HEIGHT) / 2.0
def unittouu(self, unit):
return inkex.unittouu(unit)
def DebugMsg(self, s):
if self.fDebug:
self.fDebug.write(s)
# Generate long vertical lines for flex
# Parameters : StartX, StartY, size, nunmber of lines and +1 if lines goes up and -1 down
def GenLinesFlex(self, StartX, StartY, Size, nLine, UpDown, path):
for i in range(nLine):
path.Line(StartX, StartY, StartX, StartY + UpDown*Size)
self.DebugMsg("GenLinesFlex from "+str((StartX, StartY))+" to "+str((StartX, StartY + UpDown*Size))+'\n')
StartY += UpDown*(Size+2)
# Generate the path link to a flex step
#
def generate_step_flex(self, step, size_notch, ShortMark, LongMark, nMark, index):
path = inkcape_draw_cartesian(self.OffsetFlex, self.group)
#External part of the notch, fraction of total notch
notch_useful = 2.0 / (self.notchesInterval + 2)
# First, link towards next step
# Line from ((step+1)*size_notch, 0) to ((step+0.5)*size_notch, 0
path.Line((step+1)*size_notch, 0, (step+notch_useful)*size_notch, 0)
if self.flexnotch[index] == 0:
ShortMark = 0
# Then ShortLine from ((step+notch_useful)*size_notch, ShortMark) towards ((step+notch_useful)*size_notch, -Thickness)
path.Line((step+notch_useful)*size_notch, ShortMark,(step+notch_useful)*size_notch, -self.thickness)
# Then notch
path.LineTo(step*size_notch, -self.thickness)
# Then short mark towards other side (step*size_notch, shortmark)
path.LineTo(step*size_notch, ShortMark)
if ShortMark != 0: #Only if there is flex
# Then line towards center
self.GenLinesFlex(step*size_notch, ShortMark + 2, (self.height - 2*ShortMark - 2.0)/(nMark-1) - 2.0, nMark-1, 1, path)
# Then notch
path.Line(step*size_notch, self.height - ShortMark, step*size_notch, self.height + self.thickness)
path.LineTo((step+notch_useful)*size_notch, self.height + self.thickness)
path.LineTo((step+notch_useful)*size_notch, self.height - ShortMark)
if ShortMark != 0:
#Then nMark-1 Lines
self.GenLinesFlex((step+notch_useful)*size_notch, self.height - ShortMark - 2, (self.height - 2*ShortMark - 2.0)/(nMark-1) - 2.0, nMark-1, -1, path)
#Then Long lines internal to notch
self.GenLinesFlex((step+notch_useful/2)*size_notch, 1 - self.thickness, (self.height + 2.0*self.thickness)/nMark - 2, nMark, 1, path)
# link towards next One
path.Line((step+notch_useful)*size_notch, self.height, (step+1)*size_notch, self.height)
if ShortMark != 0:
# notchesInterval *nMark Long lines up to next notch or 2 shorts and nMark-1 long
i = 1
while i < self.notchesInterval:
pos = (i + 2.0) / (self.notchesInterval + 2.0)
if i % 2 :
#odd draw from bottom to top, nMark lines
self.GenLinesFlex((step+pos)*size_notch, self.height - 1, self.height /nMark - 2.0, nMark, -1, path)
else:
# even draw from top to bottom nMark+1 lines, 2 short and nMark-1 Long
path.Line((step+pos)*size_notch, 3, (step+pos)*size_notch, ShortMark)
self.GenLinesFlex((step+pos)*size_notch, ShortMark + 2, (self.height - 2*ShortMark - 2.0)/(nMark-1) - 2.0, nMark-1, 1, path)
path.Line((step+pos)*size_notch, self.height - ShortMark, (step+pos)*size_notch, self.height - 3)
i += 1
# Write path to inkscape
path.GenPath()
def GenerateStartFlex(self, size_notch, ShortMark, LongMark, nMark, index):
'''
Draw the start pattern
The notch is only 1 mm wide, to enable putting both start and end notch in the same hole in the cover
'''
path = inkcape_draw_cartesian(self.OffsetFlex, self.group)
#External part of the notch, fraction of total notch
notch_useful = 1.0 / (self.notchesInterval + 2)
notch_in = self.notchesInterval / (self.notchesInterval + 2.0)
# First, link towards next step
# Line from (, 0) to 0, 0
path.Line(-notch_in*size_notch, 0, 0, 0)
if self.flexnotch[index] == 0:
ShortMark = 0
# Then ShortLine from (-notch_in*size_notch, ShortMark) towards -notch_in*size_notch, Thickness)
path.Line(-notch_in*size_notch, ShortMark, -notch_in*size_notch, -self.thickness)
# Then notch (beware, only size_notch/4 here)
path.LineTo((notch_useful-1)*size_notch, -self.thickness)
# Then edge, full length
path.LineTo((notch_useful-1)*size_notch, self.height+self.thickness)
# Then notch
path.LineTo(-notch_in*size_notch, self.height + self.thickness)
path.LineTo(-notch_in*size_notch, self.height - ShortMark + 1)
if ShortMark != 0:
#Then nMark - 1 Lines
self.GenLinesFlex(-notch_in*size_notch, self.height - ShortMark - 2, (self.height - 2*ShortMark - 2.0)/(nMark-1) - 2.0, nMark-1, -1, path)
# link towards next One
path.Line(-notch_in*size_notch, self.height, 0, self.height)
if ShortMark != 0:
# notchesInterval *nMark Long lines up to next notch or 2 shorts and nMark-1 long
i = 1
while i < self.notchesInterval:
pos = (i - self.notchesInterval) / (self.notchesInterval + 2.0)
if i % 2 :
#odd draw from bottom to top, nMark lines
self.GenLinesFlex(pos*size_notch, self.height - 1, self.height /nMark - 2.0, nMark, -1, path)
else:
# even draw from top to bottom nMark+1 lines, 2 short and nMark-1 Long
path.Line(pos*size_notch, 3, pos*size_notch, ShortMark)
self.GenLinesFlex(pos*size_notch, ShortMark + 2, (self.height - 2*ShortMark - 2.0)/(nMark-1) - 2.0, nMark-1, 1, path)
path.Line(pos*size_notch, self.height - ShortMark, pos*size_notch, self.height - 3)
i += 1
path.GenPath()
def GenerateEndFlex(self, step, size_notch, ShortMark, LongMark, nMark, index):
path = inkcape_draw_cartesian(self.OffsetFlex, self.group)
delta_notch = 1.0 / (self.notchesInterval + 2.0)
if self.flexnotch[index] == 0:
ShortMark = 0
# ShortLine from (step*size_notch, ShortMark) towards step*size_notch, -Thickness)
path.Line(step*size_notch, ShortMark, step*size_notch, -self.thickness)
# Then notch (beware, only 1mm here)
path.LineTo((step+delta_notch)*size_notch, -self.thickness)
# Then edge, full length
path.LineTo((step+delta_notch)*size_notch, self.height+self.thickness)
# Then notch
path.LineTo(step*size_notch, self.height + self.thickness)
path.LineTo(step*size_notch, self.height - ShortMark)
if ShortMark != 0:
#Then nMark - 1 Lines
self.GenLinesFlex(step*size_notch, self.height - ShortMark - 2, (self.height - 2*ShortMark - 2.0)/(nMark-1) - 2.0, nMark-1, -1, path)
path.GenPath()
def GenFlex(self, parent, num_notch, size_notch, xOffset, yOffset):
group = etree.SubElement(parent, 'g')
self.group = group
#Compute number of vertical lines. Each long mark should be at most 50mm long to avoid failures
nMark = int(self.height / 50) + 1
nMark = max(nMark, 2) # At least 2 marks
#Then compute number of flex bands
FlexLength = num_notch * size_notch
nb_flex_band = int (FlexLength // self.max_flex_size) + 1
notch_per_band = num_notch / nb_flex_band + 1
self.DebugMsg("Generate flex structure with "+str(nb_flex_band)+" bands, "+str(num_notch)+" notches, offset ="+str((xOffset, yOffset))+'\n')
#Sizes of short and long lines to make flex
LongMark = (self.height / nMark) - 2.0 #Long Mark equally divide the height
ShortMark = LongMark/2 # And short mark should lay at center of long marks
idx_notch = 0
while num_notch > 0:
self.OffsetFlex = (xOffset, yOffset)
self.GenerateStartFlex(size_notch, ShortMark, LongMark, nMark, idx_notch)
idx_notch += 1
notch = 0
if notch_per_band > num_notch:
notch_per_band = num_notch #for the last one
while notch < notch_per_band - 1:
self.generate_step_flex(notch, size_notch, ShortMark, LongMark, nMark, idx_notch)
notch += 1
idx_notch += 1
num_notch -= notch_per_band
if num_notch == 0:
self.GenerateEndFlex(notch, size_notch, ShortMark, LongMark, nMark, 0)
else:
self.GenerateEndFlex(notch, size_notch, ShortMark, LongMark, nMark, idx_notch)
xOffset -= size_notch * notch_per_band + 10
def getPathVertices(self, path, node=None):
'''
Decompose the path data from an SVG element into individual
subpaths, each subpath consisting of absolute move to and line
to coordinates. Place these coordinates into a list of polygon
vertices.
'''
self.DebugMsg("Entering getPathVertices, len="+str(len(path))+"\n")
if (not path) or (len(path) == 0):
# Nothing to do
return None
# parsePath() may raise an exception. This is okay
simple_path = Path(path).to_arrays()
if (not simple_path) or (len(simple_path) == 0):
# Path must have been devoid of any real content
return None
self.DebugMsg("After parsePath in getPathVertices, len="+str(len(simple_path))+"\n")
self.DebugMsg(" Path = "+str(simple_path)+'\n')
# Get a cubic super path
cubic_super_path = CubicSuperPath(simple_path)
if (not cubic_super_path) or (len(cubic_super_path) == 0):
# Probably never happens, but...
return None
self.DebugMsg("After CubicSuperPath in getPathVertices, len="+str(len(cubic_super_path))+"\n")
# Now traverse the cubic super path
subpath_list = []
subpath_vertices = []
index_sp = 0
for sp in cubic_super_path:
# We've started a new subpath
# See if there is a prior subpath and whether we should keep it
self.DebugMsg("Processing SubPath"+str(index_sp)+" SubPath List len="+str(len(subpath_list))+" Vertices list length="+str(len(subpath_vertices)) +"\n")
if len(subpath_vertices):
subpath_list.append(subpath_vertices)
subpath_vertices = []
self.DebugMsg("Before subdivideCubicPath len="+str(len(sp)) +"\n")
self.DebugMsg(" Bsp="+str(sp)+'\n')
subdivideCubicPath(sp, 0.1)
self.DebugMsg("After subdivideCubicPath len="+str(len(sp)) +"\n")
self.DebugMsg(" Asp="+str(sp)+'\n')
# Note the first point of the subpath
first_point = sp[0][1]
subpath_vertices.append(first_point)
sp_xmin = first_point[0]
sp_xmax = first_point[0]
sp_ymin = first_point[1]
sp_ymax = first_point[1]
n = len(sp)
# Traverse each point of the subpath
for csp in sp[1:n]:
# Append the vertex to our list of vertices
pt = csp[1]
subpath_vertices.append(pt)
#self.DebugMsg("Append subpath_vertice '"+str(pt)+"len="+str(len(subpath_vertices)) +"\n")
# Track the bounding box of this subpath
if pt[0] < sp_xmin:
sp_xmin = pt[0]
elif pt[0] > sp_xmax:
sp_xmax = pt[0]
if pt[1] < sp_ymin:
sp_ymin = pt[1]
elif pt[1] > sp_ymax:
sp_ymax = pt[1]
# Track the bounding box of the overall drawing
# This is used for centering the polygons in OpenSCAD around the (x,y) origin
if sp_xmin < self.xmin:
self.xmin = sp_xmin
if sp_xmax > self.xmax:
self.xmax = sp_xmax
if sp_ymin < self.ymin:
self.ymin = sp_ymin
if sp_ymax > self.ymax:
self.ymax = sp_ymax
# Handle the final subpath
if len(subpath_vertices):
subpath_list.append(subpath_vertices)
if len(subpath_list) > 0:
self.paths[node] = subpath_list
'''
self.DebugMsg("After getPathVertices\n")
index_i = 0
for i in self.paths[node]:
index_j = 0
for j in i:
self.DebugMsg('Path '+str(index_i)+" élément "+str(index_j)+" = "+str(j)+'\n')
index_j += 1
index_i += 1
'''
def DistanceOnPath(self, p, pt, index):
'''
Return the distances before and after the point pt on the polygon p
The point pt is in the segment index of p, that is between p[index] and p[index+1]
'''
i = 0
before = 0
after = 0
while i < index:
# First walk through polygon up to p[index]
before += distance2points(p[i+1][0], p[i+1][1], p[i][0], p[i][1])
i += 1
#For the segment index compute the part before and after
before += distance2points(pt[0], pt[1], p[index][0], p[index][1])
after += distance2points(pt[0], pt[1], p[index+1][0], p[index+1][1])
i = index + 1
while i < len(p)-1:
after += distance2points(p[i+1][0], p[i+1][1], p[i][0], p[i][1])
i += 1
return (before, after)
# Compute position of next notch.
# Next notch will be on the path p, and at a distance notch_size from previous point
# Return new index in path p
def compute_next_notch(self, notch_points, p, Angles_p, last_index_in_p, notch_size):
index_notch = len(notch_points)
# Coordinates of last notch
Ox = notch_points[index_notch - 1][0]
Oy = notch_points[index_notch - 1][1]
CurAngle = Angles_p[last_index_in_p-1]
#self.DebugMsg("Enter cnn:last_index_in_p="+str(last_index_in_p)+" CurAngle="+str(round(CurAngle*180/math.pi))+" Segment="+str((p[last_index_in_p-1], p[last_index_in_p]))+" Length="+str(distance2points(p[last_index_in_p-1][0], p[last_index_in_p-1][1], p[last_index_in_p][0], p[last_index_in_p][1]))+"\n")
DeltaAngle = 0
while last_index_in_p < (len(p) - 1) and distance2points(Ox, Oy, p[last_index_in_p][0], p[last_index_in_p][1]) < notch_size + DeltaAngle*self.thickness/2.0:
Diff_angle = Angles_p[last_index_in_p] - CurAngle
if Diff_angle > math.pi:
Diff_angle -= 2*math.pi
elif Diff_angle < -math.pi:
Diff_angle += 2*math.pi
Diff_angle = abs(Diff_angle)
DeltaAngle += Diff_angle
CurAngle = Angles_p[last_index_in_p]
#self.DebugMsg("cnn:last_index_in_p="+str(last_index_in_p)+" Angle="+str(round(Angles_p[last_index_in_p]*180/math.pi))+" Diff_angle="+str(round(Diff_angle*180/math.pi))+" DeltaAngle="+str(round(DeltaAngle*180/math.pi))+" Distance="+str(distance2points(Ox, Oy, p[last_index_in_p][0], p[last_index_in_p][1]))+"/"+str(notch_size + DeltaAngle*self.thickness/2.0)+"\n")
last_index_in_p += 1 # Go to next point in polygon
# Starting point for the line x0, y0 is p[last_index_in_p-1]
x0 = p[last_index_in_p-1][0]
y0 = p[last_index_in_p-1][1]
# End point for the line x1, y1 is p[last_index_in_p]
x1 = p[last_index_in_p][0]
y1 = p[last_index_in_p][1]
Distance_notch = notch_size + DeltaAngle*self.thickness/2.0
#self.DebugMsg(" compute_next_notch("+str(index_notch)+") Use Segment="+str(last_index_in_p)+" DeltaAngle="+str(round(DeltaAngle*180/math.pi))+"°, notch_size="+str(notch_size)+" Distance_notch="+str(Distance_notch)+'\n')
# The actual notch position will be on the line between last_index_in_p-1 and last_index_in_p and at a distance Distance_notch of Ox,Oy
# The intersection of a line and a circle could be computed as a second degree equation in a general case
# Specific case, when segment is vertical
if abs(x1-x0) <0.001:
# easy case, x= x0 so y = sqrt(d2 - x*x)
solx1 = x0
solx2 = x0
soly1 = Oy + math.sqrt(Distance_notch**2 - (x0 - Ox)**2)
soly2 = Oy - math.sqrt(Distance_notch**2 - (x0 - Ox)**2)
else:
Slope = (y1 - y0) / (x1 - x0)
# The actual notch position will be on the line between last_index_in_p-1 and last_index_in_p and at a distance notch size of Ox,Oy
# The intersection of a line and a circle could be computed as a second degree equation
# The coefficients of this equation are computed below
a = 1.0 + Slope**2
b = 2*Slope*y0 - 2*Slope**2*x0 - 2*Ox - 2*Slope*Oy
c = Slope**2*x0**2 + y0**2 -2*Slope*x0*y0 + 2*Slope*x0*Oy - 2*y0*Oy + Ox**2 + Oy**2 - Distance_notch**2
solx1, solx2 = Solve2nd(a, b, c)
soly1 = y0 + Slope*(solx1-x0)
soly2 = y0 + Slope*(solx2-x0)
# Now keep the point which is between (x0,y0) and (x1, y1)
# The distance between (x1,y1) and the "good" solution will be lower than the distance between (x0,y0) and (x1,y1)
distance1 = distance2points(x1, y1, solx1, soly1)
distance2 = distance2points(x1, y1, solx2, soly2)
if distance1 < distance2:
#Keep solx1
solx = solx1
soly = soly1
else:
#Keep solx2
solx = solx2
soly = soly2
notch_points.append((solx, soly, last_index_in_p-1))
if abs(distance2points(solx, soly, Ox, Oy) - Distance_notch) > 1:
#Problem
self.DebugMsg("Problem in compute_next_notch: x0,y0 ="+str((x0,y0))+" x1,y1="+str((x1,y1))+'\n')
self.DebugMsg("Len(p)="+str(len(p))+'\n')
self.DebugMsg("Slope="+str(Slope)+'\n')
self.DebugMsg("solx1="+str(solx1)+" soly1="+str(soly1)+" soly1="+str(solx2)+" soly1="+str(soly2)+'\n')
self.DebugMsg(str(index_notch)+": Adding new point ("+str(solx)+","+ str(soly) + "), distance is "+ str(distance2points(solx, soly, Ox, Oy))+ " New index in path :"+str(last_index_in_p)+'\n')
#self.DebugMsg(str(index_notch)+": Adding new point ("+str(solx)+","+ str(soly) + "), distance is "+ str(distance2points(solx, soly, Ox, Oy))+ " New index in path :"+str(last_index_in_p)+'\n')
return last_index_in_p
def DrawPoly(self, p, parent):
group = etree.SubElement(parent, 'g')
Newpath = inkcape_draw_cartesian((self.xmin - self.xmax - 10, 0), group)
self.DebugMsg('DrawPoly First element (0) : '+str(p[0])+ ' Call MoveTo('+ str(p[0][0])+','+str(p[0][1])+'\n')
Newpath.MoveTo(p[0][0], p[0][1])
n = len(p)
index = 1
for point in p[1:n]:
Newpath.LineTo(point[0], point[1])
index += 1
Newpath.GenPath()
def Simplify(self, poly, max_error):
'''
Simplify the polygon, remove vertices which are aligned or too close from others
The parameter give the max error, below this threshold, points will be removed
return the simplified polygon, which is modified in place
'''
#First point
LastIdx = 0
limit = max_error * max_error #Square because distance will be square !
i = 1
while i < len(poly)-1:
#Build segment between Vertex[i-1] and Vertex[i+1]
Seg = Segment(poly[LastIdx], poly[i+1])
#self.DebugMsg("Pt["+str(i)+"]/"+str(len(poly))+" ="+str(poly[i])+" Segment="+str(Seg)+"\n")
# Compute square of distance between Vertex[i] and Segment
dis_square = Seg.square_line_distance(poly[i])
if dis_square < max_error:
# Too close, remove this point
poly.pop(i) #and do NOT increment index
#self.DebugMsg("Simplify, removing pt "+str(i)+"="+str(poly[i])+" in Segment : "+str(Seg)+" now "+str(len(poly))+" vertices\n")
else:
LastIdx = i
i += 1 #Increment index
# No need to process last point, it should NOT be modified and stay equal to first one
return poly
def MakePolyCCW(self, p):
'''
Take for polygon as input and make it counter clockwise.
If already CCW, just return the polygon, if not reverse it
To determine if polygon is CCW, compute area. If > 0 the polygon is CCW
'''
area = 0
for i in range(len(p)-1):
area += p[i][0]*p[i+1][1] - p[i+1][0]*p[i][1]
self.DebugMsg("poly area = "+str(area/2)+"\n")
if area < 0:
# Polygon is cloackwise, reverse
p.reverse()
self.DebugMsg("Polygon was clockwise, reverse it\n")
return p
def ComputeAngles(self, p):
'''
Compute a list with angles of all edges of the polygon
Return this list
'''
angles = []
for i in range(len(p)-1):
a = math.atan2(p[i+1][1] - p[i][1], p[i+1][0] - p[i][0])
angles.append(a)
# Last value is not defined as Pt n-1 = Pt 0, set it to angle[0]
angles.append(angles[0])
return angles
def writeModifiedPath(self, node, parent):
'''
Take the paths (polygons) computed from previous step and generate
1) The input path with notches
2) The flex structure associated with the path with notches (same length and number of notches)
'''
path = self.paths[node]
if (path is None) or (len(path) == 0):
return
self.DebugMsg('Enter writeModifiedPath, node='+str(node)+' '+str(len(path))+' paths, global Offset'+str((self.xmin - self.xmax - 10, 0))+'\n')
# First, if there are several paths, checks if one path is included in the first one.
# If not exchange such as the first one is the bigger one.
# All paths which are not the first one will have notches reverted to be outside the polygon instead of inside the polygon.
# On the finbal paths, these notches will always be inside the form.
if len(path) > 1:
OrderPathModified = True
# Arrange paths such as greater one is first, all others
while OrderPathModified:
OrderPathModified = False
for i in range(1, len(path)):
if polyInPoly(path[i], None, path[0], None):
self.DebugMsg("Path "+str(i)+" is included in path 0\n")
elif polyInPoly(path[0], None, path[i], None):
self.DebugMsg("Path "+str(i)+" contains path 0, exchange\n")
path[0], path[i] = path[i], path[0]
OrderPathModified = True
index_path = 0
xFlexOffset = self.xmin - 2*self.xmax - 20
yFlexOffset = self.height - self.ymax - 10
for p in path:
self.DebugMsg('Processing Path, '+str(index_path)+" Len(path)="+str(len(p))+'\n')
self.DebugMsg('p='+str(p)+'\n')
reverse_notch = False
if index_path > 0 and polyInPoly(p, None, path[0], None):
reverse_notch = True # For included path, reverse notches
#Simplify path, remove unnecessary vertices
p = self.Simplify(p, 0.1)
self.DebugMsg("---After simplification, path has "+str(len(p))+" vertices\n")
#Ensure that polygon is counter clockwise
p = self.MakePolyCCW(p)
self.DrawPoly(p, parent)
#Now compute path length. Path length is the sum of length of edges
length_path = 0
n = len(p)
index = 1
while index < n:
length_path += math.hypot((p[index][0] - p[index-1][0]), (p[index][1] - p[index-1][1]))
index += 1
angles = self.ComputeAngles(p)
# compute the sum of angles difference and check that it is 2*pi
SumAngle = 0.0
for i in range(len(p)-1):
Delta_angle = angles[i+1] - angles[i]
if Delta_angle > math.pi:
Delta_angle -= 2*math.pi
elif Delta_angle < -math.pi:
Delta_angle += 2*math.pi
Delta_angle = abs(Delta_angle)
self.DebugMsg("idx="+str(i)+" Angle1 ="+str(round(angles[i]*180/math.pi,3))+" Angle 2="+str(round(angles[i+1]*180/math.pi,3))+" Delta angle="+str(round(Delta_angle*180/math.pi, 3))+"°\n")
SumAngle += Delta_angle
self.DebugMsg("Sum of angles="+str(SumAngle*180/math.pi)+"°\n")
# Flex length will be path length - thickness*SumAngle/2 to keep flex aligned on the shortest path
flex_length = length_path - self.thickness*SumAngle/2
self.DebugMsg('Path length ='+str(length_path)+" Flex length ="+str(flex_length)+" Difference="+str(length_path-flex_length)+'\n')
#Default notch size is notchesInterval + 2mm
#Actual notch size will be adjusted to match the length
notch_number = int(round(flex_length / (self.notchesInterval + 2), 0))
notch_size = flex_length / notch_number
self.DebugMsg('Number of notches ='+str(notch_number)+' ideal notch size =' + str(round(notch_size,3)) +'\n')
# Compute position of the points on the path that will become notches
# Starting at 0, each point will be at distance actual_notch_size from the previous one, at least on one side of the notch (the one with the smallest distance)
# On the path (middle line) the actual distance will be notch_size + thickness*delta_angle/2 where delta angle is the difference between the angle at starting point and end point
# As notches are not aligned to vertices, the actual length of the path will be different from the computed one (lower in fact)
# To avoid a last notch too small, we will repeat the process until the size of the last notch is OK (less than .1mm error)
# Use an algorithm which corrects the notch_size by computing previous length of the last notch
nb_try = 0
size_last_notch = 0
oldSize = 0
BestDifference = 9999999
BestNotchSize = notch_size
mode_linear = False
delta_notch = -0.01 #In most cases, should reduce notch size
while nb_try < 100:
notch_points = [ (p[0][0], p[0][1], 0) ] # Build a list of tuples with corrdinates (x,y) and offset within polygon which is 0 the the starting point
index = 1 # Notch index
last_index_in_p = 1 # Start at 1, index 0 is the current one
self.DebugMsg("Pass "+str(nb_try)+" First point ("+str(p[0][0])+","+ str(p[0][1]) + ' notch_size='+str(notch_size)+'\n')
while index < notch_number:
#Compute next notch point and append it to the list
last_index_in_p = self.compute_next_notch(notch_points, p, angles, last_index_in_p, notch_size)
#before, after = self.DistanceOnPath(p, notch_points[index], last_index_in_p-1)
#self.DebugMsg(" Notch "+str(index)+" placed in "+str(notch_points[index])+" distance before ="+str(before)+" after="+str(after)+" total="+str(before+after)+'\n')
index += 1
size_last_notch = distance2points(p[n-1][0], p[n-1][1], notch_points[index-1][0], notch_points[index-1][1])
self.DebugMsg("Last notch size :"+str(size_last_notch)+'\n')
if abs(notch_size - size_last_notch) < BestDifference:
BestNotchSize = notch_size
BestDifference = abs(notch_size - size_last_notch)
if abs(notch_size - size_last_notch) <= 0.1:
break
# Change size_notch, cut small part in each notch
# The 0.5 factor is used to avoid non convergent series (too short then too long...)
if mode_linear:
if notch_size > size_last_notch and delta_notch > 0:
delta_notch -= delta_notch*0.99
elif notch_size < size_last_notch and delta_notch < 0:
delta_notch -= delta_notch*0.99
notch_size += delta_notch
self.DebugMsg("Linear mode, changing delta_notch size :"+str(delta_notch)+" --> notch_size="+str(notch_size)+'\n')
else:
if notch_size > size_last_notch and delta_notch > 0:
delta_notch = -0.5*delta_notch
self.DebugMsg("Changing delta_notch size :"+str(delta_notch)+'\n')
elif notch_size < size_last_notch and delta_notch < 0:
delta_notch = -0.5*delta_notch
self.DebugMsg("Changing delta_notch size :"+str(delta_notch)+'\n')
notch_size += delta_notch
if abs(delta_notch) < 0.002:
mode_linear = True
# Change size_notch, cut small part in each notch
oldSize = notch_size
# The 0.5 factor is used to avoid non convergent series (too short then too long...)
notch_size -= 0.5*(notch_size - size_last_notch)/notch_number
nb_try += 1
if nb_try >= 100:
self.DebugMsg("Algorithm doesn't converge, use best results :"+str(BestNotchSize)+" which gave last notch size difference "+str(BestDifference)+'\n')
notch_size = BestNotchSize
# Now draw the actual notches
group = etree.SubElement(parent, 'g')
# First draw a start line which will help to position flex.
Startpath = inkcape_draw_cartesian(((self.xmin - self.xmax - 10), 0), group)
index_in_p = notch_points[0][2]
AngleSlope = math.atan2(p[index_in_p+1][1] - p[index_in_p][1], p[index_in_p+1][0] - p[index_in_p][0])
#Now compute both ends of the notch,
AngleOrtho = AngleSlope + math.pi/2
Line_Start = (notch_points[0][0] + self.thickness/2*math.cos(AngleOrtho), notch_points[0][1] + self.thickness/2*math.sin(AngleOrtho))
Line_End = (notch_points[0][0] - self.thickness/2*math.cos(AngleOrtho), notch_points[0][1] - self.thickness/2*math.sin(AngleOrtho))
self.DebugMsg("Start line Start"+str(Line_Start)+" End("+str(Line_End)+" Start inside "+str(pointInPoly(Line_Start, p))+ " End inside :"+str(pointInPoly(Line_End, p))+'\n')
#Notch End should be inside the path and Notch Start outside... If not reverse
if pointInPoly(Line_Start, p):
Line_Start, Line_End = Line_End, Line_Start
AngleOrtho += math.pi
elif not pointInPoly(Line_End, p):
#Specific case, neither one is in Polygon (Open path ?), take the lowest Y as Line_End
if Line_End[1] > Line_Start[0]:
Line_Start, Line_End = Line_End, Line_Start
AngleOrtho += math.pi
#Now compute a new Start, inside the polygon Start = 3*End - 2*Start
newLine_Start = (3*Line_End[0] - 2*Line_Start[0], 3*Line_End[1] - 2*Line_Start[1])
Startpath.MoveTo(newLine_Start[0], newLine_Start[1])
Startpath.LineTo(Line_End[0], Line_End[1])
self.DebugMsg("Draw StartLine start from "+str((newLine_Start[0], newLine_Start[1]))+" to "+str((Line_End[0], Line_End[1]))+'\n')
Startpath.GenPathStart()
#Then draw the notches
Newpath = inkcape_draw_cartesian(((self.xmin - self.xmax - 10), 0), group)
self.DebugMsg("Generate path with "+str(notch_number)+" notches, offset ="+str(((self.xmin - self.xmax - 10), 0))+'\n')
isClosed = distance2points(p[n-1][0], p[n-1][1], p[0][0], p[0][1]) < 0.1
# Each notch is a tuple with (X, Y, index_in_p). index_in_p will be used to compute slope of line of the notch
# The notch will be thickness long, and there will be a part 'inside' the path and a part 'outside' the path
# The longest part will be outside
index = 0
NX0 = 0
NX1 = 0
NX2 = 0
NX3 = 0
NY0 = 0
NY1 = 0
NY2 = 0
NY3 = 0
N_Angle = 0
Notch_Pos = []
while index < notch_number:
# Line slope of the path at notch point is
index_in_p = notch_points[index][2]
N_Angle = angles[index_in_p]
AngleSlope = math.atan2(p[index_in_p+1][1] - p[index_in_p][1], p[index_in_p+1][0] - p[index_in_p][0])
self.DebugMsg("Draw notch "+str(index)+" Slope is "+str(AngleSlope*180/math.pi)+'\n')
self.DebugMsg("Ref="+str(notch_points[index])+'\n')
self.DebugMsg("Path points:"+str((p[index_in_p][0], p[index_in_p][1]))+', '+ str((p[index_in_p+1][0], p[index_in_p+1][1]))+'\n')
#Now compute both ends of the notch,
AngleOrtho = AngleSlope + math.pi/2
Notch_Start = (notch_points[index][0] + self.thickness/2*math.cos(AngleOrtho), notch_points[index][1] + self.thickness/2*math.sin(AngleOrtho))
Notch_End = (notch_points[index][0] - self.thickness/2*math.cos(AngleOrtho), notch_points[index][1] - self.thickness/2*math.sin(AngleOrtho))
self.DebugMsg("Notch "+str(index)+": Start"+str(Notch_Start)+" End("+str(Notch_End)+" Start inside "+str(pointInPoly(Notch_Start, p))+ " End inside :"+str(pointInPoly(Notch_End, p))+'\n')
#Notch End should be inside the path and Notch Start outside... If not reverse
if pointInPoly(Notch_Start, p):
Notch_Start, Notch_End = Notch_End, Notch_Start
AngleOrtho += math.pi
elif not pointInPoly(Notch_End, p):
#Specific case, neither one is in Polygon (Open path ?), take the lowest Y as Notch_End
if Notch_End[1] > Notch_Start[0]:
Notch_Start, Notch_End = Notch_End, Notch_Start
AngleOrtho += math.pi
#if should reverse notches, do it now
if reverse_notch:
Notch_Start, Notch_End = Notch_End, Notch_Start
AngleOrtho += math.pi
if AngleOrtho > 2*math.pi:
AngleOrtho -= 2*math.pi
ln = 2.0
if index == 0:
Newpath.MoveTo(Notch_Start[0], Notch_Start[1])
first = (Notch_Start[0], Notch_Start[1])
if not isClosed:
ln = 1.0 # Actual, different Notch size for the first one when open path
else:
Newpath.LineTo(Notch_Start[0], Notch_Start[1])
if not isClosed and index == notch_number - 1:
ln = 1.0
self.DebugMsg("LineTo starting point from :"+str((x,y))+" to "+str((Notch_Start[0], Notch_Start[1]))+" Length ="+str(distance2points(x, y, Notch_Start[0], Notch_Start[1]))+'\n')
Newpath.LineTo(Notch_End[0], Notch_End[1])
NX0 = Notch_Start[0]
NY0 = Notch_Start[1]
NX1 = Notch_End[0]
NY1 = Notch_End[1]
self.DebugMsg("Draw notch_1 start from "+str((Notch_Start[0], Notch_Start[1]))+" to "+str((Notch_End[0], Notch_End[1]))+'Center is '+str(((Notch_Start[0]+Notch_End[0])/2, (Notch_Start[1]+Notch_End[1])/2))+'\n')
#Now draw a line parallel to the path, which is notch_size*(2/(notchesInterval+2)) long. Internal part of the notch
x = Notch_End[0] + (notch_size*ln)/(self.notchesInterval+ln)*math.cos(AngleSlope)
y = Notch_End[1] + (notch_size*ln)/(self.notchesInterval+ln)*math.sin(AngleSlope)
Newpath.LineTo(x, y)
NX2 = x
NY2 = y
self.DebugMsg("Draw notch_2 to "+str((x, y))+'\n')
#Then a line orthogonal, which is thickness long, reverse from first one
x = x + self.thickness*math.cos(AngleOrtho)
y = y + self.thickness*math.sin(AngleOrtho)
Newpath.LineTo(x, y)
NX3 = x
NY3 = y
self.DebugMsg("Draw notch_3 to "+str((x, y))+'\n')
Notch_Pos.append((NX0, NY0, NX1, NY1, NX2, NY2, NX3, NY3, N_Angle))
# No need to draw the last segment, it will be drawn when starting the next notch
index += 1
#And the last one if the path is closed
if isClosed:
self.DebugMsg("Path is closed, draw line to start point "+str((p[0][0], p[0][1]))+'\n')
Newpath.LineTo(first[0], first[1])
else:
self.DebugMsg("Path is open\n")
Newpath.GenPath()
# Analyze notches for debugging purpose
for i in range(len(Notch_Pos)):
self.DebugMsg("Notch "+str(i)+" Pos="+str(Notch_Pos[i])+" Angle="+str(round(Notch_Pos[i][8]*180/math.pi))+"\n")
if (i > 0):
self.DebugMsg(" FromLast Notch N3-N0="+str(distance2points(Notch_Pos[i-1][6], Notch_Pos[i-1][7], Notch_Pos[i][0], Notch_Pos[i][1]))+"\n")
self.DebugMsg(" Distances: N0-N3="+str(distance2points(Notch_Pos[i][0], Notch_Pos[i][1], Notch_Pos[i][6], Notch_Pos[i][7]))+" N1-N2="+str(distance2points(Notch_Pos[i][2], Notch_Pos[i][3], Notch_Pos[i][4], Notch_Pos[i][5]))+"\n")
# For each notch determine if we need flex or not. Flex is only needed if there is some curves
# So if notch[i]-1 notch[i] notch[i+1] are aligned, no need to generate flex in i-1 and i
for index in range(notch_number):
self.flexnotch.append(1) # By default all notches need flex
index = 1
while index < notch_number-1:
det = (notch_points[index+1][0]- notch_points[index-1][0])*(notch_points[index][1] - notch_points[index-1][1]) - (notch_points[index+1][1] - notch_points[index-1][1])*(notch_points[index][0] - notch_points[index-1][0])
self.DebugMsg("Notch "+str(index)+": det="+str(det))
if abs(det) < 0.1: # My threhold to be adjusted
self.flexnotch[index-1] = 0 # No need for flex for this one and the following
self.flexnotch[index] = 0
self.DebugMsg(" no flex in notch "+str(index-1)+" and "+str(index))
index += 1
self.DebugMsg("\n")
# For the last one try notch_number - 2, notch_number - 1 and 0
det = (notch_points[0][0]- notch_points[notch_number - 2][0])*(notch_points[notch_number - 1][1] - notch_points[notch_number - 2][1]) - (notch_points[0][1] - notch_points[notch_number - 2][1])*(notch_points[notch_number - 1][0] - notch_points[notch_number - 2][0])
if abs(det) < 0.1: # My threhold to be adjusted
self.flexnotch[notch_number-2] = 0 # No need for flex for this one and the following
self.flexnotch[notch_number-1] = 0
# and the first one with notch_number - 1, 0 and 1
det = (notch_points[1][0]- notch_points[notch_number-1][0])*(notch_points[0][1] - notch_points[notch_number-1][1]) - (notch_points[1][1] - notch_points[notch_number-1][1])*(notch_points[0][0] - notch_points[notch_number-1][0])
if abs(det) < 0.1: # My threhold to be adjusted
self.flexnotch[notch_number-1] = 0 # No need for flex for this one and the following
self.flexnotch[0] = 0
self.DebugMsg("FlexNotch ="+str(self.flexnotch)+"\n")
# Generate Associated flex
self.GenFlex(parent, notch_number, notch_size, xFlexOffset, yFlexOffset)
yFlexOffset -= self.height + 10
index_path += 1
def recursivelyTraverseSvg(self, aNodeList):
'''
[ This too is largely lifted from eggbot.py and path2openscad.py ]
Recursively walk the SVG document, building polygon vertex lists
for each graphical element we support.
Rendered SVG elements:
<circle>, <ellipse>, <line>, <path>, <polygon>, <polyline>, <rect>
Except for path, all elements are first converted into a path the processed
Supported SVG elements:
<group>
Ignored SVG elements:
<defs>, <eggbot>, <metadata>, <namedview>, <pattern>,
processing directives
All other SVG elements trigger an error (including <text>)
'''
for node in aNodeList:
self.DebugMsg("Node type :" + node.tag + '\n')
if node.tag == inkex.addNS('g', 'svg') or node.tag == 'g':
self.DebugMsg("Group detected, recursive call\n")
self.recursivelyTraverseSvg(node)
elif node.tag == inkex.addNS('path', 'svg'):
self.DebugMsg("Path detected, ")
path_data = node.get('d')
if path_data:
self.getPathVertices(path_data, node)
else:
self.DebugMsg("NO path data present\n")
elif node.tag == inkex.addNS('rect', 'svg') or node.tag == 'rect':
# Create a path with the outline of the rectangle
x = float(node.get('x'))
y = float(node.get('y'))
if (not x) or (not y):
pass
w = float(node.get('width', '0'))
h = float(node.get('height', '0'))
self.DebugMsg('Rectangle X='+ str(x)+',Y='+str(y)+', W='+str(w)+' H='+str(h)+'\n')
a = []
a.append(['M', [x, y]])
a.append(['l', [w, 0]])
a.append(['l', [0, h]])
a.append(['l', [-w, 0]])
a.append(['Z', []])
self.getPathVertices(str(Path(a)), node)
elif node.tag == inkex.addNS('line', 'svg') or node.tag == 'line':
# Convert
#
# <line x1="X1" y1="Y1" x2="X2" y2="Y2/>
#
# to
#
# <path d="MX1,Y1 LX2,Y2"/>
x1 = float(node.get('x1'))
y1 = float(node.get('y1'))
x2 = float(node.get('x2'))
y2 = float(node.get('y2'))
self.DebugMsg('Line X1='+ str(x1)+',Y1='+str(y1)+', X2='+str(x2)+' Y2='+str(y2)+'\n')
if (not x1) or (not y1) or (not x2) or (not y2):
pass
a = []
a.append(['M', [x1, y1]])
a.append(['L', [x2, y2]])
self.getPathVertices(str(Path(a)), node)
elif node.tag == inkex.addNS('polyline', 'svg') or node.tag == 'polyline':
# Convert
#
# <polyline points="x1,y1 x2,y2 x3,y3 [...]"/>
#
# to
#
# <path d="Mx1,y1 Lx2,y2 Lx3,y3 [...]"/>
#
# Note: we ignore polylines with no points
pl = node.get('points', '').strip()
if pl == '':
pass
pa = pl.split()
d = "".join(["M " + pa[i] if i == 0 else " L " + pa[i] for i in range(0, len(pa))])
self.DebugMsg('PolyLine :'+ d +'\n')
self.getPathVertices(d, node)
elif node.tag == inkex.addNS('polygon', 'svg') or node.tag == 'polygon':
# Convert
#
# <polygon points="x1,y1 x2,y2 x3,y3 [...]"/>
#
# to
#
# <path d="Mx1,y1 Lx2,y2 Lx3,y3 [...] Z"/>
#
# Note: we ignore polygons with no points
pl = node.get('points', '').strip()
if pl == '':
pass
pa = pl.split()
d = "".join(["M " + pa[i] if i == 0 else " L " + pa[i] for i in range(0, len(pa))])
d += " Z"
self.DebugMsg('Polygon :'+ d +'\n')
self.getPathVertices(d, node)
elif node.tag == inkex.addNS('ellipse', 'svg') or \
node.tag == 'ellipse' or \
node.tag == inkex.addNS('circle', 'svg') or \
node.tag == 'circle':
# Convert circles and ellipses to a path with two 180 degree arcs.
# In general (an ellipse), we convert
#
# <ellipse rx="RX" ry="RY" cx="X" cy="Y"/>
#
# to
#
# <path d="MX1,CY A RX,RY 0 1 0 X2,CY A RX,RY 0 1 0 X1,CY"/>
#
# where
#
# X1 = CX - RX
# X2 = CX + RX
#
# Note: ellipses or circles with a radius attribute of value 0 are ignored
if node.tag == inkex.addNS('ellipse', 'svg') or node.tag == 'ellipse':
rx = float(node.get('rx', '0'))
ry = float(node.get('ry', '0'))
else:
rx = float(node.get('r', '0'))
ry = rx
if rx == 0 or ry == 0:
pass
cx = float(node.get('cx', '0'))
cy = float(node.get('cy', '0'))
x1 = cx - rx
x2 = cx + rx
d = 'M %f,%f ' % (x1, cy) + \
'A %f,%f ' % (rx, ry) + \
'0 1 0 %f,%f ' % (x2, cy) + \
'A %f,%f ' % (rx, ry) + \
'0 1 0 %f,%f' % (x1, cy)
self.DebugMsg('Arc :'+ d +'\n')
self.getPathVertices(d, node)
elif node.tag == inkex.addNS('pattern', 'svg') or node.tag == 'pattern':
pass
elif node.tag == inkex.addNS('metadata', 'svg') or node.tag == 'metadata':
pass
elif node.tag == inkex.addNS('defs', 'svg') or node.tag == 'defs':
pass
elif node.tag == inkex.addNS('desc', 'svg') or node.tag == 'desc':
pass
elif node.tag == inkex.addNS('namedview', 'sodipodi') or node.tag == 'namedview':
pass
elif node.tag == inkex.addNS('eggbot', 'svg') or node.tag == 'eggbot':
pass
elif node.tag == inkex.addNS('text', 'svg') or node.tag == 'text':
inkex.errormsg('Warning: unable to draw text, please convert it to a path first.')
pass
elif node.tag == inkex.addNS('title', 'svg') or node.tag == 'title':
pass
elif node.tag == inkex.addNS('image', 'svg') or node.tag == 'image':
if not self.warnings.has_key('image'):
inkex.errormsg(gettext.gettext('Warning: unable to draw bitmap images; ' +
'please convert them to line art first. Consider using the "Trace bitmap..." ' +
'tool of the "Path" menu. Mac users please note that some X11 settings may ' +
'cause cut-and-paste operations to paste in bitmap copies.'))
self.warnings['image'] = 1
pass
elif node.tag == inkex.addNS('pattern', 'svg') or node.tag == 'pattern':
pass
elif node.tag == inkex.addNS('radialGradient', 'svg') or node.tag == 'radialGradient':
# Similar to pattern
pass
elif node.tag == inkex.addNS('linearGradient', 'svg') or node.tag == 'linearGradient':
# Similar in pattern
pass
elif node.tag == inkex.addNS('style', 'svg') or node.tag == 'style':
# This is a reference to an external style sheet and not the value
# of a style attribute to be inherited by child elements
pass
elif node.tag == inkex.addNS('cursor', 'svg') or node.tag == 'cursor':
pass
elif node.tag == inkex.addNS('color-profile', 'svg') or node.tag == 'color-profile':
# Gamma curves, color temp, etc. are not relevant to single color output
pass
elif not isinstance(node.tag, basestring):
# This is likely an XML processing instruction such as an XML
# comment. lxml uses a function reference for such node tags
# and as such the node tag is likely not a printable string.
# Further, converting it to a printable string likely won't
# be very useful.
pass
else:
inkex.errormsg('Warning: unable to draw object <%s>, please convert it to a path first.' % node.tag)
pass
def effect(self):
# convert units
unit = self.options.unit
self.thickness = self.svg.unittouu(str(self.options.thickness) + unit)
self.height = self.svg.unittouu(str(self.options.zc) + unit)
self.max_flex_size = self.svg.unittouu(str(self.options.max_size_flex) + unit)
self.notchesInterval = int(self.options.notch_interval)
svg = self.document.getroot()
docWidth = self.svg.unittouu(svg.get('width'))
docHeigh = self.svg.unittouu(svg.attrib['height'])
# Open Debug file if requested
if self.options.Mode_Debug:
try:
self.fDebug = open('DebugPath2Flex.txt', 'w')
except IOError:
print ('cannot open debug output file')
self.DebugMsg("Start processing\n")
# First traverse the document (or selected items), reducing
# everything to line segments. If working on a selection,
# then determine the selection's bounding box in the process.
# (Actually, we just need to know it's extrema on the x-axis.)
# Traverse the selected objects
for id in self.options.ids:
self.recursivelyTraverseSvg([self.svg.selected[id]])
# Determine the center of the drawing's bounding box
self.cx = self.xmin + (self.xmax - self.xmin) / 2.0
self.cy = self.ymin + (self.ymax - self.ymin) / 2.0
layer = etree.SubElement(svg, 'g')
layer.set(inkex.addNS('label', 'inkscape'), 'Flex_Path')
layer.set(inkex.addNS('groupmode', 'inkscape'), 'layer')
# For each path, build a polygon with notches and the corresponding flex.
for key in self.paths:
self.writeModifiedPath(key, layer)
if self.fDebug:
self.fDebug.close()
if __name__ == '__main__':
Path2Flex().run()
Reference in New Issue Copy Permalink