Extension inkscape
Description
Ce petit module permet de faire tourner un dessin dans l'espace.
Les paramètres d'entrées sont:
- les angles de rotations selon x,y,z.
- la position du centre de rotation et de la caméra.
La projection est orthogonale ou pas (effet des distances en Z).
Les paramètres d'entrées sont:
- les angles de rotations selon x,y,z.
- la position du centre de rotation et de la caméra.
La projection est orthogonale ou pas (effet des distances en Z).
Source / Exemple :
#!/usr/bin/env python
"""
inkex.py
A helper module for creating Inkscape extensions
Copyright (C) 2005,2007 Aaron Spike, aaron@ekips.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 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
import sys, copy, optparse, random, re
import simplestyle, simplepath
import math, string
#a dictionary of all of the xmlns prefixes in a standard inkscape doc
NSS = {
u'sodipodi' :u'http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd',
u'cc' :u'http://web.resource.org/cc/',
u'svg' :u'http://www.w3.org/2000/svg',
u'dc' :u'http://purl.org/dc/elements/1.1/',
u'rdf' :u'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
u'inkscape' :u'http://www.inkscape.org/namespaces/inkscape',
u'xlink' :u'http://www.w3.org/1999/xlink',
u'xml' :u'http://www.w3.org/XML/1998/namespace'
}
#a dictionary of unit to user unit conversion factors
uuconv = {'in':90.0, 'pt':1.25, 'px':1, 'mm':3.5433070866, 'cm':35.433070866, 'pc':15.0}
def unittouu(string):
'''Returns userunits given a string representation of units in another system'''
unit = re.compile('(%s)$' % '|'.join(uuconv.keys()))
param = re.compile(r'(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)')
p = param.match(string)
u = unit.search(string)
if p:
retval = float(p.string[p.start():p.end()])
else:
retval = 0.0
if u:
try:
return retval * uuconv[u.string[u.start():u.end()]]
except KeyError:
pass
return retval
try:
from lxml import etree
except:
sys.exit('The fantastic lxml wrapper for libxml2 is required by inkex.py and therefore this extension. Please download and install the latest version from <http://cheeseshop.python.org/pypi/lxml/>, or install it through your package manager by a command like: sudo apt-get install python-lxml')
def debug(what):
sys.stderr.write(str(what) + "\n")
return what
def check_inkbool(option, opt, value):
if str(value).capitalize() == 'True':
return True
elif str(value).capitalize() == 'False':
return False
else:
raise OptionValueError("option %s: invalid inkbool value: %s" % (opt, value))
def addNS(tag, ns=None):
val = tag
if ns!=None and len(ns)>0 and NSS.has_key(ns) and len(tag)>0 and tag[0]!='{':
val = "{%s}%s" % (NSS[ns], tag)
return val
def rotz(V,alpha):
c=V
if alpha!=0:
ca=math.cos(alpha)
sa=math.sin(alpha)
c=[ca*V[0] - sa*V[1], sa*V[0] +ca*V[1] ,V[2]]
return c
def roty(V,alpha):
c=V
if alpha!=0:
ca=math.cos(alpha)
sa=math.sin(alpha)
c=[sa*V[2] + ca*V[0] , V[1] , ca*V[2] - sa*V[0]]
return c
def rotx(V,alpha):
c=V
if alpha!=0:
ca=math.cos(alpha)
sa=math.sin(alpha)
c=[V[0] , ca*V[1] - sa*V[2] , sa*V[1]+ca*V[2]]
return c
def project_vue(V,vue):
#debug(V)
temp=V[2]
if vue=="X":
#V[1]=V[1]
V[2]=-V[0]
V[0]=temp
if vue=="Y":
#V[0]=V[0]
V[2]=-V[1]
V[1]=temp
#debug(V)
return V
"""C correspond a la position de la camera
V position du point a faire tourner
La position de l'ecran est egale a (1-zoom)*C[2]"""
def project(V,C,zoom):
cp=[V[0]-C[0],V[1]-C[1],V[2]-C[2]]
norm_cp=math.sqrt(cp[0]**2+cp[1]**2+cp[2]**2)
u=[cp[0]/norm_cp,cp[1]/norm_cp,cp[2]/norm_cp]
coef=-(zoom*C[2])/ u[2]
vc=[C[0]+coef*u[0],C[1]+coef*u[1]]
if V[2]-(1-zoom)*C[2]<=0:
debug("Coordonnee en Z negative!\n augmentez la profondeur")
return vc
class InkOption(optparse.Option):
TYPES = optparse.Option.TYPES + ("inkbool",)
TYPE_CHECKER = copy.copy(optparse.Option.TYPE_CHECKER)
TYPE_CHECKER["inkbool"] = check_inkbool
class Effect:
"""A class for creating Inkscape SVG Effects"""
def __init__(self, *args, **kwargs):
self.id_characters = '0123456789abcdefghijklmnopqrstuvwkyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
self.document=None
self.ctx=None
self.selected={}
self.doc_ids={}
self.options=None
self.args=None
self.OptionParser = optparse.OptionParser(usage="usage: %prog [options] SVGfile",option_class=InkOption)
self.OptionParser.add_option("--id",
action="append", type="string", dest="ids", default=[],
help="id attribute of object to manipulate")
#rajout des options______________
""" permet de creer la variable self.options.rx"""
self.OptionParser.add_option("--rx",
action="store", type="float", dest="rx", default=0.0,
help="Angle de rotation selon x")
self.OptionParser.add_option("--ry",
action="store", type="float", dest="ry", default=0.0,
help="Angle de rotation selon y")
self.OptionParser.add_option("--rz",
action="store", type="float", dest="rz", default=0.0,
help="Angle de rotation selon z")
self.OptionParser.add_option("--px",
action="store", type="float", dest="px", default=10.0,
help="Centre de rotation en X")
self.OptionParser.add_option("--py",
action="store", type="float", dest="py", default=10.0,
help="Centre de rotation en Y")
self.OptionParser.add_option("--pz",
action="store", type="float", dest="pz", default=10.0,
help="Position de l'objet en Z")
self.OptionParser.add_option("--zoom",
action="store", type="int", dest="zoom", default=1,
help="Zoom")
self.OptionParser.add_option("--dup",
action="store", type="inkbool", dest="dup", default=[],
help="Aucune utilite...")
self.OptionParser.add_option("--vue",
action="store", type="string", dest="vue", default=[],
help="Permet de selectionner la vue")
def getoptions(self,args=sys.argv[1:]):
"""Collect command line arguments"""
self.options, self.args = self.OptionParser.parse_args(args)
def parse(self,file=None):
"""Parse document in specified file or on stdin"""
try:
try:
stream = open(file,'r')
except:
stream = open(self.args[-1],'r')
except:
stream = sys.stdin
self.document = etree.parse(stream)
stream.close()
def getposinlayer(self):
#defaults
self.current_layer = self.document.getroot()
self.view_center = (0.0,0.0)
layerattr = self.document.xpath('//sodipodi:namedview/@inkscape:current-layer', namespaces=NSS)
if layerattr:
layername = layerattr[0]
layer = self.document.xpath('//svg:g[@id="%s"]' % layername, namespaces=NSS)
if layer:
self.current_layer = layer[0]
xattr = self.document.xpath('//sodipodi:namedview/@inkscape:cx', namespaces=NSS)
yattr = self.document.xpath('//sodipodi:namedview/@inkscape:cy', namespaces=NSS)
doc_height = unittouu(self.document.getroot().get('height'))
if xattr and yattr:
x = xattr[0]
y = yattr[0]
if x and y:
self.view_center = (float(x), doc_height - float(y)) # FIXME: y-coordinate flip, eliminate it when it's gone in Inkscape
def getselected(self):
"""Collect selected nodes"""
for id in self.options.ids:
path = '//*[@id="%s"]' % id
for node in self.document.xpath(path, namespaces=NSS):
self.selected[id] = node
def getdocids(self):
docIdNodes = self.document.xpath('//@id', namespaces=NSS)
for m in docIdNodes:
self.doc_ids[m] = 1
def output(self):
"""Serialize document into XML on stdout"""
self.document.write(sys.stdout)
def affect(self):
"""Affect an SVG document with a callback effect"""
self.getoptions()
self.parse()
self.getposinlayer()
self.getselected()
self.getdocids()
self.effect()
self.output()
def uniqueId(self, old_id, make_new_id = True):
new_id = old_id
if make_new_id:
while new_id in self.doc_ids:
new_id = "%s%s" % (new_id,random.choice(self.id_characters))
self.doc_ids[new_id] = 1
return new_id
def xpathSingle(self, path):
try:
retval = self.document.xpath(path, namespaces=NSS)[0]
except:
debug("No matching node for expression: %s" % path)
retval = None
return retval
#fonction a modifier pour faire les modifications sur le dessin...__________________
"""self.options.ids correspond aux nom des objets selectionnes
self.selected[id] correspond aux noeud xml de l'objet id"""
def effect(self):
"""_______INITIALISATION_____"""
ax=self.options.rx*math.pi/180
ay=self.options.ry*math.pi/180
az=self.options.rz*math.pi/180
cr=[self.options.px,self.options.py,self.options.pz] #centre de rotation (repere local)
C=[self.options.px,self.options.py,-100.0] #position de la camera /!\ il faut qu'elle soit derriere l'ecran (z<0)
"""______________________"""
"""Cherche l'envelope du groupe d'objet"""
xmin=1000000.0
xmax=-1000000.0
ymin=1000000.0
ymax=-1000000.0
for objetID in self.options.ids:
XmlNode=self.selected[objetID]
arbre=simplepath.parsePath(XmlNode.get('d'))
for noeud in arbre:
noeuds=noeud[1]
nbpoint=len(noeuds)/2
for n in range(nbpoint):
if xmin>noeuds[2*n]:
xmin=noeuds[2*n]
if xmax<noeuds[2*n]:
xmax=noeuds[2*n]
if ymin>noeuds[2*n+1]:
ymin=noeuds[2*n+1]
if ymax<noeuds[2*n+1]:
ymax=noeuds[2*n+1]
OG=[(xmax+xmin)/2, (ymax+ymin)/2,0.0]
if self.options.vue=="Z":
cr[0]=OG[0] #centre de rotation = centre de gravite
cr[1]=OG[1]
C[0]=OG[0] #place la camera au centre de gravite
C[1]=OG[1]
sys.stderr.write("Centre de rotation :("+str(OG[0])+", "+str(OG[1])+", "+str(self.options.pz)+")\nCamera :("
+str(OG[0])+", "+str(OG[1])+", "+str(C[2])+")\n")
"""
if self.options.vue=="Y":
C[0]=OG[0] #place la camera au centre de gravite
C[1]=self.options.pz
if self.options.vue=="X":
C[0]=self.options.pz #place la camera au centre de gravite
C[1]=OG[1]
#C=project_vue(C,self.options.vue)
cr=project_vue(cr,self.options.vue)
"""
"""boucle sur les objets"""
for objetID in self.options.ids:
XmlNode=self.selected[objetID]
arbre=simplepath.parsePath(XmlNode.get('d'))
a=[]
"""on boucle sur les noeuds de l'arbre """
for noeud in arbre:
noeuds=noeud[1]
nbpoint=len(noeuds)/2
newNoeud=[]
for n in range(nbpoint):
V=project_vue([noeuds[2*n],noeuds[2*n+1],self.options.pz],self.options.vue)
#On place V dans le repere local de rotation
V=[V[0]-cr[0],V[1]-cr[1],V[2]-cr[2]]
#debug(V)
V=rotx(V,ax)
V=roty(V,ay)
V=rotz(V,az)
#replace V dans le repere global
V[0]+=cr[0]
V[1]+=cr[1]
V[2]+=cr[2]
if self.options.dup==False:
V=project(V,C,self.options.zoom)
newNoeud.append(V[0])
newNoeud.append(V[1])
a.append([noeud[0],newNoeud]) #reconstruit l'ensemble des points
XmlNode.set('d', simplepath.formatPath(a))
#debut du code principal____________
effect= Effect()
#debug("debut")
effect.affect()
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.