<div dir="ltr">OK - it's up to you all. If it's doing what you think it should, I'm fine with it.</div><div class="gmail_extra"><br><br><div class="gmail_quote">On Mon, Jul 15, 2013 at 6:28 PM, Aivar Grislis <span dir="ltr"><<a href="mailto:grislis@wisc.edu" target="_blank">grislis@wisc.edu</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
<div bgcolor="#FFFFFF" text="#000000">
<div>
<blockquote type="cite">I believe ImageJ1 treats it [RGBCMY] as
additive. Look at the sample "Organ of Corti" -- the current
behavior of ImageJ2 causes that sample to appear the same as it
does in IJ1. Before we added the bounds-checking code, it
erroneously wrapped pixel values.</blockquote>
By not being additive I meant C is a secondary color composed of
primaries G & B, etc. In the sense of
<a href="http://en.wikipedia.org/wiki/Additive_color" target="_blank">http://en.wikipedia.org/wiki/Additive_color</a> .<br>
<br>
Okay, "Organ of Corti" uses RGBK (and K is even worse than my
example of C since it has all three RGB components not just G
& B) and yet it works as an image. It's useful because the
areas lit up in each channel are fairly distinct. If these areas
overlapped the bounds-checking code would come into play in the
overlapping pixels and some highlights would get squashed and some
colors distorted (when one component is squashed but not the
others). But even if the code did a better job of combining the
colors of overlapping areas you'd still have visual ambiguity in
these areas (since eyes can't distinguish C from G + B). So now
I'm thinking the code works well as is.<br>
<blockquote type="cite">It was intended to be more general than
only the cases Aivar mentioned, and instead provided additive
support for *any* color table per channel you throw at it, the
same as ImageJ1's CompositeImages do.</blockquote>
Sure, it shouldn't crash and burn if you put Fire on one channel
and Ice on another but that's not usable visually unless the areas
lit up in each channel are distinct. If you have a lot of overlap
and you want the colors to add up meaningfully you're better off
sticking with primary additive colors for your channel LUTs.<br>
<br>
On 7/15/13 3:53 PM, Curtis Rueden wrote:<br>
</div>
<blockquote type="cite">
<div dir="ltr">Hi all,
<div><br>
</div>
<div>
<div>> the bigger issue is RGBCMY is not an additive color
system.</div>
</div>
<div><br>
</div>
<div>I believe ImageJ1 treats it as additive. Look at
the sample "Organ of Corti" -- the current behavior of ImageJ2
causes that sample to appear the same as it does in IJ1.
Before we added the bounds-checking code, it erroneously
wrapped pixel values.</div>
<div><br>
</div>
<div>As for the alpha stuff, I will try to digest and
reply soon but I am way too tired at this moment. I just
wanted to clarify why the code is the way it is. It was
intended to be more general than only the cases Aivar
mentioned, and instead provided additive support for *any*
color table per channel you throw at it, the same as ImageJ1's
CompositeImages do.</div>
<div><br>
</div>
<div>Regards,</div>
<div>Curtis</div>
</div>
<div class="gmail_extra"><br>
<br>
<div class="gmail_quote">On Mon, Jul 15, 2013 at 3:46 PM, Aivar
Grislis <span dir="ltr"><<a href="mailto:grislis@wisc.edu" target="_blank">grislis@wisc.edu</a>></span>
wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
<div bgcolor="#FFFFFF" text="#000000">
<div>I think CompositeXYProjector is meant to handle the
following cases:<br>
<br>
1) Rendering LUT images, a single converter is used.
Grayscale images are included here.<br>
<br>
2) Rendering RGB images, three converters are used.
These use red-only, green-only, and blue-only LUTs.<br>
<br>
3) I believe it's also intended to work with images with
> 3 channels, using C, M, and Y for the excess
channels.<br>
<br>
The existing code works well for cases 1 & 2. Case
3 adds the possibility of overflow, if your red
converter gives you a value of 255 for the red component
but your magenta converter adds another 255. Currently
the code just limits the value to 255 in that case.
Some sort of blending might work better here, but the
bigger issue is RGBCMY is not an additive color system.
If you see a cyan blotch you don't know if its in both
the G & B channels or just the C channel.<span><font color="#888888"><br>
<br>
Aivar</font></span>
<div>
<div><br>
<br>
<br>
On 7/15/13 2:40 PM, Lee Kamentsky wrote:<br>
</div>
</div>
</div>
<div>
<div>
<blockquote type="cite">
<div dir="ltr">Thanks for answering Aivar,
<div>
<div class="gmail_extra"><br>
</div>
<div class="gmail_extra">I think what your reply
did for me is to have me take a step back and
consider what we're modeling. If you look at
my replies below, I think that the best
solution is to use a model where the
background is white and each successive layer
filters out some of that background, like a
gel. A layer attenuates the underlying layer
by a fraction of (1 - alpha/255 * (1 -
red/255)), resulting in no attenuation for 255
and attenuation of alpha/255 for zero. We can
then use a red converter that returns a value
of 255 for the blue and green channels and the
model and math work correctly.</div>
<div class="gmail_extra"><br>
<div class="gmail_quote">On Mon, Jul 15, 2013
at 1:59 PM, Aivar Grislis <span dir="ltr"><<a href="mailto:grislis@wisc.edu" target="_blank">grislis@wisc.edu</a>></span>
wrote:<br>
<blockquote class="gmail_quote">
<div>
<div>
<blockquote type="cite">I have an
ImgPlus backed by an RGB PlanarImg
of UnsignedByteType and
ARGBType.alpha(value) is 255 for all
of them, so aSum is 765. It would
appear that the correct solution
would be to divide aSum by 3.</blockquote>
Isn't it unusual to define an alpha
for each color component, generally
you have a single A associated with a
combined RGB? So averaging the three
alphas might make sense here, because
I think they should all be the same
value.<br>
</div>
</div>
</blockquote>
<div>I think you're right, the model always
is that each pixel has an alpha value that
applies to R, G and B. The image I was
using was the Clown example image.
DefaultDatasetView.initializeView
constructs three RealLUTConverters for the
projector, one for red, one for green and
one for blue which sends you down this
rabbit hole.</div>
<blockquote class="gmail_quote">
<div>
<div>
<blockquote type="cite">In addition,
there's no scaling of the individual
red, green and blue values by their
channel's alpha. If the input were
two index-color images, each of
which had different alphas, the code
should multiply the r, g and b
values by the alphas before summing
and then divide by the total alpha
in the end. The alpha in this case
*should* be the sum of alphas
divided by the number of channels.</blockquote>
I think alpha processing is more
cumulative, done layer by layer in
some defined layer order. For a given
pixel say the current output pixel
value is ARGB1 and you are compositing
a second image with value ARGB2 on top
of it: For the red channel the output
color should be ((255 - alpha(ARGB2))
* red(ARGB1) + alpha(ARGB2) *
red(ARGB2)) / 255. The alpha of ARGB1
is not involved.<br>
</div>
</div>
</blockquote>
<div>I think that's a valid interpretation.
I've always used (alpha(ARGB1) *
red(ARGB1) + alpha(ARGB2) * red(ARGB2)) /
(alpha(ARGB1) + alpha(ARGB2)) because I
assumed the alpha indicated the</div>
<div>strength of the blending of each
source. In any case, the code as it stands
doesn't do either of these.</div>
<blockquote class="gmail_quote">
<div>
<div> <br>
In other words, if you add a layer
that is completely opaque you no
longer have to consider any of the
colors or alpha values underneath it. <br>
</div>
</div>
</blockquote>
<blockquote class="gmail_quote">
<div>
<div> <br>
I think the bigger issue here is this
code is specifically designed to
composite red, green and blue image
layers. It's a special case since for
a given pixel the red comes from the
red layer, blue from blue layer, and
green from green layer. These layers
shouldn't be completely opaque, since
the colors wouldn't combine at all
then or completely transparent since
then they wouldn't contribute any
color. I don't think transparency is
useful here.<br>
</div>
</div>
</blockquote>
<div>So this is an argument for blending
instead of layering - transparency would
be useful if the images were blended and
treated as if on a par with each other,
allowing the user to emphasize one channel
or the other. </div>
<blockquote class="gmail_quote">
<div>
<div> <br>
It's also possible that a multichannel
image with > 3 channels is being
displayed with more color channels,
namely cyan, magenta, and yellow. The
code here is designed to stop
overflow, but I'm not convinced those
extended color channels would combine
meaningfully.<br>
<br>
Aivar<br>
<br>
<blockquote type="cite">In addition,
there's no scaling of the individual
red, green and blue values by their
channel's alpha. If the input were
two index-color images, each of
which had different alphas, the code
should multiply the r, g and b
values by the alphas before summing
and then divide by the total alpha
in the end. The alpha in this case
*should* be the sum of alphas
divided by the number of channels.</blockquote>
I think alpha processing is cumulative
layer by layer. <br>
<br>
This brings up some interesting
questions:<br>
<br>
1) If the first, bottom-most layer is
transparent, what color should show
through? Black, white? Or perhaps
it's best to ignore this base layer
transparency.<br>
</div>
</div>
</blockquote>
<div>Maybe the model should be that the
background is white and successive layers
are like gel filters on top. In that case,
you'd have:</div>
<div> red = (255 - alpha(ARGB2) *(255 -
red(ARGB2))/255) * red(ARGB1) </div>
<div><br>
</div>
<div>And maybe that points to what the true
solution is. For the default, we could
change things so that red channel would
have blue = 255 and green = 255 and the
first composition would change only the
red channel.</div>
<blockquote class="gmail_quote">
<div>
<div> <br>
2) If you wanted to composite several
transparent images, how do you
calculate the transparency of the
composite? I'm not sure this is
something we need to do.<br>
<br>
Aivar<br>
<br>
<br>
On 7/15/13 10:31 AM, Lee Kamentsky
wrote:<br>
</div>
<blockquote type="cite">
<div dir="ltr">
<div>Hi all, </div>
<div>I'm looking at the code for
net.imglib2.display.CompositeXYProjector
and as I step through it, it's
clear that the alpha calculation
isn't being handled correctly.
Here's the code as it stands now,
line 190 roughly:</div>
<div><br>
</div>
<div><span> </span>for ( int i = 0;
i < size; i++ )</div>
<div><span> </span>{</div>
<div><span> </span>sourceRandomAccess.setPosition(
currentPositions[ i ], dimIndex );</div>
<div><span> </span>currentConverters[
i ].convert(
sourceRandomAccess.get(), bi );</div>
<div><span> </span>// accumulate
converted result</div>
<div><span> </span>final int value
= bi.get();</div>
<div><span> </span>final int a =
ARGBType.alpha( value );</div>
<div><span> </span>final int r =
ARGBType.red( value );</div>
<div><span> </span>final int g =
ARGBType.green( value );</div>
<div><span> </span>final int b =
ARGBType.blue( value );</div>
<div><span> </span>aSum += a;</div>
<div><span> </span>rSum += r;</div>
<div><span> </span>gSum += g;</div>
<div><span> </span>bSum += b;</div>
<div><span> </span>}</div>
<div><span> </span>if ( aSum >
255 )</div>
<div><span> </span>aSum = 255;</div>
<div><span> </span>if ( rSum >
255 )</div>
<div><span> </span>rSum = 255;</div>
<div> <span> </span>if ( gSum >
255 )</div>
<div><span> </span>gSum = 255;</div>
<div><span> </span>if ( bSum >
255 )</div>
<div><span> </span>bSum = 255;</div>
<div><span> </span>targetCursor.get().set(
ARGBType.rgba( rSum, gSum, bSum,
aSum ) );</div>
<div><br>
</div>
<div>I have an ImgPlus backed by an
RGB PlanarImg of UnsignedByteType
and ARGBType.alpha(value) is 255
for all of them, so aSum is 765.
It would appear that the correct
solution would be to divide aSum
by 3. In addition, there's no
scaling of the individual red,
green and blue values by their
channel's alpha. If the input were
two index-color images, each of
which had different alphas, the
code should multiply the r, g and
b values by the alphas before
summing and then divide by the
total alpha in the end. The alpha
in this case *should* be the sum
of alphas divided by the number of
channels.</div>
<div><br>
</div>
<div>However, I think the problem is
deeper than that. For an RGB
ImgPlus, there are three LUTs and
each of them has an alpha of 255,
but that alpha only applies to one
of the colors in the LUT. When
you're compositing images and
weighing them equally, if two are
black and one is white, then the
result is 1/3 of the white
intensity - if you translate that
to red, green and blue images, the
resulting intensity will be 1/3 of
that desired. This might sound
weird, but the only solution that
works out mathematically is for
the defaultLUTs in the
DefaultDatasetView to use color
tables that return values that are
3x those of ColorTables.RED, GREEN
and BLUE. Thinking about it, I'm
afraid this *is* the correct model
and each channel really is 3x
brighter than possible.</div>
<div><br>
</div>
<div>It took me quite a bit of back
and forth to come up with the
above... I hope you all understand
what I'm saying and understand the
problem and counter-intuitive
solution and have the patience to
follow it. Dscho, if you made it
this far - you're the
mathematician, what's your take?</div>
<div><br>
</div>
<div>--Lee</div>
</div>
<br>
<fieldset></fieldset>
<br>
<pre>_______________________________________________
ImageJ-devel mailing list
<a href="mailto:ImageJ-devel@imagej.net" target="_blank">ImageJ-devel@imagej.net</a>
<a href="http://imagej.net/mailman/listinfo/imagej-devel" target="_blank">http://imagej.net/mailman/listinfo/imagej-devel</a>
</pre>
</blockquote>
<br>
</div>
<br>
_______________________________________________<br>
ImageJ-devel mailing list<br>
<a href="mailto:ImageJ-devel@imagej.net" target="_blank">ImageJ-devel@imagej.net</a><br>
<a href="http://imagej.net/mailman/listinfo/imagej-devel" target="_blank">http://imagej.net/mailman/listinfo/imagej-devel</a><br>
<br>
</blockquote>
</div>
<br>
</div>
</div>
</div>
</blockquote>
<br>
</div>
</div>
</div>
<br>
_______________________________________________<br>
ImageJ-devel mailing list<br>
<a href="mailto:ImageJ-devel@imagej.net" target="_blank">ImageJ-devel@imagej.net</a><br>
<a href="http://imagej.net/mailman/listinfo/imagej-devel" target="_blank">http://imagej.net/mailman/listinfo/imagej-devel</a><br>
<br>
</blockquote>
</div>
<br>
</div>
</blockquote>
<br>
</div>
</blockquote></div><br></div>