Do you have a more "presence oriented," transient form of communication
I could use to get ahold of you (like an IRC channel where you hang, or
AIM or ICQ etc)?
I want to pick your brain on some of your ideas about gegl.
It is unclear to me why we want to generalize the graph so that we can
pass non-image data types. It seems like a tremendous amount of
increased complexity for little potential benefit to an image processing
library.
I do see that it has numerous theoretical advantages. Obviously being
able to treat images just like anything else is pretty spiffy. However
I am finding it difficult to come up with many situation where you want
to pass non-image data in the same way you pass image data along the
processing graph. Let me try to explain what I mean:
There are several situations where you might produce non-image data; we
have graced these in the past, but here are the concrete examples I can
think of at the moment: histograms, fractal measures, euclid numbers,
image meta-info, and various numbers from image segmentation.
These are all good, but the infrastructure in place to generalize data
is there to _move data between nodes_. I can't see any reason why, in
an image processing specific context, we would need to pass various
non-image pieces of data between the nodes (with the sole exceptions of
image meta-data which should come in and out of file nodes).
Now, one could argue that you could generalize gegl's architecture to
allow nodes that process non-images, but then gegl moves away from an
"image processing library" to a "processing everything under the sun"
library, adding yet more complexity, and getting further away from
gegl's goal of being a good image processing library (under the premise
that you can do something specific better than you can do everything
generally).
This really starts to hit you when you need to generalize ImageProducer
and ImageConsumer so that you have producers and consumers for every
data type. What is the point of this when you are ever really going to
pass those data types through the graph?
An alternate solution:
Focus on passing only images (which are containers of channels (a
container of samples) and of pixels (another contianer of samples))
though the graph, and force nodes to get all their parameters directly
from within their nodes. This will greatly simplify the implementation
of things like: GeglData, GeglDataProducer, GeglDataConsumer, GeglNode,
GeglOp, and all op functions. It will simplify verify_inputs,
verify_outputs. AFAIK, most of these functions kinda assume that only
images are inputs and outputs anyway, so it isn't much of a leap from
what we have now, but it gives more focus, and allows removing a lot of
code that currently checks to make sure things are images (even though
they aready must be). Things will be faster, cleaner, simpler, smaller
and without sacrificing our goal of becoming an image processing library.
Since there is an obvious need to get non-image results out of the graph
(without passing it within the graph), come up with an api for
retrieving the non-image data from the nodes. (this may be unnecessary.
It may be enough to provide guidelines for the api the nodes use to
access data).
--
Dan
