GSoC proposal: comic related brush engines and impasto implementation

[JL VT]

Fellow Krita developers and users,
below is my first GSoC proposal draft. If you consider it good enough,
I'll upload it to Google's Summer of Code website.

Thank you for your feedback,
Pentalis.
(José Luis Vergara)




=============Introduction=============

Krita is a raster graphics editing application whose aim is to offer an
integrated solution to create images from scratch. This puts the application in
competition with commercial solutions like Corel Painter and other
artist-focused applications like Art Rage and SAI.

The target audience for krita is, therefore, any artist who works creating art
from scratch. This includes fine artists who wish to experiment with digital
media, comic artists, illustrators, etc.

Desirable new features for Krita include functionalities that simulate a real
artist's workspace, like the ability to turn the canvas without touching the
image data, mirroring, realistic color mixing, impasto-like effects, brush
engines simulating real media, colorspace-aware color pickers, among many
others.


================Project Proposal and Background Information================

The goal of this project is to improve Krita's simulation of real media,
through new special brush engines or filter operations (see below), and
implementation of impasto effect simulation.

The new features to implement are of interest to both comic artists and
painters.

------Features to be implemented------

1) A versatile and thorough halftone and hatching mechanism.

The goal of this feature is not to merely create a filter to create halftones
from a color or simulate printer dot patterns (even though that may be part of
its functionality). Its objective is to allow the artist to have access to a
digital tool which, with simplicity, simulates the versatility of real life
tools for halftoning, hatching and other patterns. For example, to create images
like this:
http://derbyimages.woot.com/724994/8a44b08d-1d87-4c08-a4f2-535e1785e4f7.jpg

Where the use of halftones could be interpreted as a technical necessity but as
an artistic choice as well.

Manga artists make exhaustive use of preprinted patterns, and there's entire
product lines devoted to such end[1]. Many consist of large sheets of contiguous
pattern to be cut out from the sheet and pasted on the desired location, often
by merely applying pressure on the desired spot (similar to this example
image[2]).

Many different patterns can be achieved producing very interesting effects.
Such patterns are even individually numbered by manufacturers and presented to
users in sample images:
http://www.mangablog.es/imagenes-posts/maxon_01.jpg

The tool to be developed ought to make it possible to achieve just as many
patterns as real life tools permit, but with the increased ease and convenience
of a digital workspace. This could be achieved by creating specialized filters
and refining the already existing filter brush engine such that both tools
integrate and work seamlessly.
Creating a completely new, parametric brush engine is another option.
Whichever way turns out to be the best in terms of code correctness
and usability, for the tool to be readily usable and useful, it must include a
pattern generator for halftones and hatching. Parameters to accept user input
would include, at least:
--For halftones, spacing between dots, angle[3], max and minimum dot size. The
ability to choose the source of darkening: whether it is caused by dot density,
greater dot diameter, or adding more dot patterns in different angles.
--For hatching, spacing between lines, line thickness, angle. The ability to
choose the source of darkening: whether it is caused by line density, or
greater line thickness, or adding more line patterns in different angles.
If time permits, the ability to create more patterns procedurally[4], or to
control more parameters in the same types of patterns, can be implemented, for
example, to obtain the curved line patterns that are present in hand drawings
like this:
http://longstreet.typepad.com/.a/6a00d83542d51e69e201156e487aa5970c-500wi

While tutorials to create halftone patters using the already existing tools in
Photoshop[5] and The GIMP[6] already exist, such constrained method
to obtain halftone patterns is what this tool purports to substitute.

Summarizing, this first feature will consist of a new set of filters, with
parameters to generate patterns, and the ability to apply such patterns on a
selection. Such filters should be applicable with a brush in order for them to
be intuitive and usable. This could be immediately achieved using the already
existing filter brush. If the filter brush code is enough to work
seamlessly with those filters, work will be done on making this
integration. However, if this is not possible, a new brush engine specially
prepared to make use of those filters will be prepared, ready to accept input
like stylus pressure and angle and to turn it into pattern parameters.


[1] http://www.letraset.com/manga/shopdisplaycategories.asp?id=2930&cat=
Screentone+Single+Sheets
[2] http://images2.makefive.com/images/200905/01e35ede59597eac.jpg
[3] http://2.bp.blogspot.com/_lNzlqVMcIj8/ShnkMi1UQWI/AAAAAAAAAoA/IX76dAXXInI/
s400/Screen+angles.jpg
[4] http://www.fao.org/docrep/003/T0390S/T0390S86.gif
[5] http://snowbunnyluv.deviantart.com/art/Tutorial-Colour-halftone-31323611
[6] http://istarlome.deviantart.com/art/halftone-effect-in-gimp-65731702



2) A system to simulate paint thickness: impasto-like effects.

The goal of this feature is to simulate the bumpy texture of thick paint.
The original, real life technique called "Impasto" is well described in this
article:
http://en.wikipedia.org/wiki/Impasto

The implementation of this feature should be comparable in quality to that of
competing software like Corel Painter or Art Rage. This includes the ability of
the impasto layer (or layers) to be edited, choosing the source of illumination
to create the bump mapping, etc. The technical aspects (for example, deciding
whether to implement all impasto effects in one layer or in separate layers) are
going to be decided during implementation time.



====================Timeline====================

Given my particular circumstances (see 'about the applicant'), this project is
going to be taken with the same responsibility as a full time job.

Work is due to begin as soon as I learn whether my proposal has been accepted,
and it will continue until all minimal features promised are accepted.

I consider myself in an ill position to predict how long each stage of this
project is going to take, but I can give rought estimates:

April 26 -- Work commences.
June 16 - June 26 -- Either part 1 (halftones and hatching) or part 2 (impasto)
of the project should be completely finished. This includes documentation, bug
fixing, and integration into the trunk branch.
August 05 - August 16 -- The unfinished part of the project (the one not
finished first) should be completely finished as well.

In the event that I find myself with both parts of the project complete with
their minimum feature set, before the equivalent of 3 months of full
time work (roughly 500 hours of coding) have been completed, and there is
remaining time in Google's Summer of Code, this spare time will be used in
improving existing tools, the bottom line is:

QUALITY OVER QUANTITY.



====================About the Applicant=====================

I'm a graduated chemistry student about to obtain my professional title (which
is obtained after 5 years of education, graduation requires 4), currently
enrolled in a master's degree on intellectual property in my alma mater
(University of Santiago of Chile). I've been in contact with computers since
I have memory, when I had access to a PC-1 computer[7] with MS-DOS. My first
program was made in Visual Basic when I was 10 (it was a dice roll simulator).
Further experience includes the (incomplete) creation of a dynamic website with
PHP and Javascript, and an hexagon based panel for a PyGame-based game. The
only finished piece with source code available is a command-line dice roll
analyzer, made in C++[8].

I've used free software for years and my motivation to join the Google's Summer
of Code is multiple. Partly it is my drive to give something back to the
community that has given so much to me, partly it is about improving a tool I
need to use for professional work (in a future personal project), and I need the
stipend to sustain myself.

The career I chose to study, while having a great potential market for jobs, is
not particularly attractive to employeers in my country. We chemists are often
mistaken for technicians, and as a result are often offered a lower wage and
less interesting field of work than we'd expect.

For my first job I'd rather do something intellectually stimulating, well paid,
and for an institution I love, than the nearly complete opposite that the
current job market offers for me and fellow chemists. This project fulfills all
those requisites.


[7] http://www.seasip.info/VintagePC/prodestpc1.html
[8] http://pentalis.org/Analizator.cpp