Doc:Overview/es

2010-06-12T01:07:01Z

Ferguweb: Created page with ' {{Title|Introducción}} {{Navigation|Category:Manual|Doc:Getting Started}} Category:Manual Category:Unverified  Synfig Studio es …'

{{Title|Introducción}}
{{Navigation|Category:Manual|Doc:Getting Started}}
[[Category:Manual]]
[[Category:Unverified]]

Synfig Studio es un programa de animación vectorial en 2D de código abierto. Está diseñado para producir animaciones con calidad cinematográfica con pocas personas y recursos.

Según [http://en.wikipedia.org/w/index.php?title=Animation&oldid=358878912 Wikipedia], la animación es la exhibición rápida de una secuencia de imágenes para crear una ilusión de movimiento. Tradicionalmente, la animación 2D se creaba dibujando individualmente cada imagen mostrada. Dichas imágenes se denominan "fotogramas" y este método se llama "animación fotograma a fotograma". Para crear una buena ilusión de movimiento se necesita dibujar muchos fotogramas, es por ello que este método requiere mucho tiempo y recursos.


Synfig Studio está diseñado para eliminar la necesidad de dibujar cada fotograma de forma individual. Existen dos técnicas para lograr esto:
* Animación por transformación (Morphing)
* Animación por cortes (Cutout animation)

'''Morphing''' es una técnica que toma dos imágenes y crea una suave transición entre ellas. En el proceso de transición una forma se deforma hacia la otra y esta deformación se controla mediante puntos de control. En Synfig Studio las imágenes construidas a partir de formas vectoriales y la transformación se realizan de forma automática. Esto permite crear la animación dibujando únicamente posiciones clave a intervalos de tiempo relativamente amplios. Los artistas pueden dibujar tantos fotogramas como necesiten para crear una sensación de movimiento básica para la escena y Synfig Studio se encarga de crear los fotogramas de enmedio.


'''Cutout animation''' se crea dividiendo los objetos en partes y aplicandoles alguna transformación sencilla (como translación, rotación o escalado) en diferentes momentos del tiempo. Synfig Studio usa estos valores para interpolar el movimiento para los fotogramas de enmedio. La animación por corte se puede producir a partir de imágenes bitmap o de gráficos vectoriales.


En ambos casos, el papel de Synfig Studio es rellenar los huecos entre fotogramas dibujados (también llamados "fotogramas clave") para producir una animación suave y fluida. Este proceso se denomina "intermediación" ("tweening"). Pero la intermediación no es la única ventaja de Synfig Studio.

Aunque Synfig Studio no está directamente pensado para dibujar animaciones fotograma a fotograma, puede ser usado para llevar sus animaciones fotograma a fotograma dibujadas a mano al nivel de calidad cinematográfica. Esto se consigue convirtiendo la información de mapas de bits de cada fotograma a formato vectorial. Este proceso se denomina "trazado" ("tracing"). Existen infinidad de efectos integrados en Synfig Studio que le permitirán lograr unas animaciones de aspecto profesional.


Tanto si realiza animaciones fotograma a fotograma como si no, Synfig Studio puede proporcionarle control flexible sobre la información repetitiva, como colores, características de los contornos, texturas, imágenes y mucho más -incluso las trayectorias de animación y sus conjuntos (acciones). La reutilización de información repetitiva se logra mediante el enlazado. Esta potencia de Synfig Studio es especialmente importante para grandes proyectos de animación.

No sólo puede enlazar elementos de información artística, sino también definir relaciones entre ellos utilizando un conjunto de funciones. Esto permite crear animaciones automáticas basadas en unas leyes definidas, llevando el proceso entero de animación a un nuevo nivel.




Para coronarlo todo, Synfig Studio es un software potente dirigido a la creación de animaciones de cualquier complejidad.

{{Navigation|Category:Manual|Doc:Getting Started}}

Doc:Svg2synfig/es

2010-06-09T00:18:13Z

Ferguweb: Created page with '== Opción 1 == Esta opción utiliza una hoja de estilo XSLT 2.0 para transformar el XML de SVG a XML de Synfig. === Objetivo === Convertir una imagen SVG en un archivo Synfig pa…'

== Opción 1 ==
Esta opción utiliza una hoja de estilo XSLT 2.0 para transformar el XML de SVG a XML de Synfig.
=== Objetivo ===
Convertir una imagen SVG en un archivo Synfig para importarlo. Publicado por primera vez en el foro: http://synfig.org/forums/viewtopic.php?t=30
=== Prerrequisitos ===
# Asegúrese de tener instalado un entorno de ejecución Java (JRE).
# Obtenga una versión reciente del procesador de XSLT SAXON para Java de http://saxon.sourceforge.net/. Versión recomendada: Saxon-SA 9.0 (saxonsa9-0-0-2j.zip).
# Extraiga el paquete SAXON a una carpeta de su elección. Como ejemplo vamos a utilizar d:\saxon en lo sucesivo. La carpeta contendrá varios archivos JAR.
# Cree el archivo d:\saxon\svg2synfig.xsl con el contenido proporcionado al final de este documento ({{l|#svg2synfig.xsl}}).
==== Prerrequisitos opcionales para Windows ====
Si no desea utilizar la línea de comandos, cree un archivo de procesamiento por lotes d:\saxon\svg2synfig.bat con este contenido:
@java -jar %0\..\saxon9.jar -xsl:%0\..\svg2synfig.xsl %1 > %0\..\synfig.sif
@pause
=== Transformación de un SVG en un archivo Synfig ===
==== Archivo de proceso por lotes de Windows ====
# Simplemente suelte el archivo SVG sobre svg2synfig.bat.
==== Línea de comandos ====
# Cambie el directorio a d:\saxon.
# Introduzca el siguiente comando (sustituya your_input.svg por la ruta a su archivo SVG):
java -jar saxon9.jar -xsl:svg2synfig.xsl your_input.svg > synfig.sif
=== Resultado ===
Si la conversión ha tenido éxito, el resultado se escribirá en el archivo d:\saxon\synfig.sif.
Puede abrir este archivo en Synfig.
=== Limitaciones ===
* No parece funcionar con SaxonB (la versión FOSS)
* Los SVG comprimidos (svgz) deben ser descomprimidos primero.
* Únicamente los trayectos de objetos SVG están soportados. Intente convertir todos los objetos a trayectos.
* Sólo un subconjunto de elementos de trayecto está soportado. Intente modificar todos los nodos de trayecto de forma que tengan tangentes divididas, y todos los segmentos de trayecto sean curvas.
* El coloreado sofisticado (gradientes, por ejemplo) no está soportado.
* Sólo las transformaciones básicas están soportadas.
* Relleno y contorno en el mismo objeto no está soportado.
=== svg2synfig.xsl ===
<pre><nowiki>
<xsl:stylesheet version="2.0" exclude-result-prefixes="#all"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:math="http://exslt.org/math">
<xsl:output method="xml" indent="yes" encoding="UTF-8"/>

<xsl:template match="/">
<xsl:apply-templates/>
</xsl:template>

<xsl:template match="svg:svg">
<xsl:variable name="width" select="math:units_to_px(@width)"/>
<xsl:variable name="height" select="math:units_to_px(@height)"/>
<xsl:variable name="has_view_box" select="matches(@viewBox, '(\d+\s){3}\d+')"/>
<canvas version="0.2" id="{@id}"
width="{if ($has_view_box) then replace(@viewBox, '(\d+)\s(\d+)\s(\d+)\s(\d+)', '$3') else $width}"
height="{if ($has_view_box) then replace(@viewBox, '(\d+)\s(\d+)\s(\d+)\s(\d+)', '$4') else $height}"
view-box="{if ($has_view_box) then @viewBox else concat('0 0 ', $width, ' ', $height)}">
<xsl:apply-templates select="svg:g|svg:svg|svg:path"/>
</canvas>
</xsl:template>

<xsl:template match="svg:g">
<layer type="PasteCanvas" active="true" version="0.1" desc="{@id}">
<param name="canvas">
<canvas>
<xsl:apply-templates/>
</canvas>
</param>
</layer>
</xsl:template>

<xsl:template match="svg:path">
<xsl:variable name="style">
<xsl:for-each select="ancestor-or-self::*">
<xsl:sort select="position()" data-type="number" order="descending"/>
<xsl:value-of select="concat(@style, ';fill:', @fill, ';stroke:', @stroke, ';stroke-width:', @stroke-width, ';')"/>
</xsl:for-each>
</xsl:variable>
<xsl:variable name="self" select="."/>
<xsl:variable name="is_fill" select="not(matches(replace($style, 'fill:[^n;][^o].*', ''), 'fill:none'))"/>
<xsl:analyze-string select="@d" regex="m[^z]+(z|$)" flags="i">
<xsl:matching-substring>
<layer type="{if ($is_fill) then 'region' else 'outline'}" version="0.1" desc="{$self/@id}">
<xsl:call-template name="style-to-color">
<xsl:with-param name="style" select="replace(replace($style, ':none.*', ''), if ($is_fill) then '.*fill:([^;]+).*' else '.*stroke:([^;]+).*', '$1')"/>
</xsl:call-template>
<xsl:if test="not ($is_fill)">
<xsl:call-template name="style-to-width">
<xsl:with-param name="style" select="replace($style, '.*stroke-width:([^;]+).*', '$1')"/>
</xsl:call-template>
</xsl:if>
<param name="bline">
<bline type="bline_point" loop="{matches(., 'z', 'i')}">
<xsl:call-template name="path-to-bline">
<xsl:with-param name="path" select="."/>
<xsl:with-param name="node" select="$self" tunnel="yes"/>
</xsl:call-template>
</bline>
</param>
</layer>
</xsl:matching-substring>
</xsl:analyze-string>
</xsl:template>

<xsl:template name="path-to-bline">
<xsl:param name="path"/>
<xsl:variable name="stripped" select="replace(replace(translate($path, ',', ' '), '(\d)-', '$1 -'), '\s*([a-z]+)\s*', '$1', 'i')"/>
<xsl:variable name="closed" select="if (matches($stripped, 'z', 'i')) then $stripped else replace($stripped, 'm([-\d.]+\s[-\d.]+).*$', '$0l$1z', 'i')"/>
<xsl:variable name="tmp" select="replace($closed, '([-\d.]+\s[-\d.]+)l([-\d.]+\s[-\d.]+)', '$1c$1 $2 $2', 'i')"/>
<xsl:variable name="curve" select="replace($tmp, '([-\d.]+\s[-\d.]+)l([-\d.]+\s[-\d.]+)', '$1c$1 $2 $2', 'i')"/>
<xsl:analyze-string select="$curve" regex="\s([-\d.]+\s[-\d.]+)\s[-\d.]+\s[-\d.]+z" flags="i">
<xsl:matching-substring>
<xsl:analyze-string select="concat(regex-group(1), $curve)" regex="([-\d.]+)\s([-\d.]+)[m\s]([-\d.]+)\s([-\d.]+)c([-\d.]+)\s([-\d.]+)" flags="i">
<xsl:matching-substring>
<xsl:call-template name="node-to-bline-point">
<xsl:with-param name="c1_x" select="regex-group(1)"/>
<xsl:with-param name="c1_y" select="regex-group(2)"/>
<xsl:with-param name="x" select="regex-group(3)"/>
<xsl:with-param name="y" select="regex-group(4)"/>
<xsl:with-param name="c2_x" select="regex-group(5)"/>
<xsl:with-param name="c2_y" select="regex-group(6)"/>
</xsl:call-template>
</xsl:matching-substring>
</xsl:analyze-string>
</xsl:matching-substring>
</xsl:analyze-string>
</xsl:template>

<xsl:template name="node-to-bline-point">
<xsl:param name="x"/>
<xsl:param name="y"/>
<xsl:param name="c1_x"/>
<xsl:param name="c1_y"/>
<xsl:param name="c2_x"/>
<xsl:param name="c2_y"/>
<xsl:param name="node" tunnel="yes"/>
<xsl:variable name="transform">
<xsl:for-each select="$node/ancestor-or-self::*/@transform">
<xsl:value-of select="."/>
</xsl:for-each>
</xsl:variable>
<xsl:variable name="t" select="math:resolve_transform($transform)"/>
<xsl:variable name="transformed_x" select="$t[5] + $t[1] * xs:float($x) + $t[3] * xs:float($y)"/>
<xsl:variable name="transformed_y" select="$t[6] + $t[2] * xs:float($x) + $t[4] * xs:float($y)"/>
<xsl:variable name="transformed_c1_x" select="$t[5] + $t[1] * xs:float($c1_x) + $t[3] * xs:float($c1_y)"/>
<xsl:variable name="transformed_c1_y" select="$t[6]+ $t[2] * xs:float($c1_x) + $t[4] * xs:float($c1_y)"/>
<xsl:variable name="transformed_c2_x" select="$t[5] + $t[1] * xs:float($c2_x) + $t[3] * xs:float($c2_y)"/>
<xsl:variable name="transformed_c2_y" select="$t[6]+ $t[2] * xs:float($c2_x) + $t[4] * xs:float($c2_y)"/>
<entry>
<composite type="bline_point">
<point>
<vector>
<x><xsl:value-of select="$transformed_x"/></x>
<y><xsl:value-of select="$transformed_y"/></y>
</vector>
</point>
<width>
<real value="1"/>
</width>
<origin>
<real value="0.5"/>
</origin>
<split>
<bool value="true"/>
</split>
<t1>
<xsl:call-template name="vector-pair-to-radial">
<xsl:with-param name="origin-x" select="$transformed_c1_x"/>
<xsl:with-param name="origin-y" select="$transformed_c1_y"/>
<xsl:with-param name="x" select="$transformed_x"/>
<xsl:with-param name="y" select="$transformed_y"/>
</xsl:call-template>
</t1>
<t2>
<xsl:call-template name="vector-pair-to-radial">
<xsl:with-param name="origin-x" select="$transformed_x"/>
<xsl:with-param name="origin-y" select="$transformed_y"/>
<xsl:with-param name="x" select="$transformed_c2_x"/>
<xsl:with-param name="y" select="$transformed_c2_y"/>
</xsl:call-template>
</t2>
</composite>
</entry>
</xsl:template>

<xsl:template name="vector-pair-to-radial">
<xsl:param name="x"/>
<xsl:param name="y"/>
<xsl:param name="origin-x"/>
<xsl:param name="origin-y"/>
<xsl:variable name="dx" select="xs:float($x) - xs:float($origin-x)"/>
<xsl:variable name="dy" select="xs:float($y) - xs:float($origin-y)"/>
<xsl:variable name="d" select="math:sqrt($dx * $dx + $dy * $dy)"/>
<xsl:variable name="angle" select="math:atan2($dy, $dx)"/>
<radial_composite type="vector">
<radius>
<real value="{$d * 3}"/>
</radius>
<theta>
<angle value="{$angle * 57.295779513082320876798154814105}"/>
</theta>
</radial_composite>
</xsl:template>

<xsl:template name="style-to-width">
<xsl:param name="style"/>
<xsl:if test="matches($style, '^\d')">
<param name="width">
<real value="{math:units_to_px($style)}"/>
</param>
</xsl:if>
</xsl:template>

<xsl:template name="style-to-color">
<xsl:param name="style"/>
<xsl:if test="matches($style, '#')">
<xsl:analyze-string select="concat($style, ';')" regex="#([\da-f]{{2}})([\da-f]{{2}})([\da-f]{{2}});">
<xsl:matching-substring>
<param name="color">
<color>
<r><xsl:value-of select="math:hex_to_color(regex-group(1))"/></r>
<g><xsl:value-of select="math:hex_to_color(regex-group(2))"/></g>
<xsl:value-of select="math:hex_to_color(regex-group(3))"/>
<a><xsl:value-of select="if (matches($style, 'fill-opacity:')) then math:power(xs:float(replace($style, '.*fill-opacity:([-\d.]+).*', '$1')), 1 div 2.2) else 1"/></a>
</color>
</param>
</xsl:matching-substring>
</xsl:analyze-string>
</xsl:if>
<xsl:if test="matches($style, 'rgb')">
<xsl:analyze-string select="concat($style, ';')" regex="rgb[(\s]+([-\d.]+)[,\s]+([-\d.]+)[,\s]+([-\d.]+)[\s)]+;">
<xsl:matching-substring>
<param name="color">
<color>
<r><xsl:value-of select="math:power(xs:float(regex-group(1)) div 255, 2.2)"/></r>
<g><xsl:value-of select="math:power(xs:float(regex-group(2)) div 255, 2.2)"/></g>
<xsl:value-of select="math:power(xs:float(regex-group(3)) div 255, 2.2)"/>
<a>1</a>
</color>
</param>
</xsl:matching-substring>
</xsl:analyze-string>
</xsl:if>
<xsl:if test="matches($style, 'url')">
<param name="color">
<color><r>0.5</r><g>0.5</g>0.5<a>0.5</a> </color>
</param>
</xsl:if>
</xsl:template>

<xsl:function name="math:resolve_transform">
<xsl:param name="transform"/>
<xsl:variable name="stripped" select="replace(replace($transform, 'translate$', 'X(1,0,0,1,'), 'matrix', 'X')"/>
<xsl:analyze-string select="concat('X(1,0,0,1,0,0)', $stripped)" regex="(.*)X\((-?[\d.]+),(-?[\d.]+),(-?[\d.]+),(-?[\d.]+),(-?[\d.]+),(-?[\d.]+)$[^X]*X$(-?[\d.]+),(-?[\d.]+),(-?[\d.]+),(-?[\d.]+),(-?[\d.]+),(-?[\d.]+)$.*">
<xsl:non-matching-substring>
<xsl:sequence select="(1,0,0,1,0,0)"/>
</xsl:non-matching-substring>
<xsl:matching-substring>
<xsl:variable name="a2" select="xs:float(regex-group(8))"/>
<xsl:variable name="b2" select="xs:float(regex-group(9))"/>
<xsl:variable name="c2" select="xs:float(regex-group(10))"/>
<xsl:variable name="d2" select="xs:float(regex-group(11))"/>
<xsl:variable name="e2" select="xs:float(regex-group(12))"/>
<xsl:variable name="f2" select="xs:float(regex-group(13))"/>
<xsl:variable name="a1" select="xs:float(regex-group(2))"/>
<xsl:variable name="b1" select="xs:float(regex-group(3))"/>
<xsl:variable name="c1" select="xs:float(regex-group(4))"/>
<xsl:variable name="d1" select="xs:float(regex-group(5))"/>
<xsl:variable name="e1" select="xs:float(regex-group(6))"/>
<xsl:variable name="f1" select="xs:float(regex-group(7))"/>
<xsl:variable name="p" select="($a1*$a2+$c1*$b2,$b1*$a2+$d1*$b2,$a1*$c2+$c1*$d2,$b1*$c2+$d1*$d2,$a1*$e2+$c1*$f2+$e1,$b1*$e2+$d1*$f2+$f1)"/>
<xsl:variable name="remainder" select="replace(regex-group(1), 'X$1,0,0,1,0,0$', '')"/>
<xsl:choose>
<xsl:when test="matches($remainder, 'X')">
<xsl:variable name="recursion" select="concat($remainder, 'X(', $p[1], ',', $p[2], ',', $p[3], ',', $p[4], ',', $p[5], ',', $p[6], ')')"/>
<xsl:sequence select="math:resolve_transform($recursion)"/>
</xsl:when>
<xsl:otherwise>
<xsl:sequence select="$p"/>
</xsl:otherwise>
</xsl:choose>
</xsl:matching-substring>
</xsl:analyze-string>
</xsl:function>

<xsl:function name="math:hex_to_color" as="xs:float">
<xsl:param name="hex"/>
<xsl:value-of select="math:power(xs:float(string-length(substring-before('0123456789abcdef', substring($hex,1,1))) * 16 + string-length(substring-before('0123456789abcdef', substring($hex,2,1)))) div 255, 2.2)"/>
</xsl:function>

<xsl:function name="math:units_to_px" as="xs:float">
<xsl:param name="size"/>
<xsl:analyze-string select="$size" regex="^([-\d.]+)([a-z%]*)$">
<xsl:matching-substring>
<xsl:variable name="factor">
<xsl:choose>
<xsl:when test="regex-group(2) = 'pt'">1.25</xsl:when>
<xsl:when test="regex-group(2) = 'em'">16</xsl:when>
<xsl:when test="regex-group(2) = 'mm'">3.54</xsl:when>
<xsl:when test="regex-group(2) = 'pc'">15</xsl:when>
<xsl:when test="regex-group(2) = 'cm'">35.43</xsl:when>
<xsl:when test="regex-group(2) = 'in'">90</xsl:when>
<xsl:otherwise>1</xsl:otherwise>
</xsl:choose>
</xsl:variable>
<xsl:value-of select="xs:float($factor) * xs:float(regex-group(1))"/>
</xsl:matching-substring>
</xsl:analyze-string>
</xsl:function>
</xsl:stylesheet>
</nowiki></pre>

== Opción 2 ==

Esta es un programa en C realizado por akagogo que utiliza libxml para convertir SVG al formato de Synfig.

http://none.carlos.googlepages.com/svgtosif.zip

=== Instalación ===

Simplemente efectue los habituales '''./configure && make && sudo make install'''

=== Utilización ===

Los archivos SVG deben estar en una carpeta llamada '''data'''. Debe ejecutar el comando desde el directorio padre, pero usando el nombre del archivo como argumento del comando. Así, si:

* Tiene una carpeta "/ejemplo" debe crear una carpeta llamada "/ejemplo/data" y colocar allí el archivo "file.svg".
* Ahora ejecute '''svgtosif file.svg''' siendo "/ejemplo" su actual directorio de trabajo.

Como puede ver, esto no es realmente muy amigable. Para solucionar rápidamente el problema, utilice el siguiente script de bash:

#!/bin/bash
mkdir data
cp "$1" data/
/usr/local/bin/svgtosif "$1"
NAME=`echo "$1" | cut -d "." -f 1`
cp "data/$NAME.sif" .
rm data/*
rmdir data
echo "Conversion complete!"

Ponga estas líneas en un archivo llamado "svg2sif" (llámele como prefiera, pero evite llamarle "svgtosif") y guárdelo en un directorio PATH (se sugiere /usr/bin). Entonces:
chmod +x /usr/bin/svg2sif

Eso es todo. Ahora utilice:
svg2sif <file.svg>

y obtendrá un archivo .sif en la misma carpeta en que esté trabajando.

Synfig Studio :: Documentation - User contributions [en]

Doc:Overview/es

Doc:Svg2synfig/es