Hello there, my name is Gustav Gonzalez and I'm the leader and current developer of the Tupi project, a 2D
vectorial animation tool (http://www.maefloresta.com).

A week ago I was attending the Libre Graphics Meeting 2013 and I had the pleasure of meeting Boud and talk
to him about the possibility of developing some kind of "bridge" between Krita and Tupi to provide the feature
of 2D animation.

The initial idea is to use the format ORA (OpenRAster) to create the frames from Krita and then load them from
Tupi to create/adjust the animation files. Anyway, it's just our first approach.

This is a very general specification of the TUP format file: http://maefloresta.com/portal/files/tup_format.svg
In case that some of you want to share some ideas with me about how to enhance it and how to work together
on the Krita+Tupi feature.

Every comment, question, suggestion is very welcome. Thank you.

PS: Currently, the git repository of Tupi is here -> https://github.com/xtingray/tupi

Hi Gustav,

Nice to see you on the Krita forum!
About Krita + Tupi workflow, this idea you talked about with boud is interesting, however it may not be the best.

The thing is there's a GSOC proposal to get some basic animation feature in Krita, and if we can get it done, then it would be easy to sketch animation frames in Krita, export frame sequence and import it in Tupi to trace with vector ink and colors (in this case Tupi just needs to handle properly image sequence import ).

Another idea then could be to contribute directly some Tupi features in Krita (enhancing the potential animation features and the vector tools.. As current Krita vector tools come from Karbon application which is a bit unmaintained now... ). Sure that's a different approach, but it may be the best way to get something efficient quickly and without overlapping features.

Anyway I'm looking forward to your progress

Hello Timothee, nice to read you!

Let me tell you a little about my work in progress. Right now I'm studying this library: git://gitorious.org/openraster/libora.git
and looking for some kind of Qt wrapper library to deal with ORA files. After that, I will make some tests with ORA files generated
from Krita to ensure that the support is transparent/accurate.

My next step will consist of creating a new Tupi feature to import an ORA file as a Layer, understanding that in Tupi, one Layer is
a bunch of Frames. In that way, to create an animation file from an ORA file will be an easy task using Tupi.

As you can see, my first approach is very minimalistic but handy. I hope to implement this feature really quick so you'll be able to
test it soon

What do you think?

Hum, I'm sorry to say I think that's not a good way to do it, for several reasons.

Layers in ORA are not a bunch of frames, they are "compositing" layers, as Tupi layers, but don't have the "Time" property which would allow to have a bunch of frames per layer.
Currently we can use a hacky workaround to make some sort of frames using group layers and some shortcuts to switch between them, but this is not a proper long term solution.
And even with this, the exported ora file would contain:
-several top-level group layers corresponding to different frames,
-each groups containing several "compositing" layers for different elements and drawing steps can be raster and/or vector layers,
-and some "junk" layers like some clone layers+ color layers I use currently to fake light-table, or possibly other elements useful during workflow but that don't need to be in the final export compositing.

So basically, import ORA is good, but import it as a simple multi-layer image, not as a file sequence..
To can really use ORA as an animation file format would require to add a possible "animation/frame/time" parameter to layers to can contain several frames per layer. Until then, the only proper way to use ora for animation is 1file/frame like a png files sequence but possibly with multi-layer.

Also ORA is limited as it can contain only bitmap layers up to 16bit, while Krita can work which much more kinds of data. So relying on ORA export for a big feature like animation would restrict a lot workflow possibilities.

Finally, let's see if the GSOC animation proposal gets accepted, what file format we'll have to support animation in Krita then.

Wow! Your arguments are very strong... I think I'll have to change my route map unavoidably.
This thread has been very educational for me. Thank you!

But, I still have some questions to do...

1) So, if you can export your illustrations from Krita as PNG files, supporting the ORA format in Tupi has no sense, right?

2) What should be the best way to connect Krita with Tupi right now? Does it exist one different to the obvious and
boring way:
1. Work on single images from Krita, thinking that every one is a "frame"
2. Export every image as PNG file
3. Import the set of images (frames) as an array from Tupi
4. Create the animation file from Tupi

Question 3:
What about to create a very very basic set of frames from Tupi, then open them one by one from Krita and make the detailed
art work there, and then, import them back into Tupi to create the animation? Not so nice, I guess... is it? :S

Well, I'll be waiting for the animation format specifications for Krita, and then, try to find out how to join the party

Comments and suggestions are very welcome!

Good questions, I'm happy you ask them
So
-supporting ora can make sense as an alternative, like we could have the option to load them either as a single layer in Tupi (but just keeping layers work inside the file), or import each layers as a corresponding layer in Tupi. Also if one would import an array of ORA files, consistent layer names across the files should share the same import layer.. (do you see what I mean?) But it is less important than a good simple png sequence support first.

