Student Research Project Ideas

Updated 2,571 Days AgoPublic

Actions

1. Real-looking oil-paint brush with bristles

We have a hairy brush in Krita, but the bristles can be only 1px wide there. We should extend this brush to support bigger bristles and also bristles that remove color. The problem is that the bristles should be painted extremely efficiently. Therefore, the idea of Quick Brush might be use there.

• Priority: high
• Level: 5/5
• Time to code: 3-6w

2. Brush with a heightmap

Just allow brushes to paint in impasto mode. We already have an implementation of Phong Bumbmap filter, we just need a source of the height information. So the brushes should also write this info.

• Priority: high
• Level: 3/5
• Time to code: 1-2w

3. Simulated oil-paint brush

You can take any whitepaper and implement simulation of the oil-paint brush. That is a research project and it should be considered carefully if it can be used in Krita

• Priority: very low
• Level: 5/5
• Time to code: +inf

4. Using AVX2 arithmetics for alpha-blending of color data

AVX2 instruction set (first appeared in Intel Haswell architecture) supports instructions, which can do arithmetics with 16x16-bit integer numbers at the same time. So theoretically, if we process 16 pixels at the same time, we can boost the compositing (painting) performance by 16 times! In practice, we already use AVX1, which allows working with 8x32-bit float numbers, so the gain will be only 2 times, which is also not that bad :)

The support should be implemented within Vc library, which involves a bit of C++ templates magic.

Manual: Intel Optimizations Guide

• Priority: high
• Level: 4/5
• Time to code: 2-4w

5. 3D-model editing tool

The user should be able to load a 3D model as a File Layer, rotate or scale it, and then use it as a reference for painting.

• Priority: medium
• Level: 2/5
• Time to code: 4-8w

6. Auto-hatching with some Machine Learning

References: auto-hatching, auto animation

7. Thick bezier curve rendering

There is a bug in Qt, which makes it render bezier curves incorrectly. It needs a new, better algorithm for rendering bezier curves with width.

Refernce: link

• Priority: very high
• Level: 2/5
• Time to code: 1w
• Time to push your patch to Qt: 3months

8. Lazy selection tool using watershed algorithm

Video: link

• Priority: high
• Level: 3/5
• Time to code: 3w

9. Multithreaded watershed algorithm

There are hardly any papers on it, but it is possible to make it multithreaded. Most probably, will be a real research project

• Priority: medium
• Level: 5/5
• Time to code: NaN

10. Vector brushes

We need some brushes that create a nicely looking vector lines that can be edited later. We already have a calligraphy tool, it creates nice lines, but they are not much editable later. This is a research project.

• Priority: medium
• Level: 2/5
• Time to code: NaN

11. Efficient triangular interpolation method for cage, warp and liquify mesh transformations

Right now we use a naive rectangural interpolation method, which creates suboptimal results for cage transform, which is undefined outside the cage.

• Priority: high
• Level: 2/5
• Time to code: 1-2w

12. Character editing/animation with bones

This project can actually be split into four somewhat independent projects:

1. Tool for editing the bones: forward and inverse kinematics
2. Linking bones to arbitrary 2D-mesh (google: "bone skinning")
3. Importing bones from Blender and/or Synfig
4. Animation of bones

13. Efficient hard-disk storage for animation frame stream

Basically, we need a swapping mechanism for animation cache, which is used for animation playback and which is generated in background. This project is rather simple, because we have quite a lot of tools for efficient swapping of tiles already implemented in Krita. This project just needs a proper scheduler and adaptation of these tools.

• Priority: extremely high(!)
• Level: 2/5
• Time to code: 1-2w

14. Raster-to-vector tracing ("line drawing vectorization")

Vectorization tools are very important in artist's workflow and we have no implementation of it. There are a lot of methods of doing it. Just choose any one you like and implement :)

See for example: link

• Priority: high
• Level: 4/5
• Time to code: +inf

15. Kubelka-Munk color blending

That might be a nice research project. We don't know if it can be used implemented efficiently within Krita, but at least a proof-of-concept application could help us decide.

• Priority: low
• Level: 3/5
• Time to code: +inf