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.
mightyscape-1.1-deprecated/extensions/fablabchemnitz/snap_object_points/snap_object_points.py
2021-07-23 02:36:56 +02:00

137 lines
6.1 KiB
Python

#!/usr/bin/env python3
'''
Copyright (C) 2020 Scott Pakin, scott-ink@pakin.org
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
'''
from collections import defaultdict
import inkex
from inkex.paths import Arc, Curve, Horz, Line, Move, Quadratic, Smooth, TepidQuadratic, Vert, ZoneClose
class SnapObjectPoints(inkex.EffectExtension):
"Snap the points on multiple paths towards each other."
def add_arguments(self, pars):
pars.add_argument('--max_dist', type=float, default=25.0, help='Maximum distance to be considered a "nearby" point')
pars.add_argument('--controls', type=inkex.Boolean, default=True, help='Snap control points')
pars.add_argument('--ends', type=inkex.Boolean, default=True, help='Snap endpoints')
pars.add_argument('--first_only', type=inkex.Boolean, default=True, help='Modify only the first selected path')
def _bin_points(self):
"Associate each path ID with a list of control points and a list of endpoints."
cpoints = defaultdict(list)
epoints = defaultdict(list)
for node in self.svg.selection.filter(inkex.PathElement).values():
for cmd in node.path.to_absolute().proxy_iterator():
pid = node.get_id()
cpoints[pid].extend(cmd.control_points)
epoints[pid].append(cmd.end_point)
return cpoints, epoints
def _find_nearest(self, pid, x0, y0, other_points):
'''Find the nearest neighbor to a given point, and return the midpoint
of the given point and its neighbor.'''
max_dist2 = self.options.max_dist**2 # Work with squares instead of wasting time on square roots.
bx, by = x0, y0 # Best new point
best_dist2 = max_dist2 # Minimal distance observed from (x0, y0)
for k, pts in other_points.items():
if k == pid:
continue # Don't compare to our own points.
for vec in pts:
x1, y1 = vec.x, vec.y
dist2 = (x1 - x0)**2 + (y1 - y0)**2 # Squared distance
if dist2 > best_dist2:
continue # Not the nearest point
best_dist2 = dist2
bx, by = x1, y1
return (x0 + bx)/2, (y0 + by)/2
def _simplify_paths(self):
'Make all commands absolute, and replace Vert and Horz commands with Line.'
for node in self.svg.selection.filter(inkex.PathElement).values():
path = node.path.to_absolute()
new_path = []
prev = inkex.Vector2d()
prev_prev = inkex.Vector2d()
first = inkex.Vector2d()
for i, cmd in enumerate(path):
if i == 0:
first = cmd.end_point(first, prev)
prev, prev_prev = first, first
if isinstance(cmd, Vert):
cmd = cmd.to_line(prev)
elif isinstance(cmd, Horz):
cmd = cmd.to_line(prev)
new_path.append(cmd)
if isinstance(cmd, (Curve, Quadratic, Smooth, TepidQuadratic)):
prev_prev = list(cmd.control_points(first, prev, prev_prev))[-2]
prev = cmd.end_point(first, prev)
node.path = new_path
def effect(self):
"""Snap control points to other objects' control points and endpoints
to other objects' endpoints."""
# This function uses an O(n^2) algorithm, which shouldn't be too slow
# for typical point counts.
#
# As a preprocessing step, we first simplify the paths to reduce the
# number of special cases we'll need to deal with. Then, we associate
# each path with all of its control points and endpoints.
if len(self.svg.selection.filter(inkex.PathElement)) < 2:
raise inkex.utils.AbortExtension(_('Snap Object Points requires that at least two paths be selected.'))
self._simplify_paths()
cpoints, epoints = self._bin_points()
# Process in turn each command on each path.
for node in self.svg.selection.filter(inkex.PathElement).values():
pid = node.get_id()
path = node.path
new_path = []
for cmd in path:
args = cmd.args
new_args = list(args)
na = len(args)
if isinstance(cmd, (Curve, Line, Move, Quadratic, Smooth, TepidQuadratic)):
# Zero or more control points followed by an endpoint.
if self.options.controls:
for i in range(0, na - 2, 2):
new_args[i], new_args[i + 1] = self._find_nearest(pid, args[i], args[i + 1], cpoints)
if self.options.ends:
new_args[na - 2], new_args[na - 1] = self._find_nearest(pid, args[na - 2], args[na - 1], epoints)
elif isinstance(cmd, ZoneClose):
# No arguments at all.
pass
elif isinstance(cmd, Arc):
# Non-coordinates followed by an endpoint.
if self.options.ends:
new_args[na - 2], new_args[na - 1] = self._find_nearest(pid, args[na - 2], args[na - 1], epoints)
else:
# Unexpected command.
inkex.errormsg(_('Unexpected path command "%s"' % cmd.name))
new_path.append(cmd.__class__(*new_args))
node.path = new_path
if self.options.first_only:
break
if __name__ == '__main__':
SnapObjectPoints().run()