Ramblings and Congrats

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

First off I wanted to say that I have mixed feelings about this project because
I was gearing up to try and start my own open source project to basically create
a domain specific image processing language with dynamic processing etc... So I
am sad that this one exists but also really happy because it appears to have a
larger scope than my original project did.

I just wanted to ask some questions out of laziness, make some comments, and
congratulate you.

I am going to ask this because I haven't dug through the code yet: I was
wondering do you have the ability to reduce a series of arithmetic operations
into the smallest necessary subset of operations required? (image+3 then image+4
should be image+7) This is one of the steps I know a compiler does but I wanted
to find a open source library that accomplished just that feat. (I didn't want
to have to rip it out of gcc in some ugly way.) Did you find such a thing? (I
was worried about doing this for floating point operations where I know there
are a considerable amount of idiosyncrasies that make it a hard problem.) 

The other question I had (out of laziness of not wanting to do a lot of
research) is: Why is there GeglOperationPointComposer in addition to
GeglOperationComposer? Can't that information be determined at runtime? Without
thinking about it too much, this seems to unnecessarily over-complicate your 

Last lazy question: It there the capability to compile code from your
"language". Or do you see the overhead of compiling as inconsequential compared
to the gains of the more intelligent processing your algorithms? I ask this
because my language supported convolutions and when you compiled my code I was
going to put all of the convolution kernels into frequency space and
pre-multiply the consecutive ones. Doing this would save a substantial amount of
processing at runtime. (Especially if you simply want to apply the same set of
operations to a large number of files.)

One thing I wanted to do for my project was to allow what I called "dynamic
operations" which basically just meant that I would hand them some information
and they could push more operations onto my operation stack at runtime. It was
also going to be scoped so that if you asked for information from the whole
image you would be able to edit the operation stack for all the pixels in the
image but if you received information from a region or a single pixel then you
would only be able to edit the stack for those pixels. I was worried that having
a separate stack for each pixel might generate quite a bit of overhead so I was
considering limiting it to only have whole image dynamic image operations but I
still think it is a useful operation. 

In that same vein I was wondering if it would be possible so generate image
statistics as you were applying another operation to an image. Basically if I
have operation X but if I apply a getImageStatistics operation right after it
then it might be more efficient to obtain those statistics for each pixel
immediately after the previous operation is applied, while the pixel value is
still in the cache. (Sorry, that statement is confusing.) 

If you really want this project to use efficiently use multiple machines you
should look at ZPL. It looks like this project has stopped being developed but
it might provide some insight to the challenges ahead:

By the way, congratulations! This looks like it is going to be an amazing
project. I hope to help in some small capacity. 

Gegl-developer mailing list

[Video For Linux]     [Photo]     [Yosemite News]    [Yosemite Photos]    [gtk]     [GIMP Users]     [KDE]     [Scanner]     [Gimp's Home]     [Gimp on Windows]     [Steve's Art]     [Webcams]