Extension inkscape

Soyez le premier à donner votre avis sur cette source.

Vue 4 948 fois - Téléchargée 137 fois

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).

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()

Codes Sources

A voir également

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.