share/extensions/interp.py

   1 #!/usr/bin/env python
   2 '''
   3 Copyright (C) 2005 Aaron Spike, aaron@ekips.org
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 '''
  19 import inkex, cubicsuperpath, simplestyle, copy, math, re, bezmisc
  20
  21 uuconv = {'in':90.0, 'pt':1.25, 'px':1, 'mm':3.5433070866, 'cm':35.433070866, 'pc':15.0}
  22 def numsegs(csp):
  23         return sum([len(p)-1 for p in csp])
  24 def interpcoord(v1,v2,p):
  25         return v1+((v2-v1)*p)
  26 def interppoints(p1,p2,p):
  27         return [interpcoord(p1[0],p2[0],p),interpcoord(p1[1],p2[1],p)]
  28 def pointdistance((x1,y1),(x2,y2)):
  29         return math.sqrt(((x2 - x1) ** 2) + ((y2 - y1) ** 2))
  30 def bezlenapprx(sp1, sp2):
  31         return pointdistance(sp1[1], sp1[2]) + pointdistance(sp1[2], sp2[0]) + pointdistance(sp2[0], sp2[1])
  32 def tpoint((x1,y1), (x2,y2), t = 0.5):
  33         return [x1+t*(x2-x1),y1+t*(y2-y1)]
  34 def cspbezsplit(sp1, sp2, t = 0.5):
  35         m1=tpoint(sp1[1],sp1[2],t)
  36         m2=tpoint(sp1[2],sp2[0],t)
  37         m3=tpoint(sp2[0],sp2[1],t)
  38         m4=tpoint(m1,m2,t)
  39         m5=tpoint(m2,m3,t)
  40         m=tpoint(m4,m5,t)
  41         return [[sp1[0][:],sp1[1][:],m1], [m4,m,m5], [m3,sp2[1][:],sp2[2][:]]]
  42 def cspbezsplitatlength(sp1, sp2, l = 0.5, tolerance = 0.001):
  43         bez = (sp1[1][:],sp1[2][:],sp2[0][:],sp2[1][:])
  44         t = bezmisc.beziertatlength(bez, l, tolerance)
  45         return cspbezsplit(sp1, sp2, t)
  46 def cspseglength(sp1,sp2, tolerance = 0.001):
  47         bez = (sp1[1][:],sp1[2][:],sp2[0][:],sp2[1][:])
  48         return bezmisc.bezierlength(bez, tolerance)
  49 def csplength(csp):
  50         total = 0
  51         lengths = []
  52         for sp in csp:
  53                 lengths.append([])
  54                 for i in xrange(1,len(sp)):
  55                         l = cspseglength(sp[i-1],sp[i])
  56                         lengths[-1].append(l)
  57                         total += l
  58         return lengths, total
  59 def styleunittouu(string):
  60         unit = re.compile('(%s)$' % '|'.join(uuconv.keys()))
  61         param = re.compile(r'(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)')
  62
  63         p = param.match(string)
  64         u = unit.search(string)
  65         if p:
  66                 retval = float(p.string[p.start():p.end()])
  67         else:
  68                 retval = 0.0
  69         if u:
  70                 try:
  71                         return retval * uuconv[u.string[u.start():u.end()]]
  72                 except KeyError:
  73                         pass
  74         return retval
  75
  76 def tweenstylefloat(property, start, end, time):
  77         sp = float(start[property])
  78         ep = float(end[property])
  79         return str(sp + (time * (ep - sp)))
  80 def tweenstyleunit(property, start, end, time):
  81         sp = styleunittouu(start[property])
  82         ep = styleunittouu(end[property])
  83         return str(sp + (time * (ep - sp)))
  84 def tweenstylecolor(property, start, end, time):
  85         sr,sg,sb = parsecolor(start[property])
  86         er,eg,eb = parsecolor(end[property])
  87         return '#%s%s%s' % (tweenhex(time,sr,er),tweenhex(time,sg,eg),tweenhex(time,sb,eb))
  88 def tweenhex(time,s,e):
  89         s = float(int(s,16))
  90         e = float(int(e,16))
  91         retval = hex(int(math.floor(s + (time * (e - s)))))[2:]
  92         if len(retval)==1:
  93                 retval = '0%s' % retval
  94         return retval
  95 def parsecolor(c):
  96         r,g,b = '0','0','0'
  97         if c[:1]=='#':
  98                 if len(c)==4:
  99                         r,g,b = c[1:2],c[2:3],c[3:4]
 100                 elif len(c)==7:
 101                         r,g,b = c[1:3],c[3:5],c[5:7]
 102         return r,g,b
 103
 104 class Interp(inkex.Effect):
 105         def __init__(self):
 106                 inkex.Effect.__init__(self)
 107                 self.OptionParser.add_option("-e", "--exponent",
 108                                                 action="store", type="float",
 109                                                 dest="exponent", default=0.0,
 110                                                 help="values other than zero give non linear interpolation")
 111                 self.OptionParser.add_option("-s", "--steps",
 112                                                 action="store", type="int",
 113                                                 dest="steps", default=5,
 114                                                 help="number of interpolation steps")
 115                 self.OptionParser.add_option("-m", "--method",
 116                                                 action="store", type="int",
 117                                                 dest="method", default=2,
 118                                                 help="method of interpolation")
 119                 self.OptionParser.add_option("-d", "--dup",
 120                                                 action="store", type="inkbool",
 121                                                 dest="dup", default=True,
 122                                                 help="duplicate endpaths")
 123                 self.OptionParser.add_option("--style",
 124                                                 action="store", type="inkbool",
 125                                                 dest="style", default=True,
 126                                                 help="try interpolation of some style properties")
 127         def effect(self):
 128                 exponent = self.options.exponent
 129                 if exponent>= 0:
 130                         exponent = 1.0 + exponent
 131                 else:
 132                         exponent = 1.0/(1.0 - exponent)
 133                 steps = [1.0/(self.options.steps + 1.0)]
 134                 for i in range(self.options.steps - 1):
 135                         steps.append(steps[0] + steps[-1])
 136                 steps = [step**exponent for step in steps]
 137
 138                 paths = {}
 139                 styles = {}
 140                 for id in self.options.ids:
 141                         node = self.selected[id]
 142                         if node.tagName =='path':
 143                                 paths[id] = cubicsuperpath.parsePath(node.attributes.getNamedItem('d').value)
 144                                 styles[id] = simplestyle.parseStyle(node.attributes.getNamedItem('style').value)
 145                         else:
 146                                 self.options.ids.remove(id)
 147
 148                 for i in range(1,len(self.options.ids)):
 149                         start = copy.deepcopy(paths[self.options.ids[i-1]])
 150                         end = copy.deepcopy(paths[self.options.ids[i]])
 151                         sst = copy.deepcopy(styles[self.options.ids[i-1]])
 152                         est = copy.deepcopy(styles[self.options.ids[i]])
 153                         basestyle = copy.deepcopy(sst)
 154
 155                         #prepare for experimental style tweening
 156                         if self.options.style:
 157                                 dostroke = True
 158                                 dofill = True
 159                                 styledefaults = {'opacity':'1.0', 'stroke-opacity':'1.0', 'fill-opacity':'1.0',
 160                                                 'stroke-width':'1.0', 'stroke':'none', 'fill':'none'}
 161                                 for key in styledefaults.keys():
 162                                         sst.setdefault(key,styledefaults[key])
 163                                         est.setdefault(key,styledefaults[key])
 164                                 isnotplain = lambda x: not (x=='none' or x[:1]=='#')
 165                                 if isnotplain(sst['stroke']) or isnotplain(est['stroke']) or (sst['stroke']=='none' and est['stroke']=='none'):
 166                                         dostroke = False
 167                                 if isnotplain(sst['fill']) or isnotplain(est['fill']) or (sst['fill']=='none' and est['fill']=='none'):
 168                                         dofill = False
 169                                 if dostroke:
 170                                         if sst['stroke']=='none':
 171                                                 sst['stroke-width'] = '0.0'
 172                                                 sst['stroke-opacity'] = '0.0'
 173                                                 sst['stroke'] = est['stroke']
 174                                         elif est['stroke']=='none':
 175                                                 est['stroke-width'] = '0.0'
 176                                                 est['stroke-opacity'] = '0.0'
 177                                                 est['stroke'] = sst['stroke']
 178                                 if dofill:
 179                                         if sst['fill']=='none':
 180                                                 sst['fill-opacity'] = '0.0'
 181                                                 sst['fill'] = est['fill']
 182                                         elif est['fill']=='none':
 183                                                 est['fill-opacity'] = '0.0'
 184                                                 est['fill'] = sst['fill']
 185
 186
 187
 188                         if self.options.method == 2:
 189                                 #subdivide both paths into segments of relatively equal lengths
 190                                 slengths, stotal = csplength(start)
 191                                 elengths, etotal = csplength(end)
 192                                 lengths = {}
 193                                 t = 0
 194                                 for sp in slengths:
 195                                         for l in sp:
 196                                                 t += l / stotal
 197                                                 lengths.setdefault(t,0)
 198                                                 lengths[t] += 1
 199                                 t = 0
 200                                 for sp in elengths:
 201                                         for l in sp:
 202                                                 t += l / etotal
 203                                                 lengths.setdefault(t,0)
 204                                                 lengths[t] += -1
 205                                 sadd = [k for (k,v) in lengths.iteritems() if v < 0]
 206                                 sadd.sort()
 207                                 eadd = [k for (k,v) in lengths.iteritems() if v > 0]
 208                                 eadd.sort()
 209
 210                                 t = 0
 211                                 s = [[]]
 212                                 for sp in slengths:
 213                                         if not start[0]:
 214                                                 s.append(start.pop(0))
 215                                         s[-1].append(start[0].pop(0))
 216                                         for l in sp:
 217                                                 pt = t
 218                                                 t += l / stotal
 219                                                 if sadd and t > sadd[0]:
 220                                                         while sadd and sadd[0] < t:
 221                                                                 nt = (sadd[0] - pt) / (t - pt)
 222                                                                 bezes = cspbezsplitatlength(s[-1][-1][:],start[0][0][:], nt)
 223                                                                 s[-1][-1:] = bezes[:2]
 224                                                                 start[0][0] = bezes[2]
 225                                                                 pt = sadd.pop(0)
 226                                                 s[-1].append(start[0].pop(0))
 227                                 t = 0
 228                                 e = [[]]
 229                                 for sp in elengths:
 230                                         if not end[0]:
 231                                                 e.append(end.pop(0))
 232                                         e[-1].append(end[0].pop(0))
 233                                         for l in sp:
 234                                                 pt = t
 235                                                 t += l / etotal
 236                                                 if eadd and t > eadd[0]:
 237                                                         while eadd and eadd[0] < t:
 238                                                                 nt = (eadd[0] - pt) / (t - pt)
 239                                                                 bezes = cspbezsplitatlength(e[-1][-1][:],end[0][0][:], nt)
 240                                                                 e[-1][-1:] = bezes[:2]
 241                                                                 end[0][0] = bezes[2]
 242                                                                 pt = eadd.pop(0)
 243                                                 e[-1].append(end[0].pop(0))
 244                                 start = s[:]
 245                                 end = e[:]
 246                         else:
 247                                 #which path has fewer segments?
 248                                 lengthdiff = numsegs(start) - numsegs(end)
 249                                 #swap shortest first
 250                                 if lengthdiff > 0:
 251                                         start, end = end, start
 252                                 #subdivide the shorter path
 253                                 for x in range(abs(lengthdiff)):
 254                                         maxlen = 0
 255                                         subpath = 0
 256                                         segment = 0
 257                                         for y in range(len(start)):
 258                                                 for z in range(1, len(start[y])):
 259                                                         leng = bezlenapprx(start[y][z-1], start[y][z])
 260                                                         if leng > maxlen:
 261                                                                 maxlen = leng
 262                                                                 subpath = y
 263                                                                 segment = z
 264                                         sp1, sp2 = start[subpath][segment - 1:segment + 1]
 265                                         start[subpath][segment - 1:segment + 1] = cspbezsplit(sp1, sp2)
 266                                 #if swapped, swap them back
 267                                 if lengthdiff > 0:
 268                                         start, end = end, start
 269
 270                         #break paths so that corresponding subpaths have an equal number of segments
 271                         s = [[]]
 272                         e = [[]]
 273                         while start and end:
 274                                 if start[0] and end[0]:
 275                                         s[-1].append(start[0].pop(0))
 276                                         e[-1].append(end[0].pop(0))
 277                                 elif end[0]:
 278                                         s.append(start.pop(0))
 279                                         e[-1].append(end[0][0])
 280                                         e.append([end[0].pop(0)])
 281                                 elif start[0]:
 282                                         e.append(end.pop(0))
 283                                         s[-1].append(start[0][0])
 284                                         s.append([start[0].pop(0)])
 285                                 else:
 286                                         s.append(start.pop(0))
 287                                         e.append(end.pop(0))
 288
 289                         if self.options.dup:
 290                                 steps = [0] + steps + [1]
 291                         #create an interpolated path for each interval
 292                         group = self.document.createElement('svg:g')
 293                         self.document.documentElement.appendChild(group)
 294                         for time in steps:
 295                                 interp = []
 296                                 #process subpaths
 297                                 for ssp,esp in zip(s, e):
 298                                         if not (ssp or esp):
 299                                                 break
 300                                         interp.append([])
 301                                         #process superpoints
 302                                         for sp,ep in zip(ssp, esp):
 303                                                 if not (sp or ep):
 304                                                         break
 305                                                 interp[-1].append([])
 306                                                 #process points
 307                                                 for p1,p2 in zip(sp, ep):
 308                                                         if not (sp or ep):
 309                                                                 break
 310                                                         interp[-1][-1].append(interppoints(p1, p2, time))
 311
 312                                 #remove final subpath if empty.
 313                                 if not interp[-1]:
 314                                         del interp[-1]
 315                                 new = self.document.createElement('svg:path')
 316
 317                                 #basic style tweening
 318                                 if self.options.style:
 319                                         basestyle['opacity'] = tweenstylefloat('opacity',sst,est,time)
 320                                         if dostroke:
 321                                                 basestyle['stroke-opacity'] = tweenstylefloat('stroke-opacity',sst,est,time)
 322                                                 basestyle['stroke-width'] = tweenstyleunit('stroke-width',sst,est,time)
 323                                                 basestyle['stroke'] = tweenstylecolor('stroke',sst,est,time)
 324                                         if dofill:
 325                                                 basestyle['fill-opacity'] = tweenstylefloat('fill-opacity',sst,est,time)
 326                                                 basestyle['fill'] = tweenstylecolor('fill',sst,est,time)
 327                                 new.setAttribute('style', simplestyle.formatStyle(basestyle))
 328                                 new.setAttribute('d', cubicsuperpath.formatPath(interp))
 329                                 group.appendChild(new)
 330
 331 e = Interp()
 332 e.affect()