share/extensions/pathmodifier.py

   1 #!/usr/bin/env python\r
   2 '''\r
   3 Copyright (C) 2006 Jean-Francois Barraud, barraud@math.univ-lille1.fr\r
   4 \r
   5 This program is free software; you can redistribute it and/or modify\r
   6 it under the terms of the GNU General Public License as published by\r
   7 the Free Software Foundation; either version 2 of the License, or\r
   8 (at your option) any later version.\r
   9 \r
  10 This program is distributed in the hope that it will be useful,\r
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13 GNU General Public License for more details.\r
  14 \r
  15 You should have received a copy of the GNU General Public License\r
  16 along with this program; if not, write to the Free Software\r
  17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\r
  18 barraud@math.univ-lille1.fr\r
  19 '''\r
  20 import inkex, cubicsuperpath, bezmisc, simplestyle\r
  21 import copy, math, re, random, xml.xpath\r
  22 \r
  23 def parseTransform(transf,mat=[[1.0,0.0,0.0],[0.0,1.0,0.0]]):\r
  24     if transf=="":\r
  25         return(mat)\r
  26     result=re.match("(translate|scale|rotate|skewX|skewY|matrix)\(([^)]*)\)",transf)\r
  27 #-- translate --\r
  28     if result.group(1)=="translate":\r
  29         args=result.group(2).split(",")\r
  30         dx=float(args[0])\r
  31         if len(args)==1:\r
  32             dy=0.0\r
  33         else:\r
  34             dy=float(args[1])\r
  35         matrix=[[1,0,dx],[0,1,dy]]\r
  36 #-- scale --\r
  37     if result.groups(1)=="scale":\r
  38         args=result.group(2).split(",")\r
  39         sx=float(args[0])\r
  40         if len(args)==1:\r
  41             sy=sx\r
  42         else:\r
  43             sy=float(args[1])\r
  44         matrix=[[sx,0,0],[0,sy,0]]\r
  45 #-- rotate --\r
  46     if result.groups(1)=="rotate":\r
  47         args=result.group(2).split(",")\r
  48         a=float(args[0])*math.pi/180\r
  49         if len(args)==1:\r
  50             cx,cy=(0.0,0.0)\r
  51         else:\r
  52             cx,cy=args[1:]\r
  53         matrix=[[math.cos(a),-math.sin(a),cx],[math.sin(a),math.cos(a),cy]]\r
  54 #-- skewX --\r
  55     if result.groups(1)=="skewX":\r
  56         a=float(result.group(2))*math.pi/180\r
  57         matrix=[[1,math.tan(a),0],[0,1,0]]\r
  58 #-- skewX --\r
  59     if result.groups(1)=="skewX":\r
  60         a=float(result.group(2))*math.pi/180\r
  61         matrix=[[1,0,0],[math.tan(a),1,0]]\r
  62 #-- matrix --\r
  63     if result.group(1)=="matrix":\r
  64         a11,a21,a12,a22,v1,v2=result.group(2).split(",")\r
  65         matrix=[[float(a11),float(a12),float(v1)],[float(a21),float(a22),float(v2)]]\r
  66     \r
  67     matrix=composeTransform(mat,matrix)\r
  68     if result.end()<len(transf):\r
  69         return(parseTransform(transf[result.end():],matrix))\r
  70     else:\r
  71         return matrix\r
  72 \r
  73 def formatTransform(mat):\r
  74     return("matrix(%f,%f,%f,%f,%f,%f)"%(mat[0][0],mat[1][0],mat[0][1],mat[1][1],mat[0][2],mat[1][2]))\r
  75 \r
  76 def composeTransform(M1,M2):\r
  77     a11=M1[0][0]*M2[0][0]+M1[0][1]*M2[1][0]\r
  78     a12=M1[0][0]*M2[0][1]+M1[0][1]*M2[1][1]\r
  79     a21=M1[1][0]*M2[0][0]+M1[1][1]*M2[1][0]\r
  80     a22=M1[1][0]*M2[0][1]+M1[1][1]*M2[1][1]\r
  81 \r
  82     v1=M1[0][0]*M2[0][2]+M1[0][1]*M2[1][2]+M1[0][2]\r
  83     v2=M1[1][0]*M2[0][2]+M1[1][1]*M2[1][2]+M1[1][2]\r
  84     return [[a11,a12,v1],[a21,a22,v2]]\r
  85 \r
  86 def applyTransformToNode(mat,node):\r
  87     m=parseTransform(node.getAttributeNS(None,"transform"))\r
  88     newtransf=formatTransform(composeTransform(mat,m))\r
  89     node.setAttributeNS(None,"transform", newtransf)\r
  90 \r
  91 def applyTransformToPoint(mat,pt):\r
  92     x=mat[0][0]*pt[0]+mat[0][1]*pt[1]+mat[0][2]\r
  93     y=mat[1][0]*pt[0]+mat[1][1]*pt[1]+mat[1][2]\r
  94     pt[0]=x\r
  95     pt[1]=y\r
  96 \r
  97 def fuseTransform(node):\r
  98     m=parseTransform(node.getAttributeNS(None,"transform"))\r
  99     d = node.getAttributeNS(None,'d')\r
 100     p=cubicsuperpath.parsePath(d)\r
 101     for comp in p:\r
 102         for ctl in comp:\r
 103             for pt in ctl:\r
 104                 applyTransformToPoint(m,pt)\r
 105     node.setAttributeNS(None,'d', cubicsuperpath.formatPath(p))\r
 106     node.removeAttributeNS(None,"transform")\r
 107 \r
 108 \r
 109 def boxunion(b1,b2):\r
 110     if b1 is None:\r
 111         return b2\r
 112     elif b2 is None:\r
 113         return b1    \r
 114     else:\r
 115         return((min(b1[0],b2[0]),max(b1[1],b2[1]),min(b1[2],b2[2]),max(b1[3],b2[3])))\r
 116 \r
 117 def roughBBox(path):\r
 118     xmin,xMax,ymin,yMax=path[0][0][0][0],path[0][0][0][0],path[0][0][0][1],path[0][0][0][1]\r
 119     for pathcomp in path:\r
 120         for ctl in pathcomp:\r
 121            for pt in ctl:\r
 122                xmin=min(xmin,pt[0])\r
 123                xMax=max(xMax,pt[0])\r
 124                ymin=min(ymin,pt[1])\r
 125                yMax=max(yMax,pt[1])\r
 126     return xmin,xMax,ymin,yMax\r
 127 \r
 128 \r
 129 class PathModifier(inkex.Effect):\r
 130     def __init__(self):\r
 131         inkex.Effect.__init__(self)\r
 132 \r
 133 ##################################\r
 134 #-- Selectionlists manipulation --\r
 135 ##################################\r
 136     def computeBBox(self, aList):\r
 137         bbox=None\r
 138         for id, node in aList.iteritems():\r
 139             if node.tagName == 'path':\r
 140                 d = node.attributes.getNamedItem('d')\r
 141                 p = cubicsuperpath.parsePath(d.value)\r
 142                 bbox=boxunion(roughBBox(p),bbox)\r
 143         return bbox\r
 144 \r
 145     def duplicateNodes(self, aList):\r
 146         clones={}\r
 147         for id,node in aList.iteritems():\r
 148             clone=node.cloneNode(True)\r
 149     #!!!--> should it be given an id?\r
 150     #seems to work without this!?!\r
 151             clone.setAttributeNS(None,"id", self.uniqueId(node.tagName))\r
 152             node.parentNode.appendChild(clone)\r
 153             clones[clone.getAttributeNS(None,"id")]=clone\r
 154         return(clones)\r
 155 \r
 156     def uniqueId(self, prefix):\r
 157         id="%s%04i"%(prefix,random.randint(0,9999))\r
 158         while len(xml.xpath.Evaluate('//*[@id="%s"]' % id,self.document)):\r
 159             id="%s%04i"%(prefix,random.randint(0,9999))\r
 160         return(id)\r
 161 \r
 162     def expandGroups(self,aList,transferTransform=True):\r
 163         for id, node in aList.items():      \r
 164             if node.tagName == 'g':\r
 165                 mat=parseTransform(node.getAttributeNS(None,"transform"))\r
 166                 for child in node.childNodes:\r
 167                     if child.nodeType==child.ELEMENT_NODE:\r
 168                         if transferTransform:\r
 169                             applyTransformToNode(mat,child)\r
 170                         aList.update(self.expandGroups({child.getAttribute('id'):child}))\r
 171                 if transferTransform:\r
 172                     node.removeAttribute("transform")\r
 173                 del aList[id]\r
 174         return(aList)\r
 175 \r
 176     def expandGroupsUnlinkClones(self,aList,transferTransform=True,doReplace=True):\r
 177         for id in aList.keys()[:]:     \r
 178             node=aList[id]\r
 179             if node.tagName == 'g':\r
 180                 self.expandGroups(aList,transferTransform)\r
 181                 self.expandGroupsUnlinkClones(aList,transferTransform,doReplace)\r
 182                 #Hum... not very efficient if there are many clones of groups...\r
 183             elif node.tagName == 'use':\r
 184                 refid=node.getAttributeNS(inkex.NSS[u'xlink'],'href')\r
 185                 path = '//*[@id="%s"]' % refid[1:]\r
 186                 refnode = xml.xpath.Evaluate(path,self.document)[0]\r
 187                 newnode=refnode.cloneNode(True)\r
 188                 self.recursNewIds(newnode)\r
 189 \r
 190                 if node.hasAttributeNS(None,u'style'):\r
 191                     style=simplestyle.parseStyle(node.getAttributeNS(None,u'style'))\r
 192                     refstyle=simplestyle.parseStyle(refnode.getAttributeNS(None,u'style'))\r
 193                     style.update(refstyle)\r
 194                     newnode.setAttributeNS(None,'style',simplestyle.formatStyle(style))\r
 195                 applyTransformToNode(parseTransform(node.getAttributeNS(None,'transform')),newnode)\r
 196                 if doReplace:\r
 197                     parent=node.parentNode\r
 198                     parent.insertBefore(newnode,node)\r
 199                     parent.removeChild(node)\r
 200                 del aList[id]\r
 201                 newid=newnode.getAttributeNS(None,'id')\r
 202                 aList.update(self.expandGroupsUnlinkClones({newid:newnode},transferTransform,doReplace))\r
 203         return aList\r
 204     \r
 205     def recursNewIds(self,node):\r
 206         if node.nodeType==node.ELEMENT_NODE and node.hasAttributeNS(None,u'id'):\r
 207             node.setAttributeNS(None,u'id',self.uniqueId(node.tagName))\r
 208         for child in node.childNodes:\r
 209             self.recursNewIds(child)\r
 210                 \r
 211 \r
 212         \r
 213 \r
 214 #     def makeClonesReal(self,aList,doReplace=True,recursivelytransferTransform=True):\r
 215 #         for id in aList.keys():     \r
 216 #             node=aList[id]\r
 217 #             if node.tagName == 'g':\r
 218 #                 childs={}\r
 219 #                 for child in node.childNodes:\r
 220 #                     if child.nodeType==child.ELEMENT_NODE:\r
 221 #                       childid=child.getAttributeNS(None,'id')\r
 222 #                       del aList[childid]\r
 223 #                         aList.update(self.makeClonesReal({childid:child},doReplace))\r
 224 #             elif node.tagName == 'use':\r
 225 #                 refid=node.getAttributeNS(inkex.NSS[u'xlink'],'href')\r
 226 #                 path = '//*[@id="%s"]' % refid[1:]\r
 227 #                 refnode = xml.xpath.Evaluate(path,document)[0]\r
 228 #                 clone=refnode.cloneNode(True)\r
 229 #               cloneid=self.uniqueId(clone.tagName)\r
 230 #                 clone.setAttributeNS(None,'id', cloneid)\r
 231 #                 style=simplestyle.parseStyle(node.getAttributeNS(None,u'style'))\r
 232 #                 refstyle=simplestyle.parseStyle(refnode.getAttributeNS(None,u'style'))\r
 233 #                 style.update(refstyle)\r
 234 #                 clone.setAttributeNS(None,'style',simplestyle.formatStyle(style))\r
 235 #                 applyTransformToNode(parseTransform(node.getAttributeNS(None,'transform')),clone)\r
 236 #                 if doReplace:\r
 237 #                     parent=node.parentNode\r
 238 #                     parent.insertBefore(clone,node)\r
 239 #                     parent.removeChild(node)\r
 240 #                 del aList[id]\r
 241 #                 aList.update(self.expandGroupsUnlinkClones({cloneid:clone}))\r
 242 #         return aList\r
 243 \r
 244 ################################\r
 245 #-- Object conversion ----------\r
 246 ################################\r
 247 \r
 248     def rectToPath(self,node,doReplace=True):\r
 249         if node.tagName == 'rect':\r
 250             x =float(node.getAttributeNS(None,u'x'))\r
 251             y =float(node.getAttributeNS(None,u'y'))\r
 252             try:\r
 253                 rx=float(node.getAttributeNS(None,u'rx'))\r
 254                 ry=float(node.getAttributeNS(None,u'ry'))\r
 255             except:\r
 256                 rx=0\r
 257                 ry=0\r
 258             w =float(node.getAttributeNS(None,u'width' ))\r
 259             h =float(node.getAttributeNS(None,u'height'))\r
 260             d ='M %f,%f '%(x+rx,y)\r
 261             d+='L %f,%f '%(x+w-rx,y)\r
 262             d+='A %f,%f,%i,%i,%i,%f,%f '%(rx,ry,0,0,1,x+w,y+ry)\r
 263             d+='L %f,%f '%(x+w,y+h-ry)\r
 264             d+='A %f,%f,%i,%i,%i,%f,%f '%(rx,ry,0,0,1,x+w-rx,y+h)\r
 265             d+='L %f,%f '%(x+rx,y+h)\r
 266             d+='A %f,%f,%i,%i,%i,%f,%f '%(rx,ry,0,0,1,x,y+h-ry)\r
 267             d+='L %f,%f '%(x,y+ry)\r
 268             d+='A %f,%f,%i,%i,%i,%f,%f '%(rx,ry,0,0,1,x+rx,y)\r
 269 \r
 270             newnode=self.document.createElement('path')\r
 271             newnode.setAttributeNS(None,'d',d)\r
 272             newnode.setAttributeNS(None,'id', self.uniqueId('path'))\r
 273             newnode.setAttributeNS(None,'style',node.getAttributeNS(None,u'style'))\r
 274             newnode.setAttributeNS(None,'transform',node.getAttributeNS(None,u'transform'))\r
 275             fuseTransform(newnode)\r
 276             if doReplace:\r
 277                 parent=node.parentNode\r
 278                 parent.insertBefore(newnode,node)\r
 279                 parent.removeChild(node)\r
 280             return newnode\r
 281 \r
 282     def objectToPath(self,node,doReplace=True):\r
 283     #--TODO: support other object types!!!!\r
 284     #--TODO: make sure cubicsuperpath supports A and Q commands... \r
 285         if node.tagName == 'rect':\r
 286             return(self.rectToPath(node,doReplace))\r
 287         elif node.tagName == 'path':\r
 288             attributes = node.attributes.keys()\r
 289             for uri,attName in attributes:\r
 290                 if uri in [inkex.NSS[u'sodipodi'],inkex.NSS[u'inkscape']]:\r
 291 #                if attName not in ["d","id","style","transform"]:\r
 292                     node.removeAttributeNS(uri,attName)\r
 293             fuseTransform(node)\r
 294             return node\r
 295         else:\r
 296             inkex.debug("Please first convert objects to paths!...(got '%s')"%node.tagName)\r
 297             return None\r
 298 \r
 299     def objectsToPaths(self,aList,doReplace=True):\r
 300         newSelection={}\r
 301         for id,node in aList.items():\r
 302             newnode=self.objectToPath(node,self.document)\r
 303             del aList[id]\r
 304             aList[newnode.getAttributeNS(None,u'id')]=newnode\r
 305 \r
 306 \r
 307 ################################\r
 308 #-- Action ----------\r
 309 ################################\r
 310             \r
 311     #-- overwrite this method in subclasses...\r
 312     def effect(self):\r
 313         #self.duplicateNodes(self.selected)\r
 314         self.expandGroupsUnlinkClones(self.selected, True)\r
 315         self.objectsToPaths(self.selected, True)\r
 316         self.bbox=self.computeBBox(self.selected)\r
 317         for id, node in self.selected.iteritems():\r
 318             if node.tagName == 'path':\r
 319                 d = node.attributes.getNamedItem('d')\r
 320                 p = cubicsuperpath.parsePath(d.value)\r
 321 \r
 322                 #do what ever you want with p!\r
 323 \r
 324                 d.value = cubicsuperpath.formatPath(p)\r
 325 \r
 326 \r
 327 class Diffeo(PathModifier):\r
 328     def __init__(self):\r
 329         inkex.Effect.__init__(self)\r
 330 \r
 331     def applyDiffeo(self,bpt,vects=()):\r
 332         '''\r
 333         bpt is a base point and for v in vectors, v'=v-p is a tangent vector at bpt. \r
 334         Defaults to identity!\r
 335         '''\r
 336         for v in vects:\r
 337             v[0]-=bpt[0]\r
 338             v[1]-=bpt[1]\r
 339 \r
 340         #-- your transformations go here:\r
 341         #x,y=bpt\r
 342         #bpt[0]=f(x,y)\r
 343         #bpt[1]=g(x,y)\r
 344         #for v in vects:\r
 345         #    vx,vy=v\r
 346         #    v[0]=df/dx(x,y)*vx+df/dy(x,y)*vy\r
 347         #    v[1]=dg/dx(x,y)*vx+dg/dy(x,y)*vy\r
 348         #\r
 349         #-- !caution! y-axis is pointing downward!\r
 350 \r
 351         for v in vects:\r
 352             v[0]+=bpt[0]\r
 353             v[1]+=bpt[1]\r
 354 \r
 355 \r
 356     def effect(self):\r
 357         #self.duplicateNodes(self.selected)\r
 358         self.expandGroupsUnlinkClones(self.selected, True)\r
 359         self.expandGroups(self.selected, True)\r
 360         self.objectsToPaths(self.selected, True)\r
 361         self.bbox=self.computeBBox(self.selected)\r
 362         for id, node in self.selected.iteritems():\r
 363             if node.tagName == 'path':\r
 364                 d = node.attributes.getNamedItem('d')\r
 365                 p = cubicsuperpath.parsePath(d.value)\r
 366 \r
 367                 for sub in p:\r
 368                     for ctlpt in sub:\r
 369                         self.applyDiffeo(ctlpt[1],(ctlpt[0],ctlpt[2]))\r
 370 \r
 371                 d.value = cubicsuperpath.formatPath(p)\r
 372 \r
 373 #e = Diffeo()\r
 374 #e.affect()\r
 375
 376