656 lines
36 KiB
Python
656 lines
36 KiB
Python
#!/usr/bin/env python3
|
|
|
|
import inkex
|
|
from inkex.bezier import csplength, csparea
|
|
from lxml import etree
|
|
import re
|
|
import math
|
|
import datetime
|
|
|
|
class LaserCheck(inkex.EffectExtension):
|
|
|
|
'''
|
|
ToDos:
|
|
- check for old styles which should be upgraded
|
|
- self-intersecting paths
|
|
- number of parts to weed in total; number of parts which are smaller than vector grid
|
|
- add some inkex.Desc to all elements which were checked and which have some issue. use special syntax to remove old stuff each time the check is applied again
|
|
- this code is horrible ugly stuff
|
|
- output time/cost estimations per stroke color
|
|
- add check for stroke colors -> make some useful predefinitions like (for default modes)
|
|
- black = cutting
|
|
- blue = cutting inside
|
|
- green = cutting outside
|
|
- pink = Vektorgravur
|
|
...
|
|
'''
|
|
|
|
def add_arguments(self, pars):
|
|
pars.add_argument('--tab')
|
|
|
|
pars.add_argument('--machine_size', default="812x508")
|
|
pars.add_argument('--max_cutting_speed', type=float, default=500)
|
|
pars.add_argument('--max_travel_speed', type=float, default=150)
|
|
pars.add_argument('--cut_travel_factor', type=float, default=0.60)
|
|
pars.add_argument('--price_per_minute_gross', type=float, default=2.0)
|
|
pars.add_argument('--vector_grid_xy', type=float, default=12.0) #TODO
|
|
|
|
pars.add_argument('--show_issues_only', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--checks', default="check_all")
|
|
pars.add_argument('--bbox', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--bbox_offset', type=float, default=5.000)
|
|
pars.add_argument('--cutting_estimation', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--elements_outside_canvas', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--groups_and_layers', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--clones', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--clippaths', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--images', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--texts', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--lowlevelstrokes', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--stroke_colors', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--stroke_colors_max', type=int, default=3)
|
|
pars.add_argument('--stroke_widths', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--stroke_widths_max', type=int, default=1)
|
|
pars.add_argument('--stroke_opacities', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--cosmestic_dashes', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--invisible_shapes', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--pointy_paths', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--transformations', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--short_paths', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--short_paths_min', type=float, default=1.000)
|
|
pars.add_argument('--non_path_shapes', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--nodes_per_path', type=inkex.Boolean, default=False)
|
|
pars.add_argument('--nodes_per_path_max', type=int, default=2)
|
|
pars.add_argument('--nodes_per_path_interval', type=float, default=10.000)
|
|
|
|
def effect(self):
|
|
|
|
so = self.options
|
|
machineWidth = self.svg.unittouu(so.machine_size.split('x')[0] + "mm")
|
|
machineHeight = self.svg.unittouu(so.machine_size.split('x')[1] + "mm")
|
|
selected = [] #total list of elements to parse
|
|
|
|
|
|
def parseChildren(element):
|
|
if element not in selected:
|
|
selected.append(element)
|
|
children = element.getchildren()
|
|
if children is not None:
|
|
for child in children:
|
|
if child not in selected:
|
|
selected.append(child)
|
|
parseChildren(child) #go deeper and deeper
|
|
|
|
#check if we have selected elements or if we should parse the whole document instead
|
|
if len(self.svg.selected) == 0:
|
|
for element in self.document.getroot().iter(tag=etree.Element):
|
|
if element != self.document.getroot():
|
|
|
|
selected.append(element)
|
|
else:
|
|
for element in self.svg.selected.values():
|
|
parseChildren(element)
|
|
|
|
namedView = self.document.getroot().find(inkex.addNS('namedview', 'sodipodi'))
|
|
doc_units = namedView.get(inkex.addNS('document-units', 'inkscape'))
|
|
user_units = namedView.get(inkex.addNS('units'))
|
|
pagecolor = namedView.get('pagecolor')
|
|
inkex.utils.debug("---------- Default checks")
|
|
inkex.utils.debug("Document units: {}".format(doc_units))
|
|
inkex.utils.debug("User units: {}".format(user_units))
|
|
|
|
'''
|
|
The SVG format is highly complex and offers a lot of possibilities. Most things of SVG we do not
|
|
need for a laser cutter. Usually we need svg:path and maybe svg:image; we can drop a lot of stuff
|
|
like svg:defs, svg:desc, gradients, etc.
|
|
'''
|
|
nonShapes = []
|
|
shapes = []
|
|
for element in selected:
|
|
if not isinstance(element, inkex.ShapeElement):
|
|
nonShapes.append(element)
|
|
else:
|
|
shapes.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} shape elements in total".format(len(shapes)))
|
|
inkex.utils.debug("{} non-shape elements in total".format(len(nonShapes)))
|
|
for nonShape in nonShapes:
|
|
inkex.utils.debug("non-shape id={}".format(nonShape.get('id')))
|
|
|
|
|
|
'''
|
|
Nearly each laser job needs a bit of border to place the material inside the laser. Often
|
|
we have to fixate on vector grid, pin grid or task plate. Thus we need tapes or pins. So we
|
|
leave some borders off the actual part geometries.
|
|
'''
|
|
if so.checks == "check_all" or so.bbox is True:
|
|
inkex.utils.debug("\n---------- Borders around all elements - minimum offset {} mm from each side".format(so.bbox_offset))
|
|
bbox = inkex.BoundingBox()
|
|
for element in self.document.getroot().iter(tag=etree.Element):
|
|
if element != self.document.getroot() and isinstance(element, inkex.ShapeElement) and element.tag != inkex.addNS('use','svg') and element.get('inkscape:groupmode') != 'layer': #bbox fails for svg:use elements and layers
|
|
transform = inkex.Transform()
|
|
parent = element.getparent()
|
|
if parent is not None and isinstance(parent, inkex.ShapeElement):
|
|
transform = parent.composed_transform()
|
|
try:
|
|
if isinstance (element, inkex.Rectangle) or \
|
|
isinstance (element, inkex.Circle) or \
|
|
isinstance (element, inkex.Ellipse):
|
|
bbox += element.bounding_box() * scale_factor
|
|
elif isinstance (element, inkex.TextElement) or \
|
|
isinstance (element, inkex.Tspan):
|
|
continue
|
|
else:
|
|
bbox += element.bounding_box(transform)
|
|
except Exception:
|
|
transform = element.composed_transform()
|
|
x1, y1 = transform.apply_to_point([0, 0])
|
|
x2, y2 = transform.apply_to_point([1, 1])
|
|
bbox += inkex.BoundingBox((x1, x2), (y1, y2))
|
|
|
|
if abs(bbox.width) == math.inf or abs(bbox.height) == math.inf:
|
|
inkex.utils.debug("bounding box could not be calculated. SVG seems to be empty.")
|
|
#else:
|
|
# inkex.utils.debug("bounding box is {}".format(bbox))
|
|
scale_factor = self.svg.unittouu("1px")
|
|
page_width = self.svg.unittouu(self.document.getroot().attrib['width'])
|
|
width_height = self.svg.unittouu(self.document.getroot().attrib['height'])
|
|
fmm = self.svg.unittouu(str(so.bbox_offset) + "mm")
|
|
bb_left = round(bbox.left, 3)
|
|
bb_right = round(bbox.right, 3)
|
|
bb_top = round(bbox.top, 3)
|
|
bb_bottom = round(bbox.bottom, 3)
|
|
bb_width = round(bbox.width, 3)
|
|
bb_height = round(bbox.height, 3)
|
|
if bb_left >= fmm:
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("left border... ok")
|
|
else:
|
|
inkex.utils.debug("left border... fail: {:0.3f} mm".format(self.svg.uutounit(bb_left, "mm")))
|
|
|
|
if bb_top >= fmm:
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("top border... ok")
|
|
else:
|
|
inkex.utils.debug("top border... fail: {:0.3f} mm".format(self.svg.uutounit(bb_top, "mm")))
|
|
|
|
if bb_right + fmm <= page_width:
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("right border... ok")
|
|
else:
|
|
inkex.utils.debug("right border... fail: {:0.3f} mm".format(self.svg.uutounit(bb_right, "mm")))
|
|
|
|
if bb_bottom + fmm <= width_height:
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("bottom border... ok")
|
|
else:
|
|
inkex.utils.debug("bottom border... fail: {:0.3f} mm".format(self.svg.uutounit(bb_bottom, "mm")))
|
|
if bb_width <= machineWidth:
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("page width... ok")
|
|
else:
|
|
inkex.utils.debug("page width... fail: {:0.3f} mm".format(bb_width))
|
|
if bb_height <= machineHeight:
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("page height... ok")
|
|
else:
|
|
inkex.utils.debug("page height... fail: {:0.3f} mm".format(bb_height))
|
|
|
|
|
|
if so.checks == "check_all" or so.groups_and_layers is True:
|
|
inkex.utils.debug("\n---------- Groups and layers")
|
|
global md
|
|
md = 0
|
|
def maxDepth(element, level):
|
|
global md
|
|
if (level == md):
|
|
md += 1
|
|
for child in element:
|
|
maxDepth(child, level + 1)
|
|
maxDepth(self.document.getroot(), -1)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("Maximum group depth={}".format(md - 1))
|
|
if md - 1 > 2:
|
|
self.msg("Warning: this group depth might cause issues!")
|
|
groups = []
|
|
layers = []
|
|
for element in selected:
|
|
if element.tag == inkex.addNS('g','svg'):
|
|
if element.get('inkscape:groupmode') == 'layer':
|
|
layers.append(element)
|
|
else:
|
|
groups.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} groups in total".format(len(groups)))
|
|
inkex.utils.debug("{} layers in total".format(len(layers)))
|
|
|
|
#check for empty groups
|
|
for group in groups:
|
|
if len(group) == 0:
|
|
inkex.utils.debug("id={} is empty group".format(group.get('id')))
|
|
|
|
#check for empty layers
|
|
for layer in layers:
|
|
if len(layer) == 0:
|
|
inkex.utils.debug("id={} is empty layer".format(layer.get('id')))
|
|
|
|
'''
|
|
Clones should be unlinked because they cause similar issues like transformations
|
|
'''
|
|
if so.checks == "check_all" or so.clones is True:
|
|
inkex.utils.debug("\n---------- Clones (svg:use) - maybe unlink")
|
|
uses = []
|
|
for element in selected:
|
|
if element.tag == inkex.addNS('use','svg'):
|
|
uses.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} svg:use clones in total".format(len(uses)))
|
|
for use in uses:
|
|
inkex.utils.debug("id={}".format(use.get('id')))
|
|
|
|
|
|
'''
|
|
Clip paths are neat to visualize things, but they do not perform a real path cutting.
|
|
Please perform real intersections to have an intact target geometry.
|
|
'''
|
|
if so.checks == "check_all" or so.clippaths is True:
|
|
inkex.utils.debug("\n---------- Clippings (svg:clipPath) - please replace with real cut paths")
|
|
clipPaths = []
|
|
for element in selected:
|
|
if element.tag == inkex.addNS('clipPath','svg'):
|
|
clipPaths.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} svg:clipPath in total".format(len(clipPaths)))
|
|
for clipPath in clipPaths:
|
|
inkex.utils.debug("id={}".format(clipPath.get('id')))
|
|
|
|
|
|
'''
|
|
Sometimes images look like vector but they are'nt. In case you dont want to perform engraving, either
|
|
check to drop or trace to vector paths
|
|
'''
|
|
if so.checks == "check_all" or so.images is True:
|
|
inkex.utils.debug("\n---------- Images (svg:image) - maybe trace to svg")
|
|
images = []
|
|
for element in selected:
|
|
if element.tag == inkex.addNS('image','svg'):
|
|
images.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} svg:image in total".format(len(images)))
|
|
for image in images:
|
|
inkex.utils.debug("image id={}".format(image.get('id')))
|
|
|
|
|
|
'''
|
|
Low level strokes cannot be properly edited in Inkscape (no node handles). Converting helps
|
|
'''
|
|
if so.checks == "check_all" or so.lowlevelstrokes is True:
|
|
inkex.utils.debug("\n---------- Low level strokes (svg:line/polyline/polygon) - maybe convert to path")
|
|
lowlevels = []
|
|
for element in selected:
|
|
if element.tag in (inkex.addNS('line','svg'), inkex.addNS('polyline','svg'), inkex.addNS('polygon','svg')):
|
|
lowlevels.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} low level strokes in total".format(len(lowlevels)))
|
|
for lowlevel in lowlevels:
|
|
inkex.utils.debug("id={}".format(lowlevel.get('id')))
|
|
|
|
|
|
'''
|
|
Texts cause problems when sharing with other people. You must ensure that everyone has the
|
|
font files installed you used. Convert to paths avoids this issue and guarantees same result
|
|
everywhere.
|
|
'''
|
|
if so.checks == "check_all" or so.texts is True:
|
|
inkex.utils.debug("\n---------- Texts (should be converted to paths)")
|
|
texts = []
|
|
for element in selected:
|
|
if element.tag == inkex.addNS('text','svg'):
|
|
texts.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} svg:text in total".format(len(texts)))
|
|
for text in texts:
|
|
inkex.utils.debug("id={}".format(text.get('id')))
|
|
|
|
|
|
|
|
'''
|
|
The more stroke colors the more laser job configuration is required. Reduce the SVG file
|
|
to a minimum of stroke colors to be quicker
|
|
'''
|
|
if so.checks == "check_all" or so.stroke_colors is True:
|
|
inkex.utils.debug("\n---------- Stroke colors ({} are allowed)".format(so.stroke_colors_max))
|
|
strokeColors = []
|
|
for element in shapes:
|
|
style = element.get('style')
|
|
if style is not None:
|
|
stroke = re.search('(;|^)stroke:(.*?)(;|$)', style)
|
|
if stroke is not None:
|
|
strokeColor = stroke[0].split("stroke:")[1].split(";")[0]
|
|
if strokeColor not in strokeColors:
|
|
strokeColors.append(strokeColor)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} different stroke colors in total".format(len(strokeColors)))
|
|
if len(strokeColors) > so.stroke_colors_max:
|
|
for strokeColor in strokeColors:
|
|
inkex.utils.debug("stroke color {}".format(strokeColor))
|
|
|
|
|
|
'''
|
|
Different stroke widths might behave the same like different stroke colors. Reduce to a minimum set.
|
|
Ideally all stroke widths are set to 1 pixel.
|
|
'''
|
|
if so.checks == "check_all" or so.stroke_widths is True:
|
|
inkex.utils.debug("\n---------- Stroke widths ({} are allowed)".format(so.stroke_widths_max))
|
|
strokeWidths = []
|
|
for element in shapes:
|
|
style = element.get('style')
|
|
if style is not None:
|
|
stroke_width = re.search('stroke-width:(.*?)(;|$)', style)
|
|
if stroke_width is not None:
|
|
strokeWidth = stroke_width[0].split("stroke-width:")[1].split(";")[0] #possibly w/o units. could contain units from css
|
|
if strokeWidth not in strokeWidths:
|
|
strokeWidths.append(strokeWidth)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} different stroke widths in total".format(len(strokeWidths)))
|
|
if len(strokeWidths) > so.stroke_widths_max:
|
|
for strokeWidth in strokeWidths:
|
|
swConverted = self.svg.uutounit(float(self.svg.unittouu(strokeWidth))) #possibly w/o units. we unify to some internal float
|
|
inkex.utils.debug("stroke width {}px ({}mm)".format(
|
|
round(self.svg.uutounit(swConverted, "px"),4),
|
|
round(self.svg.uutounit(swConverted, "mm"),4),
|
|
)
|
|
)
|
|
|
|
|
|
'''
|
|
Cosmetic dashes cause simulation issues and are no real cut paths. It's similar to the thing
|
|
with clip paths. Please convert lines to real dash segments if you want to laser them.
|
|
'''
|
|
if so.checks == "check_all" or so.cosmestic_dashes is True:
|
|
inkex.utils.debug("\n---------- Cosmetic dashes - should be converted to paths")
|
|
strokeDasharrays = []
|
|
for element in shapes:
|
|
style = element.get('style')
|
|
if style is not None:
|
|
stroke_dasharray = re.search('stroke-dasharray:(.*?)(;|$)', style)
|
|
if stroke_dasharray is not None:
|
|
strokeDasharray = stroke_dasharray[0].split("stroke-dasharray:")[1].split(";")[0]
|
|
if strokeDasharray not in strokeDasharrays:
|
|
strokeDasharrays.append(strokeDasharray)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} different stroke dash arrays in total".format(len(strokeDasharrays)))
|
|
for strokeDasharray in strokeDasharrays:
|
|
inkex.utils.debug("stroke dash array {}".format(strokeDasharray))
|
|
|
|
|
|
'''
|
|
Shapes/paths with the same color like the background, 0% opacity, etc. lead to strange
|
|
laser cutting results, like duplicated edges, enlarged laser times and more. Please double
|
|
check for such occurences.
|
|
'''
|
|
if so.checks == "check_all" or so.invisible_shapes is True:
|
|
inkex.utils.debug("\n---------- Invisible shapes")
|
|
invisibles = []
|
|
for element in shapes:
|
|
if element.tag not in (inkex.addNS('tspan','svg')):
|
|
style = element.get('style')
|
|
if style is not None:
|
|
stroke = re.search('stroke:(.*?)(;|$)', style) #filter white on white (we guess the background color of the document is white too but we do not check)
|
|
if stroke is None:
|
|
strokeVis = 0
|
|
elif stroke[0].split("stroke:")[1].split(";")[0] == 'none':
|
|
strokeVis = 0
|
|
elif stroke[0].split("stroke:")[1].split(";")[0] in ('#ffffff', 'white', 'rgb(255,255,255)'):
|
|
strokeVis = 0
|
|
else:
|
|
strokeVis = 1
|
|
|
|
stroke_width = re.search('stroke-width:(.*?)(;|$)', style)
|
|
if stroke_width is None:
|
|
widthVis = 0
|
|
elif self.svg.unittouu(stroke_width[0].split("stroke-width:")[1].split(";")[0]) < 0.005: #really thin (0,005pc = 0,080px)
|
|
widthVis = 0
|
|
else:
|
|
widthVis = 1
|
|
|
|
stroke_opacity = re.search('stroke-opacity:(.*?)(;|$)', style)
|
|
if stroke_opacity is None:
|
|
strokeOpacityVis = 0
|
|
elif float(stroke_opacity[0].split("stroke-opacity:")[1].split(";")[0]) < 0.05: #nearly invisible (<5% opacity)
|
|
strokeOpacityVis = 0
|
|
else:
|
|
strokeOpacityVis = 1
|
|
|
|
if pagecolor == '#ffffff':
|
|
invisColors = [pagecolor, 'white', 'rgb(255,255,255)']
|
|
else:
|
|
invisColors = [pagecolor] #we could add some parser to convert pagecolor to rgb/hsl/cmyk
|
|
fill = re.search('fill:(.*?)(;|$)', style)
|
|
if fill is None:
|
|
fillVis = 0
|
|
elif fill[0].split("fill:")[1].split(";")[0] == 'none':
|
|
fillVis = 0
|
|
elif fill[0].split("fill:")[1].split(";")[0] in invisColors:
|
|
fillVis = 0
|
|
else:
|
|
fillVis = 1
|
|
|
|
fill_opacity = re.search('fill-opacity:(.*?)(;|$)', style)
|
|
if fill_opacity is None:
|
|
fillOpacityVis = 0
|
|
elif float(fill_opacity[0].split("fill-opacity:")[1].split(";")[0]) < 0.05: #nearly invisible (<5% opacity)
|
|
fillOpacityVis = 0
|
|
else:
|
|
fillOpacityVis = 1
|
|
|
|
#inkex.utils.debug("strokeVis={}, widthVis={}, strokeOpacityVis={}, fillVis={}, fillOpacityVis={}".format(strokeVis, widthVis, strokeOpacityVis, fillVis, fillOpacityVis))
|
|
if (strokeVis == 0 or widthVis == 0 or strokeOpacityVis == 0) and (fillVis == 0 or fillOpacityVis == 0):
|
|
if element not in invisibles:
|
|
invisibles.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} invisible shapes in total".format(len(invisibles)))
|
|
for invisible in invisibles:
|
|
inkex.utils.debug("id={}".format(invisible.get('id')))
|
|
|
|
|
|
'''
|
|
Additionally, stroke opacities less than 1.0 cause problems in most laser softwares. Please
|
|
adjust all strokes to use full opacity.
|
|
'''
|
|
if so.checks == "check_all" or so.stroke_opacities is True:
|
|
inkex.utils.debug("\n---------- Objects with stroke transparencies < 1.0 - should be set to 1.0")
|
|
transparencies = []
|
|
for element in shapes:
|
|
style = element.get('style')
|
|
if style is not None:
|
|
stroke_opacity = re.search('stroke-opacity:(.*?)(;|$)', style)
|
|
if stroke_opacity is not None:
|
|
if float(stroke_opacity[0].split("stroke-opacity:")[1].split(";")[0]) < 1.0:
|
|
if element not in transparencies:
|
|
transparencies.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} objects with stroke transparencies < 1.0 in total".format(len(transparencies)))
|
|
for transparency in transparencies:
|
|
inkex.utils.debug("id={}".format(transparency.get('id')))
|
|
|
|
'''
|
|
We look for paths which are just points. Those are useless in case of lasercutting.
|
|
Note: this scan only works for paths, not for subpaths. If so, you need to break apart before
|
|
'''
|
|
if so.checks == "check_all" or so.pointy_paths is True:
|
|
inkex.utils.debug("\n---------- Pointy paths - should be deleted")
|
|
pointyPaths = []
|
|
for element in shapes:
|
|
if isinstance(element, inkex.PathElement):
|
|
p = element.path
|
|
commandsCoords = p.to_arrays()
|
|
if len(commandsCoords) == 1 or \
|
|
(len(commandsCoords) == 2 and commandsCoords[0][1] == commandsCoords[1][1]) or \
|
|
(len(commandsCoords) == 2 and commandsCoords[-1][0] == 'Z') or \
|
|
(len(commandsCoords) == 3 and commandsCoords[0][1] == commandsCoords[1][1] and commandsCoords[2][1] == 'Z'):
|
|
pointyPaths.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} pointy paths in total".format(len(pointyPaths)))
|
|
for pointyPath in pointyPaths:
|
|
inkex.utils.debug("id={}".format(pointyPath.get('id')))
|
|
|
|
|
|
'''
|
|
Transformations often lead to wrong stroke widths or mis-rendering in end software. The best we
|
|
can do with a final SVG is to remove all relative translations, rotations and scalings. We should
|
|
apply absolute coordinates only.
|
|
'''
|
|
if so.checks == "check_all" or so.transformations is True:
|
|
inkex.utils.debug("\n---------- Transformations - should be applied to absolute")
|
|
transformations = []
|
|
for element in shapes:
|
|
if element.get('transform') is not None:
|
|
transformations.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} transformation in total".format(len(transformations)))
|
|
for transformation in transformations:
|
|
inkex.utils.debug("transformation in id={}".format(transformation.get('id')))
|
|
|
|
'''
|
|
Really short paths can cause issues with laser cutter mechanics and should be avoided to
|
|
have healthier stepper motor belts, etc.
|
|
'''
|
|
if so.checks == "check_all" or so.short_paths is True:
|
|
inkex.utils.debug("\n---------- Short paths (< {} mm)".format(so.short_paths_min))
|
|
shortPaths = []
|
|
totalLength = 0
|
|
totalDropLength = 0
|
|
for element in shapes:
|
|
if isinstance(element, inkex.PathElement):
|
|
slengths, stotal = csplength(element.path.transform(element.composed_transform()).to_superpath())
|
|
totalLength += stotal
|
|
if stotal < self.svg.unittouu(str(so.short_paths_min) + "mm"):
|
|
shortPaths.append([element, stotal])
|
|
totalDropLength += stotal
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} short paths in total".format(len(shortPaths)))
|
|
if totalDropLength > 0:
|
|
inkex.utils.debug("{:0.2f}% of total ({:0.2f} mm /{:0.2f} mm)".format(totalDropLength / totalLength, self.svg.uutounit(str(totalDropLength), "mm"), self.svg.uutounit(str(totalLength), "mm")))
|
|
for shortPath in shortPaths:
|
|
inkex.utils.debug("id={}, length={}mm".format(shortPath[0].get('id'), round(self.svg.uutounit(str(shortPath[1]), "mm"), 3)))
|
|
|
|
'''
|
|
Really short paths can cause issues with laser cutter mechanics and should be avoided to
|
|
have healthier stepper motor belts, etc.
|
|
'''
|
|
if so.checks == "check_all" or so.cutting_estimation is True:
|
|
inkex.utils.debug("\n---------- Cutting time estimation")
|
|
totalCuttingLength = 0
|
|
for element in shapes:
|
|
if isinstance(element, inkex.PathElement):
|
|
slengths, stotal = csplength(element.path.transform(element.composed_transform()).to_superpath())
|
|
totalCuttingLength += stotal
|
|
extraTraveLength = (machineWidth / 3 + machineHeight / 3) * 2.0 #from top-left to the ~1/3 of the bed and back again
|
|
totalTravelLength = totalCuttingLength * (1.0 - so.cut_travel_factor) + extraTraveLength
|
|
totalLength = totalCuttingLength + totalTravelLength
|
|
inkex.utils.debug("(measured) cutting length (mm) = {:0.2f} mm".format(self.svg.uutounit(str(totalCuttingLength), "mm"), self.svg.uutounit(str(totalCuttingLength), "mm")))
|
|
inkex.utils.debug("(estimated) travel length (mm) = {:0.2f} mm".format(self.svg.uutounit(str(totalTravelLength), "mm"), self.svg.uutounit(str(totalTravelLength), "mm")))
|
|
inkex.utils.debug("(estimated) total length (mm) = {:0.2f} mm".format(self.svg.uutounit(str(totalLength), "mm"), self.svg.uutounit(str(totalLength), "mm")))
|
|
for speedFactor in [100,90,80,70,60,50,40,30,20,10,5]:
|
|
v_cut = so.max_cutting_speed * speedFactor/100.0
|
|
v_travel = so.max_travel_speed #this is always at maximum
|
|
tsec_cut = self.svg.uutounit(str(totalCuttingLength)) / v_cut
|
|
tsec_travel = self.svg.uutounit(str(totalTravelLength)) / v_travel
|
|
tsec_total = tsec_cut + tsec_travel
|
|
minutes, seconds = divmod(tsec_total, 60) # split the seconds to minutes and seconds
|
|
partial_minutes = round(seconds/60 * 2) / 2
|
|
inkex.utils.debug("@{:03.0f}% (cut={:06.2f}mm/s | travel={:06.2f}mm/s) > {:03.0f}min {:02.0f}sec | cost={:02.0f}€".format(speedFactor, v_cut, v_travel, minutes, seconds, so.price_per_minute_gross * (minutes + partial_minutes)))
|
|
|
|
|
|
'''
|
|
Paths with a high amount of nodes will cause issues because each node means slowing down/speeding up the laser mechanics
|
|
'''
|
|
if so.checks == "check_all" or so.nodes_per_path is True:
|
|
inkex.utils.debug("\n---------- Heavy node-loaded paths (allowed: {} node(s) per {} mm) - should be simplified".format(so.nodes_per_path_max, round(so.nodes_per_path_interval, 3)))
|
|
heavyPaths = []
|
|
for element in shapes:
|
|
if isinstance(element, inkex.PathElement):
|
|
slengths, stotal = csplength(element.path.transform(element.composed_transform()).to_superpath())
|
|
nodes = len(element.path)
|
|
if nodes / stotal > so.nodes_per_path_max / self.svg.unittouu(str(so.nodes_per_path_interval) + "mm"):
|
|
heavyPaths.append([element, nodes, stotal])
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} Heavy node-loaded paths in total".format(len(heavyPaths)))
|
|
for heavyPath in heavyPaths:
|
|
inkex.utils.debug("id={}, nodes={}, length={}mm, density={}nodes/mm".format(
|
|
heavyPath[0].get('id'),
|
|
heavyPath[1],
|
|
round(self.svg.uutounit(str(heavyPath[2]), "mm"), 3),
|
|
round(heavyPath[1] / self.svg.uutounit(str(heavyPath[2]), "mm"), 3)
|
|
)
|
|
)
|
|
|
|
'''
|
|
Elements outside canvas or touching the border. These are critical because they won't be lasered or not correctly lasered
|
|
'''
|
|
if so.checks == "check_all" or so.elements_outside_canvas is True:
|
|
inkex.utils.debug("\n---------- Elements outside canvas or touching the border")
|
|
elementsOutside = []
|
|
for element in shapes:
|
|
if element.tag != inkex.addNS('g', 'svg'):
|
|
ebbox = element.bounding_box()
|
|
precision = 3
|
|
#inkex.utils.debug("{} | bbox: left = {:0.3f} right = {:0.3f} top = {:0.3f} bottom = {:0.3f}".format(element.get('id'), ebbox.left, ebbox.right, ebbox.top, ebbox.bottom))
|
|
pagew = round(self.svg.unittouu(self.svg.get('width')), precision)
|
|
pageh = round(self.svg.unittouu(self.svg.get('height')), precision)
|
|
if round(ebbox.right, precision) == 0 or \
|
|
round(ebbox.left, precision) == pagew or \
|
|
round(ebbox.top, precision) == 0 or \
|
|
round(ebbox.bottom, precision) == pageh:
|
|
elementsOutside.append([element, "touching"])
|
|
elif \
|
|
round(ebbox.right, precision) < 0 or \
|
|
round(ebbox.left, precision) > pagew or \
|
|
round(ebbox.top, precision) < 0 or \
|
|
round(ebbox.bottom, precision) > pageh:
|
|
elementsOutside.append([element, "fully outside"])
|
|
else: #fully inside or partially inside/outside. we check if one or more corners is outside the canvas
|
|
rightOutside = False
|
|
leftOutside = False
|
|
topOutside = False
|
|
bottomOutside = False
|
|
if round(ebbox.right, precision) < 0 or round(ebbox.right, precision) > pagew:
|
|
rightOutside = True
|
|
if round(ebbox.left, precision) < 0 or round(ebbox.left, precision) > pagew:
|
|
leftOutside = True
|
|
if round(ebbox.top, precision) < 0 or round(ebbox.top, precision) > pageh:
|
|
topOutside = True
|
|
if round(ebbox.bottom, precision) < 0 or round(ebbox.bottom, precision) > pageh:
|
|
bottomOutside = True
|
|
if rightOutside is True or leftOutside is True or topOutside is True or bottomOutside is True:
|
|
elementsOutside.append([element, "partially outside"])
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} Elements outside canvas or touching the border in total".format(len(elementsOutside)))
|
|
for elementOutside in elementsOutside:
|
|
inkex.utils.debug("id={}, status={}".format(
|
|
elementOutside[0].get('id'),
|
|
elementOutside[1]
|
|
)
|
|
)
|
|
|
|
|
|
'''
|
|
Shapes like rectangles, ellipses, arcs, spirals should be converted to svg:path to have more
|
|
convenience in the file
|
|
'''
|
|
if so.checks == "check_all" or so.non_path_shapes is True:
|
|
inkex.utils.debug("\n---------- Non-path shapes - should be converted to paths")
|
|
nonPathShapes = []
|
|
for element in shapes:
|
|
if not isinstance(element, inkex.PathElement) and not isinstance(element, inkex.Group):
|
|
nonPathShapes.append(element)
|
|
if so.show_issues_only is False:
|
|
inkex.utils.debug("{} non-path shapes in total".format(len(nonPathShapes)))
|
|
for nonPathShape in nonPathShapes:
|
|
inkex.utils.debug("id={}".format(nonPathShape.get('id')))
|
|
|
|
exit(0)
|
|
|
|
if __name__ == '__main__':
|
|
LaserCheck().run() |