1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
#!/usr/bin/env python
# coding=utf-8
#
# Copyright (C) 2006 Jean-Francois Barraud, barraud@math.univ-lille1.fr
# 2021 Jonathan Neuhauser, jonathan.neuhauser@outlook.com
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# barraud@math.univ-lille1.fr
#
"""
This code defines a basic class (PathModifier) of effects whose purpose is
to somehow deform given objects: one common tasks for all such effect is to
convert shapes, groups, clones to paths. The class has several functions to
make this (more or less!) easy.
As an example, a second class (Diffeo) is derived from it,
to implement deformations of the form X=f(x,y), Y=g(x,y)...
"""
import inkex
from inkex import PathElement, Group, Use
from inkex.bezier import pointdistance, beziersplitatt
# This deprecated API is used by some external extensions.
from inkex.deprecated import zSort # pylint: disable=unused-import
class PathModifier(inkex.EffectExtension):
"""Select list manipulation"""
def expand_groups(self, elements, transferTransform=True):
for node_id, node in list(elements.items()):
if isinstance(node, inkex.Group):
mat = node.transform
for child in node:
if transferTransform:
child.transform = mat @ child.transform
elements.update(self.expand_groups({child.get("id"): child}))
if transferTransform and node.get("transform"):
del node.attrib["transform"]
# Group is now replaced, so remove it.
elements.pop(node_id)
return elements
def expand_clones(self, elements, transferTransform=True, replace=True):
for node_id, node in list(elements.items()):
if isinstance(node, Group):
self.expand_groups(elements, transferTransform)
self.expand_clones(elements, transferTransform, replace)
# Hum... not very efficient if there are many clones of groups...
elif isinstance(node, Use):
newnode = node.unlink()
elements.pop(node_id)
newid = newnode.get("id")
elements.update(
self.expand_clones({newid: newnode}, transferTransform, replace)
)
return elements
def objects_to_paths(self, elements, replace=True):
"""Replace all non-paths with path objects"""
for node in list(elements.values()):
elem = node.to_path_element()
if replace:
node.replace_with(elem)
elem.set("id", node.get("id"))
elements[elem.get("id")] = elem
def effect(self):
raise NotImplementedError("overwrite this method in subclasses")
self.objects_to_paths(self.svg.selection, True)
self.bbox = self.svg.selection.bounding_box()
for node in self.svg.selection.filter(PathElement):
path = node.path.to_superpath()
# do what ever you want with "path"!
node.path = path
@staticmethod
def lengthtotime(l, lengths, isclosed):
"""
Receives an arc length l, and returns the index of the segment in skelcomp
containing the corresponding point, to gether with the position of the point on this segment.
If the deformer is closed, do computations modulo the toal length.
"""
if isclosed:
l = l % sum(lengths)
if l <= 0:
return 0, l / lengths[0]
i = 0
while (i < len(lengths)) and (lengths[i] <= l):
l -= lengths[i]
i += 1
t = l / lengths[min(i, len(lengths) - 1)]
return i, t
@staticmethod
def flipxy(path):
"""Swaps x and y coordinate of all path vertices"""
for pathcomp in path:
for ctl in pathcomp:
for pt in ctl:
tmp = pt[0]
pt[0] = -pt[1]
pt[1] = -tmp
@staticmethod
def offset(pathcomp, dx, dy):
"""Shifts a subpath by (dx, dy)"""
for ctl in pathcomp:
for pt in ctl:
pt[0] += dx
pt[1] += dy
@staticmethod
def stretch(pathcomp, xscale, yscale, org):
"""Stretches a subpath by (xscale, yscale) relative to origin org"""
for ctl in pathcomp:
for pt in ctl:
pt[0] = org[0] + (pt[0] - org[0]) * xscale
pt[1] = org[1] + (pt[1] - org[1]) * yscale
@staticmethod
def linearize(p, tolerance=0.001):
"""
This function receives a component of a 'cubicsuperpath' and returns two things:
The path subdivided in many straight segments, and an array containing the length of each segment.
We could work with bezier path as well, but bezier arc lengths are (re)computed for each point
in the deformed object. For complex paths, this might take a while.
"""
zero = 0.000001
i = 0
d = 0
lengths = []
while i < len(p) - 1:
box = pointdistance(p[i][1], p[i][2])
box += pointdistance(p[i][2], p[i + 1][0])
box += pointdistance(p[i + 1][0], p[i + 1][1])
chord = pointdistance(p[i][1], p[i + 1][1])
if (box - chord) > tolerance:
b1, b2 = beziersplitatt(
[p[i][1], p[i][2], p[i + 1][0], p[i + 1][1]], 0.5
)
p[i][2][0], p[i][2][1] = b1[1]
p[i + 1][0][0], p[i + 1][0][1] = b2[2]
p.insert(
i + 1,
[[b1[2][0], b1[2][1]], [b1[3][0], b1[3][1]], [b2[1][0], b2[1][1]]],
)
else:
d = (box + chord) / 2
lengths.append(d)
i += 1
new = [p[i][1] for i in range(0, len(p) - 1) if lengths[i] > zero]
new.append(p[-1][1])
lengths = [l for l in lengths if l > zero]
return new, lengths
def get_patterns_and_skeletons(self, expand_patterns=False, duplicate=False):
"""Gets the pattern node and skeleton (with applied transforms) from selection"""
# first selected->pattern, all but first selected-> skeletons
skeletons = self.svg.selection.rendering_order()
elem = skeletons.pop()
if duplicate:
elem = elem.duplicate()
if expand_patterns:
patterns = {elem.get_id(): elem}
self.expand_clones(patterns, True, False)
self.objects_to_paths(patterns)
else:
patterns = elem
self.expand_clones(skeletons, True, False)
self.objects_to_paths(skeletons)
return patterns, skeletons.id_dict()
class Diffeo(PathModifier):
def applyDiffeo(self, bpt, vects=()):
# bpt is a base point and for v in vectors, v'=v-p is a tangent vector at bpt.
# Defaults to identity!
for v in vects:
v[0] -= bpt[0]
v[1] -= bpt[1]
# -- your transformations go here:
# x,y=bpt
# bpt[0]=f(x,y)
# bpt[1]=g(x,y)
# for v in vects:
# vx,vy=v
# v[0]=df/dx(x,y)*vx+df/dy(x,y)*vy
# v[1]=dg/dx(x,y)*vx+dg/dy(x,y)*vy
#
# -- !caution! y-axis is pointing downward!
for v in vects:
v[0] += bpt[0]
v[1] += bpt[1]
def effect(self):
self.expand_clones(self.svg.selection, True)
self.expand_groups(self.svg.selection, True)
self.objects_to_paths(self.svg.selection, True)
self.bbox = self.svg.selection.bounding_box()
for node in self.svg.selection.filter(PathElement):
path = node.path.to_superpath()
for sub in path:
for ctlpt in sub:
self.applyDiffeo(ctlpt[1], (ctlpt[0], ctlpt[2]))
node.path = path
|
