704 lines
39 KiB
Python
704 lines
39 KiB
Python
#!/usr/bin/env python3
|
|
|
|
'''
|
|
Extension for InkScape 1.0+
|
|
- WARNING: HORRIBLY SLOW CODE. PLEASE HELP TO MAKE IT USEFUL FOR LARGE AMOUNT OF PATHS
|
|
- add options:
|
|
- find line parts which are included in other lines and perform intersections/splittings (overlapping colinear lines)
|
|
- replace trimmed paths by bezier paths (calculating lengths and required t parameter)
|
|
- find more duplicates
|
|
- overlapping lines in sub splits
|
|
- overlapping in original selection
|
|
- duplicates in original selection
|
|
- duplicates in split bezier
|
|
- ...
|
|
|
|
- important to notice
|
|
- this algorithm might be really slow. Reduce flattening quality to speed up
|
|
- the code quality is horrible. We need a lot of asserts and functions to structure that stuff
|
|
- try to adjust snap tolerance and flatness in case of errors, like
|
|
poly_point_isect.py: "KeyError: 'Event(0x21412ce81c0, s0=(47.16, 179.1),
|
|
s1=(47.17, 178.21), p=(47.16, 179.1), type=2, slope=-88.9999999999531)'"
|
|
- this extension does not check for strange paths. Please ensure that your path 'd'
|
|
data is valid (no pointy paths, no duplicates, etc.)
|
|
- we do not use shapely to look for intersections by cutting each line against
|
|
each other line (line1.intersection(line2) using two for-loops) because this
|
|
kind of logic is really really slow for huge amount. You could use that only
|
|
for ~50-100 elements. So we use special algorihm (Bentley-Ottmann)
|
|
|
|
- things to look at more closely:
|
|
- https://gis.stackexchange.com/questions/203048/split-lines-at-points-using-shapely
|
|
- https://stackoverflow.com/questions/34754777/shapely-split-linestrings-at-intersections-with-other-linestrings
|
|
- There are floating point precision errors when finding a point on a line. Use the distance with an appropriate threshold instead.
|
|
- line.within(point) # False
|
|
- line.distance(point) # 7.765244949417793e-11
|
|
- line.distance(point) < 1e-8 # True
|
|
- https://bezier.readthedocs.io/en/stable/python/reference/bezier.hazmat.clipping.html / https://github.com/dhermes/bezier
|
|
- De Casteljau Algorithm
|
|
|
|
Author: Mario Voigt / FabLab Chemnitz
|
|
Mail: mario.voigt@stadtfabrikanten.org
|
|
Date: 09.08.2020 (extension originally called "Contour Scanner")
|
|
Last patch: 01.06.2021
|
|
License: GNU GPL v3
|
|
'''
|
|
|
|
import sys
|
|
import os
|
|
import copy
|
|
from lxml import etree
|
|
import poly_point_isect
|
|
from poly_point_isect import isect_segments
|
|
import inkex
|
|
from inkex import transforms, bezier, PathElement, Color, Circle
|
|
from inkex.bezier import csplength
|
|
from inkex.paths import Path, CubicSuperPath
|
|
from shapely.geometry import LineString, Point, MultiPoint
|
|
from shapely.ops import snap, split
|
|
from shapely import speedups
|
|
if speedups.available:
|
|
speedups.enable()
|
|
|
|
|
|
idPrefix = "subsplit"
|
|
intersectedVerb = "-intersected-"
|
|
|
|
class ContourScannerAndTrimmer(inkex.EffectExtension):
|
|
|
|
def breakContours(self, element, breakelements = None):
|
|
''' this does the same as "CTRL + SHIFT + K" '''
|
|
if breakelements == None:
|
|
breakelements = []
|
|
if element.tag == inkex.addNS('path','svg'):
|
|
parent = element.getparent()
|
|
idx = parent.index(element)
|
|
idSuffix = 0
|
|
raw = element.path.to_arrays()
|
|
subPaths, prev = [], 0
|
|
for i in range(len(raw)): # Breaks compound paths into simple paths
|
|
if raw[i][0] == 'M' and i != 0:
|
|
subPaths.append(raw[prev:i])
|
|
prev = i
|
|
subPaths.append(raw[prev:])
|
|
for subpath in subPaths:
|
|
replacedelement = copy.copy(element)
|
|
oldId = replacedelement.get('id')
|
|
csp = CubicSuperPath(subpath)
|
|
if len(subpath) > 1 and csp[0][0] != csp[0][1]: #avoids pointy paths like M "31.4794 57.6024 Z"
|
|
replacedelement.set('d', csp)
|
|
replacedelement.set('id', oldId + str(idSuffix))
|
|
parent.insert(idx, replacedelement)
|
|
idSuffix += 1
|
|
breakelements.append(replacedelement)
|
|
parent.remove(element)
|
|
for child in element.getchildren():
|
|
self.breakContours(child, breakelements)
|
|
return breakelements
|
|
|
|
|
|
def getChildPaths(self, element, elements = None):
|
|
''' a function to get child paths from elements (used by "handling groups" option) '''
|
|
if elements == None:
|
|
elements = []
|
|
if element.tag == inkex.addNS('path','svg'):
|
|
elements.append(element)
|
|
for child in element.getchildren():
|
|
self.getChildPaths(child, elements)
|
|
return elements
|
|
|
|
|
|
def getPathElements(self):
|
|
''' get all path elements, either from selection or from whole document. Uses options '''
|
|
pathElements = []
|
|
if len(self.svg.selected) == 0: #if nothing selected we search for the complete document
|
|
pathElements = self.document.xpath('//svg:path', namespaces=inkex.NSS)
|
|
else: # or get selected paths (and children) and convert them to shapely LineString objects
|
|
if self.options.handle_groups is False:
|
|
pathElements = list(self.svg.selection.filter(PathElement).values())
|
|
else:
|
|
for element in self.svg.selection.values():
|
|
pathElements = self.getChildPaths(element, pathElements)
|
|
|
|
if len(pathElements) == 0:
|
|
self.msg('Selection appears to be empty or does not contain any valid svg:path nodes. Try to cast your objects to paths using CTRL + SHIFT + C or strokes to paths using CTRL + ALT + C')
|
|
return
|
|
return pathElements
|
|
|
|
if self.options.break_apart is True:
|
|
breakApartElements = None
|
|
for pathElement in pathElements:
|
|
breakApartElements = self.breakContours(pathElement, breakApartElements)
|
|
pathElements = breakApartElements
|
|
|
|
if self.options.show_debug is True:
|
|
self.msg("total processing paths count: {}".format(len(pathElements)))
|
|
|
|
|
|
def findGroup(self, groupId):
|
|
''' check if a group with a given id exists or not. Returns None if not found, else returns the group element '''
|
|
groups = self.document.xpath('//svg:g', namespaces=inkex.NSS)
|
|
for group in groups:
|
|
#self.msg(str(layer.get('inkscape:label')) + " == " + layerName)
|
|
if group.get('id') == groupId:
|
|
return group
|
|
return None
|
|
|
|
#function to refine the style of the lines
|
|
|
|
|
|
def adjustStyle(self, element):
|
|
''' Replace some style attributes of the given element '''
|
|
if element.attrib.has_key('style'):
|
|
style = element.get('style')
|
|
if style:
|
|
declarations = style.split(';')
|
|
for i,decl in enumerate(declarations):
|
|
parts = decl.split(':', 2)
|
|
if len(parts) == 2:
|
|
(prop, val) = parts
|
|
prop = prop.strip().lower()
|
|
if prop == 'stroke-width':
|
|
declarations[i] = prop + ':' + str(self.svg.unittouu(str(self.options.strokewidth) +"px"))
|
|
if prop == 'fill':
|
|
declarations[i] = prop + ':none'
|
|
element.set('style', ';'.join(declarations) + ';stroke:#000000;stroke-opacity:1.0')
|
|
else:
|
|
element.set('style', 'stroke:#000000;stroke-opacity:1.0')
|
|
|
|
|
|
def lineFromSegments(self, segs, i, decimals):
|
|
'''builds a straight line for the segment i and the next segment i+2. Returns both point XY coordinates'''
|
|
pseudoPath = Path(segs[i:i+2]).to_arrays()
|
|
x1 = round(pseudoPath[0][1][-2], decimals)
|
|
y1 = round(pseudoPath[0][1][-1], decimals)
|
|
if pseudoPath[1][0] == 'Z': #some crappy code when the path is closed
|
|
pseudoPathEnd = Path(segs[0:2]).to_arrays()
|
|
x2 = round(pseudoPathEnd[0][1][-2], decimals)
|
|
y2 = round(pseudoPathEnd[0][1][-1], decimals)
|
|
else:
|
|
x2 = round(pseudoPath[1][1][-2], decimals)
|
|
y2 = round(pseudoPath[1][1][-1], decimals)
|
|
return x1, y1, x2, y2
|
|
|
|
|
|
def visualize_self_intersections(self, pathElement, selfIntersectionPoints):
|
|
''' Draw some circles at given point coordinates (data from array)'''
|
|
selfIntersectionGroup = pathElement.getparent().add(inkex.Group(id="selfIntersectionPoints-{}".format(pathElement.attrib["id"])))
|
|
selfIntersectionPointStyle = {'stroke': 'none', 'fill': self.options.color_self_intersections}
|
|
for selfIntersectionPoint in selfIntersectionPoints:
|
|
cx = selfIntersectionPoint[0]
|
|
cy = selfIntersectionPoint[1]
|
|
selfIntersectionPointCircle = Circle(cx=str(cx),
|
|
cy=str(cy),
|
|
r=str(self.svg.unittouu(str(self.options.dotsize_intersections / 2) + "px"))
|
|
)
|
|
|
|
if pathElement.getparent() != self.svg.root:
|
|
selfIntersectionPointCircle.transform = -pathElement.getparent().composed_transform()
|
|
selfIntersectionPointCircle.set('id', self.svg.get_unique_id('selfIntersectionPoint-'))
|
|
selfIntersectionPointCircle.style = selfIntersectionPointStyle
|
|
selfIntersectionGroup.add(selfIntersectionPointCircle)
|
|
|
|
|
|
def visualize_global_intersections(self, globalIntersectionPoints):
|
|
''' Draw some circles at given point coordinates (data from array)'''
|
|
if len(globalIntersectionPoints) > 0: #only create a group and add stuff if there are some elements to work on
|
|
globalIntersectionGroup = self.svg.root.add(inkex.Group(id="globalIntersectionPoints"))
|
|
globalIntersectionPointStyle = {'stroke': 'none', 'fill': self.options.color_global_intersections}
|
|
for globalIntersectionPoint in globalIntersectionPoints:
|
|
cx = globalIntersectionPoint.coords[0][0]
|
|
cy = globalIntersectionPoint.coords[0][1]
|
|
globalIntersectionPointCircle = Circle(cx=str(cx),
|
|
cy=str(cy),
|
|
r=str(self.svg.unittouu(str(self.options.dotsize_intersections / 2) + "px"))
|
|
)
|
|
globalIntersectionPointCircle.set('id', self.svg.get_unique_id('globalIntersectionPoint-'))
|
|
globalIntersectionPointCircle.style = globalIntersectionPointStyle
|
|
globalIntersectionGroup.add(globalIntersectionPointCircle)
|
|
|
|
|
|
def buildTrimLineGroups(self, allSubSplitData, subSplitIndex, globalIntersectionPoints,
|
|
trimLineIndex, snap_tolerance, apply_original_style):
|
|
''' make a group containing trimmed lines'''
|
|
|
|
trimLineStyle = {'stroke': str(self.options.color_trimmed), 'fill': 'none', 'stroke-width': self.options.strokewidth}
|
|
|
|
linesWithSnappedIntersectionPoints = snap(LineString(allSubSplitData[0][subSplitIndex]), globalIntersectionPoints, snap_tolerance)
|
|
trimGroupId = 'shapely-' + allSubSplitData[1][subSplitIndex].split("_")[0] #spit at "_" (_ from subSplitId)
|
|
trimGroupParentId = allSubSplitData[1][subSplitIndex].split(idPrefix+"-")[1].split("_")[0]
|
|
trimGroupParent = self.svg.getElementById(trimGroupParentId)
|
|
trimGroupParentTransform = trimGroupParent.composed_transform()
|
|
trimGroup = self.findGroup(trimGroupId)
|
|
if trimGroup is None:
|
|
trimGroup = trimGroupParent.getparent().add(inkex.Group(id=trimGroupId))
|
|
|
|
#apply isBezier and original path id information to group (required for bezier splitting the original path at the end)
|
|
trimGroup.attrib['isBezier'] = str(allSubSplitData[3][subSplitIndex])
|
|
trimGroup.attrib['originalId'] = allSubSplitData[4][subSplitIndex]
|
|
|
|
#split all lines against all other lines using the intersection points
|
|
trimLines = split(linesWithSnappedIntersectionPoints, globalIntersectionPoints)
|
|
|
|
splitAt = [] #if the sub split line was split by an intersecting line we receive two trim lines with same assigned original path id!
|
|
prevLine = None
|
|
for j in range(len(trimLines)):
|
|
trimLineId = trimGroupId + "-" + str(trimLineIndex)
|
|
splitAt.append(trimGroupId)
|
|
if splitAt.count(trimGroupId) > 1: #we detected a lines with intersection on
|
|
trimLineId = trimLineId + self.svg.get_unique_id(intersectedVerb)
|
|
'''
|
|
so the previous lines was an intersection lines too. so we change the id to include the intersected verb
|
|
(left side and right side of cut) - note: updating element
|
|
id sometimes seems not to work if the id was used before in Inkscape
|
|
'''
|
|
prevLine.attrib['id'] = trimGroupId + "-" + str(trimLineIndex) + self.svg.get_unique_id(intersectedVerb)
|
|
prevLine.attrib['intersected'] = 'True' #some dirty flag we need
|
|
prevLine = trimLine = inkex.PathElement(id=trimLineId)
|
|
#if so.show_debug is True:
|
|
# self.msg(prevLine.attrib['id'])
|
|
# self.msg(trimLineId)
|
|
x, y = trimLines[j].coords.xy
|
|
trimLine.path = [['M', [x[0],y[0]]], ['L', [x[1],y[1]]]]
|
|
if trimGroupParentTransform is not None:
|
|
trimLine.path = trimLine.path.transform(-trimGroupParentTransform)
|
|
if apply_original_style is False:
|
|
trimLine.style = trimLineStyle
|
|
else:
|
|
trimLine.style = allSubSplitData[2][subSplitIndex]
|
|
trimGroup.add(trimLine)
|
|
return trimGroup
|
|
|
|
|
|
def remove_duplicates(self, allTrimGroups, reverse_removal_order):
|
|
''' find duplicate lines in a given array [] of groups '''
|
|
totalTrimPaths = []
|
|
if reverse_removal_order is True:
|
|
allTrimGroups = allTrimGroups[::-1]
|
|
for trimGroup in allTrimGroups:
|
|
for element in trimGroup:
|
|
if element.path not in totalTrimPaths:
|
|
totalTrimPaths.append(element.path)
|
|
else:
|
|
element.delete()
|
|
if len(trimGroup) == 0:
|
|
trimGroup.delete()
|
|
|
|
|
|
def combine_nonintersects(self, allTrimGroups, apply_original_style):
|
|
'''
|
|
combine and chain all non intersected sub split lines which were trimmed at intersection points before.
|
|
- At first we sort out all lines by their id:
|
|
- if the lines id contains intersectedVerb, we ignore it
|
|
- we combine all lines which do not contain intersectedVerb
|
|
- Then we loop through that combined structure and chain their segments which touch each other
|
|
Changes the style according to user setting.
|
|
|
|
'''
|
|
|
|
nonTrimLineStyle = {'stroke': str(self.options.color_nonintersected), 'fill': 'none', 'stroke-width': self.options.strokewidth}
|
|
trimNonIntersectedStyle = {'stroke': str(self.options.color_combined), 'fill': 'none', 'stroke-width': self.options.strokewidth}
|
|
|
|
for trimGroup in allTrimGroups:
|
|
totalIntersectionsAtPath = 0
|
|
combinedPath = None
|
|
combinedPathData = Path()
|
|
if self.options.show_debug is True:
|
|
self.msg("trim group {} has {} paths".format(trimGroup.get('id'), len(trimGroup)))
|
|
for pElement in trimGroup:
|
|
pId = pElement.get('id')
|
|
#if self.options.show_debug is True:
|
|
# self.msg("trim paths id {}".format(pId))
|
|
if intersectedVerb not in pId:
|
|
if combinedPath is None:
|
|
combinedPath = pElement
|
|
combinedPathData = pElement.path
|
|
else:
|
|
combinedPathData += pElement.path
|
|
pElement.delete()
|
|
else:
|
|
totalIntersectionsAtPath += 1
|
|
if len(combinedPathData) > 0:
|
|
segData = combinedPathData.to_arrays()
|
|
newPathData = []
|
|
newPathData.append(segData[0])
|
|
for z in range(1, len(segData)): #skip first because we add it statically
|
|
if segData[z][1] != segData[z-1][1]:
|
|
newPathData.append(segData[z])
|
|
if self.options.show_debug is True:
|
|
self.msg("trim group {} has {} combinable segments:".format(trimGroup.get('id'), len(newPathData)))
|
|
self.msg("{}".format(newPathData))
|
|
combinedPath.path = Path(newPathData)
|
|
if apply_original_style is False:
|
|
combinedPath.style = trimNonIntersectedStyle
|
|
if totalIntersectionsAtPath == 0:
|
|
combinedPath.style = nonTrimLineStyle
|
|
else: #the group might consist of intersections only. than we have length of 0
|
|
if self.options.show_debug is True:
|
|
self.msg("trim group {} has no combinable segments (contains only intersected trim lines)".format(trimGroup.get('id')))
|
|
|
|
|
|
def trim_bezier(self, allTrimGroups):
|
|
'''
|
|
trim bezier path by checking the lengths and calculating global t parameter from the trimmed sub split lines groups
|
|
This function does not work yet.
|
|
'''
|
|
for trimGroup in allTrimGroups:
|
|
if trimGroup.attrib.has_key('isBezier') and trimGroup.attrib['isBezier'] == "True":
|
|
globalTParameters = []
|
|
if self.options.show_debug is True:
|
|
self.msg("{}: count of trim lines = {}".format(trimGroup.get('id'), len(trimGroup)))
|
|
totalLength = 0
|
|
for trimLine in trimGroup:
|
|
ignore, lineLength = csplength(CubicSuperPath(trimLine.get('d')))
|
|
totalLength += lineLength
|
|
if self.options.show_debug is True:
|
|
self.msg("total length = {}".format(totalLength))
|
|
chainLength = 0
|
|
for trimLine in trimGroup:
|
|
ignore, lineLength = csplength(CubicSuperPath(trimLine.get('d')))
|
|
chainLength += lineLength
|
|
if trimLine.attrib.has_key('intersected') or trimLine == trimGroup[-1]: #we may not used intersectedVerb because this was used for the affected left as well as the right side of the splitting. This would result in one "intersection" too much.
|
|
globalTParameter = chainLength / totalLength
|
|
globalTParameters.append(globalTParameter)
|
|
if self.options.show_debug is True:
|
|
self.msg("chain piece length = {}".format(chainLength))
|
|
self.msg("t parameter = {}".format(globalTParameter))
|
|
chainLength = 0
|
|
if self.options.show_debug is True:
|
|
self.msg("Trimming the original bezier path {} at global t parameters: {}".format(trimGroup.attrib['originalId'], globalTParameters))
|
|
for globalTParameter in globalTParameters:
|
|
csp = CubicSuperPath(self.svg.getElementById(trimGroup.attrib['originalId']))
|
|
'''
|
|
Sadly, those calculated global t parameters are useless for splitting because we cannot split the complete curve at a t parameter
|
|
Instead we only can split a bezier by getting to commands which build up a bezier path segment.
|
|
- we need to find those parts (segment pairs) of the original path first where the sub split line intersection occurs
|
|
- then we need to calculate the t parameter
|
|
- then we split the bezier part (consisting of two commands) and check the new intersection point.
|
|
It should match the sub split lines intersection point.
|
|
If they do not match we need to adjust the t parameter or loop to previous or next bezier command to find intersection
|
|
'''
|
|
|
|
|
|
def add_arguments(self, pars):
|
|
pars.add_argument("--tab")
|
|
|
|
#Settings - General
|
|
pars.add_argument("--show_debug", type=inkex.Boolean, default=False, help="Show debug infos")
|
|
pars.add_argument("--path_types", default="closed_paths", help="Apply for closed paths, open paths or both")
|
|
pars.add_argument("--break_apart", type=inkex.Boolean, default=False, help="Break apart input paths into sub paths")
|
|
pars.add_argument("--handle_groups", type=inkex.Boolean, default=False, help="Also looks for paths in groups which are in the current selection")
|
|
pars.add_argument("--flattenbezier", type=inkex.Boolean, default=True, help="Flatten bezier curves to polylines")
|
|
pars.add_argument("--flatness", type=float, default=0.1, help="Minimum flatness = 0.001. The smaller the value the more fine segments you will get (quantization). Large values might destroy the line continuity.")
|
|
pars.add_argument("--decimals", type=int, default=3, help="Accuracy for sub split lines / lines trimmed by shapely")
|
|
pars.add_argument("--snap_tolerance", type=float, default=0.1, help="Snap tolerance for intersection points")
|
|
|
|
#Settings - Scanning
|
|
pars.add_argument("--remove_opened", type=inkex.Boolean, default=False, help="Remove original opened paths")
|
|
pars.add_argument("--remove_closed", type=inkex.Boolean, default=False, help="Remove original closed paths")
|
|
pars.add_argument("--remove_self_intersecting", type=inkex.Boolean, default=False, help="Remove original self-intersecting paths")
|
|
pars.add_argument("--highlight_opened", type=inkex.Boolean, default=False, help="Highlight opened contours")
|
|
pars.add_argument("--highlight_closed", type=inkex.Boolean, default=False, help="Highlight closed contours")
|
|
pars.add_argument("--highlight_self_intersecting", type=inkex.Boolean, default=False, help="Highlight self-intersecting contours")
|
|
pars.add_argument("--draw_subsplit", type=inkex.Boolean, default=False, help="Draw sub split lines (polylines)")
|
|
pars.add_argument("--visualize_self_intersections", type=inkex.Boolean, default=False, help="Visualize self-intersecting path points")
|
|
pars.add_argument("--visualize_global_intersections", type=inkex.Boolean, default=False, help="Visualize global intersection points")
|
|
|
|
#Settings - Trimming
|
|
pars.add_argument("--draw_trimmed", type=inkex.Boolean, default=False, help="Draw trimmed lines")
|
|
pars.add_argument("--combine_nonintersects", type=inkex.Boolean, default=True, help="Combine non-intersected lines")
|
|
pars.add_argument("--remove_duplicates", type=inkex.Boolean, default=True, help="Remove duplicate trim lines")
|
|
pars.add_argument("--reverse_removal_order", type=inkex.Boolean, default=False, help="Reverses the order of removal. Relevant for keeping certain styles of elements")
|
|
pars.add_argument("--keep_original_after_trim", type=inkex.Boolean, default=False, help="Keep original paths after trimming")
|
|
|
|
#Style - General Style
|
|
pars.add_argument("--strokewidth", type=float, default=1.0, help="Stroke width (px)")
|
|
pars.add_argument("--dotsize_intersections", type=int, default=30, help="Dot size (px) for self-intersecting and global intersection points")
|
|
pars.add_argument("--removefillsetstroke", type=inkex.Boolean, default=False, help="Remove fill and define stroke for original paths")
|
|
pars.add_argument("--bezier_trimming", type=inkex.Boolean, default=False, help="If true we try to use the calculated t parameters from intersection points to receive splitted bezier curves")
|
|
pars.add_argument("--apply_original_style", type=inkex.Boolean, default=True, help="Apply original path style to trimmed lines")
|
|
|
|
#Style - Scanning Colors
|
|
pars.add_argument("--color_opened", type=Color, default='4012452351', help="Color for opened contours")
|
|
pars.add_argument("--color_closed", type=Color, default='2330080511', help="Color for closed contours")
|
|
pars.add_argument("--color_self_intersecting_paths", type=Color, default='2593756927', help="Color for self-intersecting contours")
|
|
pars.add_argument("--color_subsplit", type=Color, default='1630897151', help="Color for sub split lines")
|
|
pars.add_argument("--color_self_intersections", type=Color, default='6320383', help="Color for self-intersecting line points")
|
|
pars.add_argument("--color_global_intersections", type=Color, default='4239343359', help="Color for global intersection points")
|
|
|
|
#Style - Trimming Color
|
|
pars.add_argument("--color_trimmed", type=Color, default='1923076095', help="Color for trimmed lines")
|
|
pars.add_argument("--color_combined", type=Color, default='3227634687', help="Color for non-intersected lines")
|
|
pars.add_argument("--color_nonintersected", type=Color, default='3045284607', help="Color for non-intersected paths")
|
|
|
|
|
|
def effect(self):
|
|
|
|
so = self.options
|
|
|
|
#warn if there is nothing to visualize
|
|
if \
|
|
so.keep_original_after_trim is False and \
|
|
so.remove_opened is True and \
|
|
so.remove_closed is True and \
|
|
so.visualize_self_intersections is False and \
|
|
so.visualize_global_intersections is False and \
|
|
so.draw_subsplit is False and \
|
|
so.draw_trimmed is False:
|
|
self.msg("Nothing to draw. Select at least one visualization option.")
|
|
return
|
|
|
|
#some dependent configuration for drawing modes
|
|
if \
|
|
so.highlight_opened is True or \
|
|
so.highlight_closed is True or \
|
|
so.highlight_self_intersecting is True:
|
|
so.draw_subsplit = True
|
|
if so.draw_subsplit is False:
|
|
so.highlight_open = False
|
|
so.highlight_closed = False
|
|
so.highlight_self_intersecting = False
|
|
|
|
#some constant stuff / styles
|
|
keepOpenPathStyle = {'stroke': str(so.color_opened), 'fill': 'none', 'stroke-width': so.strokewidth}
|
|
keepClosedPathStyle = {'stroke': str(so.color_closed), 'fill': 'none', 'stroke-width': so.strokewidth}
|
|
keepSelfIntersectingPathStyle = {'stroke': str(so.color_self_intersecting_paths), 'fill': 'none', 'stroke-width': so.strokewidth}
|
|
subSplitLineStyle = {'stroke': str(so.color_subsplit), 'fill': 'none', 'stroke-width': so.strokewidth}
|
|
|
|
''' 1 //
|
|
get all paths which are within selection or in document and generate sub split lines
|
|
If flatten is enabled, we do the best approximation into a set of fine line segments.
|
|
To quickly find all intersections we use Bentley-Ottmann algorithm.
|
|
To use it we have to split all paths into subpaths and each sub path's will puzzled into single straight lines
|
|
Cool tool to visualize: https://bl.ocks.org/1wheel/464141fe9b940153e636
|
|
'''
|
|
|
|
pathElements = self.getPathElements()
|
|
|
|
allSubSplitLines = []
|
|
allSubSplitIds = []
|
|
allSubSplitStyles = []
|
|
allSubSplitIsBezier = []
|
|
allSubSplitOriginalPathIds = []
|
|
|
|
allSubSplitData = [] #an array of sub split lines and it's belonging sub path id
|
|
allSubSplitData.append(allSubSplitLines) #column 0
|
|
allSubSplitData.append(allSubSplitIds) #column 1
|
|
allSubSplitData.append(allSubSplitStyles) #column 2
|
|
allSubSplitData.append(allSubSplitIsBezier) #column 3
|
|
allSubSplitData.append(allSubSplitOriginalPathIds) #column 4
|
|
|
|
for pathElement in pathElements:
|
|
path = pathElement.path.transform(pathElement.composed_transform())
|
|
#path = pathElement.path
|
|
|
|
'''
|
|
Some original path checkings for analysis/highlighting purposes
|
|
Note: highlighting open/closed/self-intersecting contours does work best if you break apart
|
|
combined paths before.
|
|
'''
|
|
pathIsClosed = False
|
|
path_arrays = path.to_arrays()
|
|
if path_arrays[-1][0] == 'Z' or \
|
|
(path_arrays[-1][0] == 'L' and path_arrays[0][1] == path_arrays[-1][1]) or \
|
|
(path_arrays[-1][0] == 'C' and path_arrays[0][1] == [path_arrays[-1][1][-2], path_arrays[-1][1][-1]]) \
|
|
: #if first is last point the path is also closed. The "Z" command is not required
|
|
pathIsClosed = True
|
|
|
|
#Check if we should delete the path or not
|
|
if so.remove_opened is True and pathIsClosed is False:
|
|
pathElement.delete()
|
|
continue #skip this loop iteration
|
|
if so.remove_closed is True and pathIsClosed is True:
|
|
pathElement.delete()
|
|
continue #skip this loop iteration
|
|
|
|
#Check if we should skip or process the path anyway
|
|
if so.path_types == 'open_paths' and pathIsClosed is True: continue #skip this loop iteration
|
|
elif so.path_types == 'closed_paths' and pathIsClosed is False: continue #skip this loop iteration
|
|
elif so.path_types == 'both': pass
|
|
|
|
#adjust the style of original paths if desired. Has influence to the finally trimmed lines style results too!
|
|
if so.removefillsetstroke:
|
|
self.adjustStyle(pathElement)
|
|
|
|
originalPathId = pathElement.attrib["id"]
|
|
|
|
if so.draw_subsplit is True:
|
|
subSplitTrimLineGroup = pathElement.getparent().add(inkex.Group(id="{}-{}".format(idPrefix, pathElement.attrib["id"])))
|
|
|
|
#get all sub paths for the path of the element
|
|
raw = path.to_arrays()
|
|
subPaths, prev = [], 0
|
|
for i in range(len(raw)): # Breaks compound paths into simple paths
|
|
if raw[i][0] == 'M' and i != 0:
|
|
subPaths.append(raw[prev:i])
|
|
prev = i
|
|
subPaths.append(raw[prev:])
|
|
|
|
#now loop through all sub paths (and flatten if desired) to build up single lines
|
|
for subPath in subPaths:
|
|
#set to True if the sub path is a bezier, else we assume it only has straight lines inside
|
|
isBezier = False
|
|
if 'C' in str(subPath):
|
|
isBezier = True
|
|
if so.show_debug is True:
|
|
self.msg("sub path in {} is bezier: {}".format(originalPathId, isBezier))
|
|
|
|
#self.msg("sub path in {} = {}".format(element.get('id'), subPath))
|
|
#flatten the subpath if wanted
|
|
subPathData = CubicSuperPath(subPath)
|
|
|
|
#flatten bezier curves. If it was already a straight line do nothing! Otherwise we would split straight lines into a lot more straight lines
|
|
if so.flattenbezier is True and isBezier is True:
|
|
bezier.cspsubdiv(subPathData, so.flatness) #modifies the path
|
|
flattenedpath = []
|
|
for seg in subPathData:
|
|
first = True
|
|
for csp in seg:
|
|
cmd = 'L'
|
|
if first:
|
|
cmd = 'M'
|
|
first = False
|
|
flattenedpath.append([cmd, [csp[1][0], csp[1][1]]])
|
|
#self.msg("flattened path = " + str(flattenedpath))
|
|
segs = list(CubicSuperPath(flattenedpath).to_segments())
|
|
else:
|
|
segs = list(subPathData.to_segments())
|
|
#segs = segs[::-1] #reverse the segments
|
|
|
|
#build polylines from segment data
|
|
subSplitLines = []
|
|
subSplitIds = []
|
|
subSplitStyles = []
|
|
subSplitIsBezier = []
|
|
subSplitOriginalPathIds = []
|
|
for i in range(len(segs) - 1): #we could do the same routine to build up polylines using "for x, y in node.path.end_points". See "number nodes" extension
|
|
x1, y1, x2, y2 = self.lineFromSegments(segs, i, so.decimals)
|
|
#self.msg("(y1 = {},y2 = {},x1 = {},x2 = {})".format(x1, y1, x2, y2))
|
|
subSplitId = "{}-{}_{}".format(idPrefix, originalPathId, i)
|
|
if so.draw_subsplit is True:
|
|
line = inkex.PathElement(id=subSplitId)
|
|
#apply line path with composed negative transform from parent element
|
|
line.path = [['M', [x1, y1]], ['L', [x2, y2]]]
|
|
if pathElement.getparent() != self.svg.root:
|
|
line.path = line.path.transform(-pathElement.getparent().composed_transform())
|
|
line.style = subSplitLineStyle
|
|
subSplitTrimLineGroup.add(line)
|
|
|
|
subSplitLines.append([(x1, y1), (x2, y2)])
|
|
subSplitIds.append(subSplitId)
|
|
subSplitStyles.append(pathElement.style)
|
|
subSplitIsBezier.append(isBezier) #some dirty flag we need
|
|
subSplitOriginalPathIds.append(originalPathId) #some dirty flag we need
|
|
|
|
if so.draw_subsplit is True:
|
|
#check for open/closed again (at first we checked for the <maybe> combined path. Now we can do for each sub path too!
|
|
subPathIsClosed = False
|
|
if subSplitLines[0][0] == subSplitLines[-1][1]:
|
|
subPathIsClosed = True
|
|
for subSplitLine in subSplitTrimLineGroup:
|
|
if subPathIsClosed is True:
|
|
if so.highlight_closed is True:
|
|
subSplitLine.style = keepClosedPathStyle
|
|
else:
|
|
if so.highlight_opened is True:
|
|
subSplitLine.style = keepOpenPathStyle
|
|
|
|
#check for self intersections
|
|
selfIntersectionPoints = isect_segments(subSplitLines, validate=True)
|
|
if len(selfIntersectionPoints) > 0:
|
|
if so.show_debug is True:
|
|
self.msg("{} in {} intersects itself with {} intersections!".format(subSplitId, originalPathId, len(selfIntersectionPoints)))
|
|
if so.draw_subsplit is True:
|
|
if so.highlight_self_intersecting is True:
|
|
for subSplitLine in subSplitTrimLineGroup:
|
|
subSplitLine.style = keepSelfIntersectingPathStyle #adjusts line color
|
|
#delete cosmetic sub split lines if desired
|
|
if so.remove_self_intersecting:
|
|
subSplitTrimLineGroup.delete()
|
|
if so.visualize_self_intersections is True: #draw points (circles)
|
|
self.visualize_self_intersections(pathElement, selfIntersectionPoints)
|
|
|
|
#and also delete non-cosmetics
|
|
if so.remove_self_intersecting:
|
|
#if we also want to avoid processing them for trimming
|
|
subSplitLines = None
|
|
subSplitIds = None
|
|
subSplitStyles = None
|
|
subSplitIsBezier = None
|
|
subSplitOriginalPathIds = None
|
|
pathElement.delete() #and finally delete the orginal path
|
|
|
|
#extend the complete collection
|
|
if subSplitLines != None and \
|
|
subSplitIds != None and \
|
|
subSplitStyles != None and \
|
|
subSplitIsBezier != None and \
|
|
allSubSplitOriginalPathIds != None:
|
|
allSubSplitStyles.extend(subSplitStyles)
|
|
allSubSplitLines.extend(subSplitLines)
|
|
allSubSplitIds.extend(subSplitIds)
|
|
allSubSplitIsBezier.extend(subSplitIsBezier)
|
|
allSubSplitOriginalPathIds.extend(subSplitOriginalPathIds)
|
|
|
|
if so.draw_subsplit is True:
|
|
if subSplitTrimLineGroup is not None: #might get deleted before so we need to check this first
|
|
subSplitTrimLineGroup = reversed(subSplitTrimLineGroup) #reverse the order to match the original path segment placing
|
|
|
|
if so.show_debug is True:
|
|
self.msg("sub split line count: {}".format(len(allSubSplitLines)))
|
|
|
|
''' 2 //
|
|
now we intersect the sub split lines to find the global intersection points (contains self-intersections too!)
|
|
'''
|
|
try:
|
|
globalIntersectionPoints = MultiPoint(isect_segments(allSubSplitData[0], validate=True))
|
|
if so.show_debug is True:
|
|
self.msg("global intersection points count: {}".format(len(globalIntersectionPoints)))
|
|
if len(globalIntersectionPoints) > 0:
|
|
if so.visualize_global_intersections is True:
|
|
self.visualize_global_intersections(globalIntersectionPoints)
|
|
|
|
''' 3 //
|
|
now we trim the sub split lines at all calculated intersection points.
|
|
We do this path by path to keep the logic between original paths, sub split lines and the final output
|
|
'''
|
|
if so.draw_trimmed is True:
|
|
allTrimGroups = [] #container to collect all trim groups for later on processing
|
|
trimLineIndex = 1
|
|
for subSplitIndex in range(len(allSubSplitData[0])):
|
|
trimGroup = self.buildTrimLineGroups(allSubSplitData, subSplitIndex,
|
|
globalIntersectionPoints, trimLineIndex, so.snap_tolerance, so.apply_original_style)
|
|
if trimGroup not in allTrimGroups:
|
|
allTrimGroups.append(trimGroup)
|
|
trimLineIndex += 1
|
|
|
|
if so.show_debug is True: self.msg("trim groups count: {}".format(len(allTrimGroups)))
|
|
if len(allTrimGroups) == 0:
|
|
self.msg("You selected to draw trimmed lines but no intersections could be calculated.")
|
|
|
|
#trim beziers - not working yet
|
|
if so.bezier_trimming is True: self.trim_bezier(allTrimGroups)
|
|
|
|
#check for duplicate trim lines and delete them if desired
|
|
if so.remove_duplicates is True: self.remove_duplicates(allTrimGroups, so.reverse_removal_order)
|
|
|
|
#glue together all non-intersected sub split lines to larger path structures again (cleaning up).
|
|
if so.combine_nonintersects is True: self. combine_nonintersects(allTrimGroups, so.apply_original_style)
|
|
|
|
#clean original paths if selected. This option is explicitely independent from remove_open, remove_closed
|
|
if so.keep_original_after_trim is False:
|
|
for pathElement in pathElements:
|
|
pathElement.delete()
|
|
|
|
except AssertionError as e:
|
|
self.msg("Error calculating global intersections.\n\
|
|
See https://github.com/ideasman42/isect_segments-bentley_ottmann.\n\n\
|
|
You can try to fix this by:\n\
|
|
- reduce or raise the 'decimals' setting (default is 3 but try to set to 6 for example)\n\
|
|
- reduce or raise the 'flatness' setting (if quantization option is used at all; default is 0.100).")
|
|
return
|
|
|
|
if __name__ == '__main__':
|
|
ContourScannerAndTrimmer().run()
|