Colin Bennett wrote:
Hello,
I'm a Linux hacker and GIMP user and am interested in helping out on GEGL. I had
two main questions:
1. What is it really going to take to integrate GEGL into the GIMP? Is it
something that might happen this year? Next year? GIMP 2.2? What are the steps
it's going to take to integrate?
I've outlined this elsewhere. I'll attach my notes at the bottom.
I really, really want 16+ bit color and adjustment layers. Sometimes I almost
feel like wiping out Linux and installing WinXP and Photoshop... :-(
2. Where can I help out on GEGL? I've done quite a bit of graphics programming
in Java (recently) and C/C++/assembly (back in the Good Old DOS days). I have
lots of experience with unit tests and mock objects (the company I worked at
for several year specialized in Extreme Programming).
Ok . .. Great! Have you done JAI programming. I am taking some
inspiration from that particular library. The current things I need
help with are building a colorspace conversion interface (this will
require lcms), a tile interator, and a multi-tile gegl image class. I
could also use more extensive tests of gegl-buffer with using an on disk
cache system. I have an implementation of GeglTile, which I can give
you diff if you are interested. I kinda got real busy with life and
took a break, but just last week started putting time into gegl agagin.
Your timing is imppecable
I checked out CVS and was very glad to see that everything built smoothly and
the tests ran perfectly. I'll be browsing the code and the docs a little but it
I can have some idea of what kinds of tasks I could help with, I'd have a place
to focus on in greater depth.
Currently there are the beginings of a generic image data access library
in gegl/gegl/image. In gegl/gegl is the remenents of the old data
access library and the tree construction code, which afaik works, but is
not connected to the generic image data access stuff. I know exactly
what needs to be done to finish the gegl iamge library, the big blocker
being that I haven't had time to put into it until very recently.
The most effective you could be would be to start with (one of)
tile-iterator, color-model, and color-space. I can give you a diff
against head which will have headers for those classes but be lacking in
implementation. I also have oodles of notes on how I thought it should
be done, but feel free to think of a better way. I am more than happy
to do anything I can to help you along.
Here is what I outlined a few months ago on what needs to be done:
1. Finish gegl/image
() Goal: gegl/image is the directory that holds the data access
libraries. It should contain the abstractions for high-bit-depth and
multiple color space manipulations.
-- a. finish up my nearly completed tile caching code
-- b. implement color space classes
-- c. write gegl-image and gegl-color
2. clean up nodes
() Goal: This will bring gegl all together. Modify the existing
node system to handle the new image data types, and get a strong core of
basic image processing nodes. Also, build a few image i/o nodes and
actually build one or two gegl test programs that actually manipulate
image data. One might argue that this step would "finish" gegl.
-- a. make nodes work with the new gegl-image stuff
-- b. design processing model that can handle multiple data types and
sample models
-- c. implement the base set of core filters
-- d. implement different bit depth processing functions
(prioritizing by what the gimp needs)
-- e. make gegl work
3. begin gimp integration
() Goal: This puts abstraction in place to actually start handling
image high bit depth and color management.
-- a. replace tile manager with data compatible GeglBufferedImage.
This involves modifying the existing gimp-compositing system to use
GeglImage, as well as modifying GimpImage and GimpColor to use GeglImage
and GeglColor.
4. start adding deep paint
() Goal: to start allowing The GIMP to handle high bit depths. The
initial integration should not take long, but I foresee unforeseen
problems, so I am setting this estimate high.
-- a. modify GimpImage and GimpLayer to use a set of GeglOps.
-- b. design a new file format (this has already begun).
-- d. convert the core (including paint) to high-bit depth.
-- e. convert the plugins to high-bit depth
5. The big ones
() Goal: start adding some long wanted features. a and b
probably need to take place at the same time.
-- a. build the CMYK painting system. This will involve figuring
out all the equivalent CMYK and RGB operations, and modifying the
GIMP to use CYMK equivalent operations in place of RGB operations.
-- b. add color management to the gui.
-- c. add layer effects
-- d. add layer groups.
-- e. add clone layers.