-Right now, as I explained best way in Krita is to draw keyframes in separate group folders, and then we already have a nice convenient feature to export every group layers to a separate file, and so get a set of separate frames in few clicks, keeping control of what is exported on each frame.
(The reason why it's not a good long term solution is that it can't handle real animation workflow with hundreds/thousands of frames in such group layers structure, adding manually clone layers for each frame to fake onionskin/light-table is tedious and not productive.. and so "frames" need to be handled properly first in Krita before to think about extending it with any other animation feature like onionskin, playback/flipbook or time/frame management. Currently it's only really usable on very small animations, and only for keyframes.)

-I don't see myself using vector drawing tools to sketch basic frames of animation, it's really more the other way.
For now I think it's more efficient to make keyframes sketch in Krita (as bitmap painting tools are always better at this step), and import them in Tupi to trace clean keyframes and inbetweens and apply colors (as vector drawing tools can be better at this step), and to tweak the timing at this step.

But yes more ideas will have to wait for the hopefully coming soon animation support in Krita...

Hello there again!

This weekend I was working on a very basic example of how to use Tupi to create an animation from a set
of raster images.

You can watch the final result here: http://www.youtube.com/watch?v=VFTk2D9zrkM
And the "making of" right here: https://vimeo.com/64955852

Note: The video edition for both videos was made using Kdenlive.

By the way, while I was trying to make this example, I had to fix some bugs that accidentally I found, so, if you
want to give a try to this feature, I recommend you to use the latest version of the Tupi source code, available
from: https://github.com/xtingray/tupi

Right now, the process of importing the image arrays is really slow. In fact, I still remember the expression
of Boud when he saw that part of the code. The expression into his eyes was something like: "blasphemy!"
So, for now, I would recommend you to use images with a resolution of less than 400 pixels, but anyway, I
promise to enhance this feature in some weeks.

I would love to see a short example like mine but using Krita, is there any chance?

Ha, yes . I think animtim has a nice video of a moving face done in Krita.

Yep I've a few animations tests made with Krita, I will collect them and paste a link here.

Though as I've reported already to xtingray I've a problem to build current Tupi (apparently because because of a libav/ffmpeg incompatibility), so I can't test Tupi further for now.

Here are two little animation tests made with Krita. It's only some quick sketch of face expressions and of a walk-cycle.

test 00
test 01

Hello guys!

This morning I added a new option to the configuration script: --without-ffmpeg
Please, update your Tupi source code from: https://github.com/xtingray/tupi and
try it again. I ran some tests and it worked nice for me.

Regards,

PS: Please, let me know if you have any issue.

Nice, now with this option I could finish my build and run it without problems.
I started to play around with the tools, I already noted some things that need improvement in your vector drawing tools, I'll send you an usability bug list soon

Don't know if its possible to incorporate into Tupi or Krita's structure yet this is just a feature suggestion I'd like to see in a 2D animation a package.
I had in the past worked with GIMP and had requested a script to to generate intermediate paths on separate layers then stroke them similar to vector animation yet tracing hand drawn keyframes with raster based lines, (create paths with path tool, creates motion between them.) helping to draw inbetweens from keyframes. A very nice scripter by the Name of Ofnuts replyed by posting a link to his script on GIMPCHAT See page 5 of forum for animation samples. http://gimpchat.com/viewtopic.php?f=9&t=4568&sid=7284bf8824bb2c8ba2bf3a88528fc1e2
The script could be used for generating single images having a unique effect or for node based animation, I used it for tracing keyframes with path tool then generating inbetween frames , sigh the script was limited though as it didn't imitate stroke pressure, of course the same amount of nodes had to be present as well. Yet the biggest downside is the script generated multiple frames (layers) yet it had no option to stroke on existing frames already made.(transparent layers) so you couldn't ink all parts of the keyframes to generate good inbetweens.

I believe the idea had potential for the single animators workflow. and I would have liked to have seen it expanded upon.
Just a feature I'd like to see, if possible lol that and autofill mutiple frames (layers) based on being enclosed and location.

That's a cool idea -- but first we need to get the animation plugin into shape! The file format definition is almost done, and we've got quite a bit of gui, but there's a lot of work left.

Hello there!

The last two weeks I had been working on a very basic feature to use Krita from Tupi to edit library objects as part of the animation process. Here you'll find a little demo of it: http://www.youtube.com/watch?v=MYn84B-_BAU

This feature will be available in the next Tupi's minor release. I hope this can be handy for someone

Regards,