Hacking:GSoC/2011/Ideas

From GIMP Developer Wiki
Jump to: navigation, search

WORK IN PROGRESS!

This page is the official ideas list for GIMP (and GEGL's) application to Google Summer of Code 2011.

GIMP is the Gnu Image Manipulation Program, and GEGL is a Graph based Image Processing Library. GEGL is being designed (mainly, but not only) to be GIMP's new core which will allow better parallelism, better memory management, non-destructive editing and higher bit depths.

For more GEGL ideas, see http://gegl.org/contribute.html

For history of GIMP and GSoC, along with past ideas, see Hacking:GSOC_Archive, and for details about applications see Hacking:GSOC‎

The GSoC timeline for this year can be found at: http://www.google-melange.com/document/show/gsoc_program/google/gsoc2011/timeline

Recommended

Ideas which are generally considered as good for GSoC this year, and are recommended for students.

Note about mentors: some projects have mentors listed for them - these are projects where a specific mentor already agreed to take if the project is accepted. However, this does not mean that other projects have no mentor! In case projects other than the ones who have a mentor listed here, will be accepted, a mentor will be assigned for them.

Replace the GimpSizeEntry widget

Category: User Interface

Potential Mentor: Martin Nordholts

Right now both the code and the UI is a mess. The unit should for example be in the text entry itself instead of in a combo box. Right now the value and the unit are displayed in different fields - one in a combobox and one in a regular text entry. Doing things like 50px*3+3cm should be possible - that requires adding basic logic for math (which partially exists now) and merging the unit smartly into the text entry with the value.

Minimal Student Requirements:

  • Good C knowledge
  • Gtk+/GObject basic knowledge and/or at least some interest in User Interface programming

Porting GIMP plugins to GEGL operations

Category: Plug-Ins

Potential Mentor: Mukund Sivaraman

In short: There are many many GIMP plugins that would need eventually to be converted to GEGL operations, if we want to use them in future versions of GIMP.

GIMP is being ported to use a new image processing core called GEGL, a graph based image processing library, which allows non-destructive editing, higher bit depths, smart job managements and memory management, and much more. Unfortunatly, GIMP's plugins use GIMP's own existing API which is not compatiable with GEGL's api for design reasons. Therefore, at least the core plugins should be ported to GEGL, which means porting the image processing logic and doing some adaptions to the logic.

This is a very large undertaking as there are a large number of GIMP plug-ins, each doing something entirely different from another. Porting each plug-in is a relatively simple and straightforward task, but it requires a good command over the C language and ability to review and understand unelegant code.

As this is a large task, this could be sub-divided into smaller tasks to be taken up by more than one student: each student ports 6-10 plug-ins to GEGL ops during the summer.

  • We want to see a demonstration of the student's ability to review C code in the context of the GIMP plug-ins.
  • The student should be able to work with computer graphics code. Most of the code in the plug-ins directory is raster graphics related with a bit of computational geometry.
  • As part of this task, some of the plug-in code may have to be entirely rewritten. But this could be smaller and simpler in many cases than the existing GIMP plug-ins code, as GEGL ops are written using floating point in a well-defined colorspace.
  • The student's work will include coding, writing testcases, profiling and optimizing performance, and checking for bugs.
  • We are looking for students who are committed to finish their work and communicate eagerly with their mentor. We will assist as much as we can. Though the student is expected to have a background in C programming, we will teach the student how to use various programming tools if necessary.
  • The student is asked to subscribe to gimp-developer mailing list and send the following:
    • Your background as it applies to this task (please don't send any personal information)
    • A code review and algorithm description of the following GIMP plug-ins: cubism, fractal trace, plasma. Extra points for cartoon and photocopy.
    • A code review and algorithm description of the following GEGL op: gaussian blur
    • Sample implementation of a new GEGL op. This could be anything of your choice, even Hello World. Please send it as a patch against GEGL master branch.

If you need any help with any of these tasks, please ask on the gimp-developer mailing list, or in the #gimp channel on irc.gimp.org.

Implement the free transform tool

Category: Tools, User Interface

The free-transform tool should a all-in-one transformation tool that will allow fast and easy transformation of images, with all kinds of affine transformations at once. For exact specifications, reasons which make this tool needed and more, see: http://gui.gimp.org/index.php/Transformation_tool_specification

Minimal Student Requirements:

  • Good C knowledge
  • Gtk+/GObject basic knowledge and/or at least some interest in User Interface programming

Dynamically resized layers

Category: Tools, User Interface, Core

Potential Mentor: Martin Nordholts

Allow layers to be resized dynamically as the user paints on them, and save the user the burden of managing layer sizes

Right now layers have to be manually resized, which is unefficient and non-useable. The first and most common problem is painting and discovering that you reached the end of the layer in the middle of your brush stroke. Another common inefficiency is simply saving large layers which is a waste of memory (RAM and disk space). No need to mention it's annoying to manage the layer size manually, and trying to crop one layer which results cropping the whole image if you don't notice the UI options correctly.

Minimal Student Requirements:

  • Good C knowledge
  • Highly recommended - some knowledge of GIMP's internals (core/tools/etc.)
  • Being a bit familiar with GIMP as a user, as this project touches several areas

Support writing JavaScript plug-ins

Category: Plug-Ins/Scripts

Potential Mentor: Kevin Cozens(?)

GIMP scripts and plug-ins can be written in Scheme, Perl, Python and C. Scheme is always available, but limited in its application in regard on image manipulation. Additionally, as a list-processing language, it may appear as weird to most users. Its main purpose is scripting workflows for repetitive work.

The Perl binding is currently the least supported one and not available on platforms other than Unix. The Python binding and the C libraries are current the most powerful ones.

Javascript could take over Scheme's role as the general purpose scripting language for GIMP. It should be based on GNOME Java Script infrastructure (GJS).

Minimal Student Requirements:

  • Good C knowledge
  • Good JavaScript knowledge
  • Good gObject knowlege
  • Some basic experience with GIMP's PDB (as a plugin/script writer)

Brush selector widget

Category: Tools, User-Interface

Note: this project, although very essential, requires complete UI specs which are not yet present, and therefore is considered less likely to be done, at least untill we have decent UI specs.

More precisely one that is also capable for brush transform input (size/angle/aspect ratio).

When you want to try a brush right now, you go to the canvas, paint on it, and undo that. No need to explain how wrong this is, both for user experience and for productivity. Right now we have options to adjust the size/aspect-ration (strech)/angle/color and some more parameters, which are not shown in the default brush thumbnail preview.

We need to create a widget that previews a brush after applying all of these parameters. We may also want to consider including the "Brush Dynamics" in the preview; "Brush Dynamics" allow mapping parameteres such as speed, tablet pressure/title, velocity and more, to every painting parameter - this allow to simulate many kinds of painting. This should probably be included in the preview by showing a brush stroke which brings all these effects into consideration.

Minimal Student Requirements:

  • Good C knowledge
  • Highly recommended - some knowledge of GIMP's internals (core/tools/etc.)
  • Gtk+/GObject basic knowledge and/or at least some interest in User Interface programming

Slicing tool

Potential mentor: João S. O. Bueno

Category: Tools, User-Interface

Note: this project, although very essential, requires complete UI specs which are not yet present, and therefore is considered less likely to be done, at least untill we have decent UI specs.

One of the most requested features by web designers and/or interface designers, is the addition of a slice tool. Currently slicing images inside GIMP can only be done in grids (using guides and the guillotine action) and you can't split just one rectangle in the middle.

For example, the following slice can not be achieved:

-----------------------------------
|            |                    |
|            |                    |
|            |--------------------|
|            |                    |
-------------|                    |
|            |                    |
-----------------------------------

A more advanced version will take the slicing idea to a new place, allowing to create general rectangles:

-------------------------------------
|          ---------------   ----   |
|          |             |   |  |   |
|          |             |   ----   |
|          ---------------          |
|                               +---+--+
|                               |   |  |
--------------------------------+----  |
                                +------+

And why stop at rectangles? Maybe allow custom shapes using custom paths? Further ideas were suggested in the mailing list, at this post..

Minimal Student Requirements:

  • Good C knowledge
  • Gtk+/GObject knowledge in high level and experience in User Interface programming

IWarp tool (aka Liquify)

Category: Tools

GIMP has a plugin with a small preview which allows to whirl/pinch/grow/shrink parts of the image. We want to create a live on-canvas tool for that operation, like the rest of the core tools.

For details about the original plugin, see http://docs.gimp.org/2.6/en/plug-in-iwarp.html

In order to implement this, in a way that will match the upcoming changes in the core, it will be implemented using a GEGL operation which does the actual image transformation. A big part of the infrastructure for a GEGL based tool, was written in the previous Google Summer of Code in which a cage transformation tool was implemented using a GEGL operation.

Minimal Student Requirements:

  • Good C knowledge
  • Basic knowledge in image manipulation and/or filtering


Adaptive Image Cloning (aka Seamless Cloning)

Category: Tools

Potential Mentor: Michael Natterer

Direct cloning of parts from one image to another, usually ends in bad results because of different lighting conditions and other settings (such as white-balance) which causes the color of the cloned part not to match the source image and look out of place. There are some techniques to solve this, by using poisson equations and some other methods.

It differs from the existing heal tool, since it is meant for taking one area from an image, and paste it smoothly in some other area. The current algorithm implemented by the healing tool allows to remove local irregularities (such as dots, hairs, etc.) very well, but experiments of using it to do "adaptive cloning" of areas (for example copying a person from one image to the other) do not produce good results.

Minimal Student Requirements:

  • Good C knowledge
  • Basic knowledge in image manipulation and/or filtering

See http://www.cs.huji.ac.il/~danix/mvclone/