After some discussions it seems that using GEGL for display filters,.
and other color management issues involving lcms might be a good idea.
Does the people with code checked into GEGL have any opinon on this
approach?

/Øyvind K.

---
Ramblings follow:

We will work on a sample color image, called in.tif, the color management
directly touching the image are the following operations:

1) loading the image
2) displaying the image
3) saving/exporting image

lcms should be used for the actual transformations,. some transformations we
do manually, for instance conversion between guchar8, guint16 and gfloat.

                                     .----> lcms --->  display
                                    /
                                   /
in.tif -> lcms -> gimp does foo --<
                                   \
                                    \
                                     `----> lcms --->  out.tif




The three operations again, as GEGL graphs, having the actual file
savers/loaders
and the lcms operation as GEGL ops.

1) loading the image
   
.-----------------------.   .---------------------.   .---.
|load_tif               |   |lcms                 |   |foo|
|  resource = "in.tif"  |-->|  in_profile='CMYK'  |-->|   | -=> gimp drawable
|                       |   |  out_profile='rgb8' |   |   |
`-----------------------'   `---------------------'   `---'

2) saving the image

               .---.   .-----------------------.   .---------------------.
               |bar|   |lcms                   |   |save_tif             |
gimpdrawable-=>|   |-->|  in_profile='rgb8'    |-->|  resource='out.tif' |
               |   |   |  out_profile='cieLAB' |   |                     |
               `---'   `-----------------------'   `---------------------'

3) displaying the image

                  .---.   .-----------------------.   .---.
                  |bar|   |lcms                   |   |foo| 
gimp drawable -=> |   |-->|  in_profile='rgb8'    |-->|   | -=> gimp drawable
                  |   |   |  out_profile='crt.icc'|   |   |
                  `---'   `-----------------------'   `---'


bar is to transform from gimps image representation to GEGLs, and foo
is the opposite.


Choosing a gimp image representation to work with:
==================================================

To ease the process, using an as simple as possible gimp image
representation as the inputs
and outputs of foo and bar would be needed, using tiles directly,
means we deal with a linear
buffer. This will cause som extra code in gimp, but it means we can
happily coexist with
exsisting tile based code. This only works well for point operations,
and not for area
operations like blur. Thus:

gimptile_read

and

gimptile_write

are would be the initial point of contact between gimp and gegl.

Special code to apply a processing graph to all tiles in an image
would be needed then,
a convenience function should be made. An ideal property interface to
lcms needs to be
found.




-- 
Software patents hinder progress | http://swpat.ffii.org/ 
Web :  http://pippin.gimp.org/
_______________________________________________
Gimp-developer mailing list
Gimp-developer@lists.xcf.berkeley.edu
http://lists.xcf.berkeley.edu/mailman/listinfo/gimp-developer

Reply via email to