LUT with bin size of 1

[Daddymoen]

Is there a way to create a LUT file that has a bin size of 1?  Each value in my .TIFF image file would have its own JPEG color it the final image.  I am making progress on my restarted Digital Phantom Leaf Photography project and such a LUT would be very useful.

Thankx

Daddymoen

[ctrueden]

Hi Daddymoen,

> Is there a way to create a LUT file that has a bin size of 1?

What do you mean by a "bin size of 1"? ImageJ LUTs have 256 bins, which map
an 8-bit intensity range to (R,G,B) triples.

If you want a LUT where adjacent colors are as different as possible, try
Fiji's Glasbey LUT:
    http://fiji.sc/Glasbey

You can design your own LUT using the Edit LUT... command in the Image >
Color menu. Or you can edit a text LUT in your favorite text editor. Just
copy the template of an existing LUT such as:
    https://github.com/fiji/fiji/blob/master/luts/glasbey.lut

Regards,
Curtis


On Tue, May 7, 2013 at 11:27 PM, Daddymoen <[hidden email]> wrote:

> Is there a way to create a LUT file that has a bin size of 1?  Each value
> in
> my .TIFF image file would have its own JPEG color it the final image.  I am
> making progress on my restarted Digital Phantom Leaf Photography project
> and
> such a LUT would be very useful.
>
> Thankx
>
> Daddymoen
>
>
>
> --
> View this message in context:
> http://imagej.1557.x6.nabble.com/LUT-with-bin-size-of-1-tp5002951.html
> Sent from the ImageJ mailing list archive at Nabble.com.
>
> --
> ImageJ mailing list: http://imagej.nih.gov/ij/list.html
>

--
ImageJ mailing list: http://imagej.nih.gov/ij/list.html

[Daddymoen]

Curtis,

Thanks for your reply, the LUT you gave the link to will be useful.

In my project I am converting  my  camera sensor intensity values (a range of 0 to 1024) in a .Tiff file  to an RGB .jpg image,   I am only interested in applying the LUT coloring over a small range of image values, perhaps a range of 75 to 100 intensity values.  The LUT needs to display subtle variations within this narrow range of values.  Ideally, each individual intensity value will have its own, color.  But, since the image has 1024 total individual values, and the LUT has only 256 colors, the image has 4 times as many values as the LUT has colors. in this case   When the LUT is applied to my image the LUT has, essentially,  256 "bins" that each containing  consecutive four intensity values.  Each of these four individual intensity values will be displayed as the same color.  So, if I'm trying to display subtle differences (such as single intensity value changes) these "four value wide bins" severely limit display of subtle features in my image data.

What I'm looking for is a way to control the size of these LUT bins.  For example in a typical image I use, Intensity values from, say, 0 to 500 are of no interest.  If I could control LUT bin size I'd make fist bin contain intensity values form 0 to 500 and color them all black.. The intensity values between, say, from 501 and 575 are of interest, I'd make each of the bins hold only one value, each value with its own color.  Values from 576 to 1023 (in this example) are again of no interest, so the last bin in the LUT could contain all those values and also be colored black.

So, I guess what I am really looking for is control of the LUT bin sizes.  I hope all that didn't add to the confusion :d)

Daddymoen

[Kenneth Sloan-2]

You need to "window" the gray levels.

a) start with a [0,1023] image
b) choose a range of interesting gray values (say, [500,600] - you said you
   only need 75-100 distinct values
c) create a 256-level image ([0,255]) by mapping:

    0…450 -> 0
    451 -> 1
    452 -> 2
    …
    704 -> 254
    705…1023 -> 255
d) convert this [0,255] image to 8-bit
e) use your favorite 8-bit LUT

The main issue is that you need to create a separate image, and convert each pixel individually.
If you can do this quickly enough (depending on the dimensions of your images and the power of your particular hardware), it is feasible to write a plug-in that will go directly from
your [0,1023] 16-bit image to an RGB image.  This would not be a difficult plug-in to write.
It could (of course?) be written to handle the full range of 16-bit values.

If I were doing this, I think I would write a 16-bit -> 8-bit plug-in that allowed some flexibility in mapping
[0,16384} -> [0,255], and then use the standard 8-bit LUT mechanism to color the 8-bit image.  

I would be surprised to learn that no one has written such a plug-in, yet, but, if so, I am ignorant of it.

Let's see…I think the interface might be:
        min, max - range of the window

and the behavior would be to map:
         0…min     -> 0
         min…max   -> 0…255
         max…16384 -> 255

--
Kenneth Sloan
[hidden email]


On May 8, 2013, at 17:50 , Daddymoen <[hidden email]> wrote:

> Curtis,
>
> Thanks for your reply, the LUT you gave the link to will be useful.
>
> In my project I am converting  my  camera sensor intensity values (a range
> of 0 to 1024) in a .Tiff file  to an RGB .jpg image,   I am only interested
> in applying the LUT coloring over a small range of image values, perhaps a
> range of 75 to 100 intensity values.  The LUT needs to display subtle
> variations within this narrow range of values.  Ideally, each individual
> intensity value will have its own, color.  But, since the image has 1024
> total individual values, and the LUT has only 256 colors, the image has 4
> times as many values as the LUT has colors. in this case   When the LUT is
> applied to my image the LUT has, essentially,  256 "bins" that each
> containing  consecutive four intensity values.  Each of these four
> individual intensity values will be displayed as the same color.  So, if I'm
> trying to display subtle differences (such as single intensity value
> changes) these "four value wide bins" severely limit display of subtle
> features in my image data.
>
> What I'm looking for is a way to control the size of these LUT bins.  For
> example in a typical image I use, Intensity values from, say, 0 to 500 are
> of no interest.  If I could control LUT bin size I'd make fist bin contain
> intensity values form 0 to 500 and color them all black.. The intensity
> values between, say, from 501 and 575 are of interest, I'd make each of the
> bins hold only one value, each value with its own color.  Values from 576 to
> 1023 (in this example) are again of no interest, so the last bin in the LUT
> could contain all those values and also be colored black.
>
> So, I guess what I am really looking for is control of the LUT bin sizes.  I
> hope all that didn't add to the confusion :d)
>
> Daddymoen
>
>
>
> --
> View this message in context: http://imagej.1557.x6.nabble.com/LUT-with-bin-size-of-1-tp5002951p5002956.html
> Sent from the ImageJ mailing list archive at Nabble.com.
>
> --
> ImageJ mailing list: http://imagej.nih.gov/ij/list.html

--
ImageJ mailing list: http://imagej.nih.gov/ij/list.html

[Stephan Saalfeld]

Hi Kenneth,

> [...]
> Let's see…I think the interface might be:
>         min, max - range of the window
>
> and the behavior would be to map:
>          0…min     -> 0
>          min…max   -> 0…255
>          max…16384 -> 255
>

isn't that exactly what is happening in ImageJ when you assign a LUT to
a 16bit image and change its min and max (B&C)?

Unfortunately, ImageJ doesn't save the LUT with a TIFF image so, for
visualization purposes, you would have to save the image as RGB.

Best,
Stephan

>
> On May 8, 2013, at 17:50 , Daddymoen <[hidden email]> wrote:
>
> > Curtis,
> >
> > Thanks for your reply, the LUT you gave the link to will be useful.
> >
> > In my project I am converting  my  camera sensor intensity values (a range
> > of 0 to 1024) in a .Tiff file  to an RGB .jpg image,   I am only interested
> > in applying the LUT coloring over a small range of image values, perhaps a
> > range of 75 to 100 intensity values.  The LUT needs to display subtle
> > variations within this narrow range of values.  Ideally, each individual
> > intensity value will have its own, color.  But, since the image has 1024
> > total individual values, and the LUT has only 256 colors, the image has 4
> > times as many values as the LUT has colors. in this case   When the LUT is
> > applied to my image the LUT has, essentially,  256 "bins" that each
> > containing  consecutive four intensity values.  Each of these four
> > individual intensity values will be displayed as the same color.  So, if I'm
> > trying to display subtle differences (such as single intensity value
> > changes) these "four value wide bins" severely limit display of subtle
> > features in my image data.
> >
> > What I'm looking for is a way to control the size of these LUT bins.  For
> > example in a typical image I use, Intensity values from, say, 0 to 500 are
> > of no interest.  If I could control LUT bin size I'd make fist bin contain
> > intensity values form 0 to 500 and color them all black.. The intensity
> > values between, say, from 501 and 575 are of interest, I'd make each of the
> > bins hold only one value, each value with its own color.  Values from 576 to
> > 1023 (in this example) are again of no interest, so the last bin in the LUT
> > could contain all those values and also be colored black.
> >
> > So, I guess what I am really looking for is control of the LUT bin sizes.  I
> > hope all that didn't add to the confusion :d)
> >
> > Daddymoen
> >
> >
> >
> > --
> > View this message in context: http://imagej.1557.x6.nabble.com/LUT-with-bin-size-of-1-tp5002951p5002956.html
> > Sent from the ImageJ mailing list archive at Nabble.com.
> >
> > --
> > ImageJ mailing list: http://imagej.nih.gov/ij/list.html
>
> --
> ImageJ mailing list: http://imagej.nih.gov/ij/list.html

--
ImageJ mailing list: http://imagej.nih.gov/ij/list.html

[Kenneth Sloan-2]

Could be,  I don't know.  There are a lot  of nooks and crannies if ImageJ which remain a mystery to me.  Mostly because I tend to go straight to a Java solution.

The limitation of LUTs to 8 bits has always struck me as quaint; I was using 12-bit LUTs in 1980 (see my paper on "Color Map Techniques".)

In this day and age, I think we ought to have support for 16-bit LUTs.

As for "not saving", that's really a TIFF design issue and ImageJ can't do much about it.  Again, I am ignorant about current TIFF capabilities, so thus may well be feasible.

-Kenneth Sloan
(von meinem iPhone4S gesendet)

On May 9, 2013, at 2:39, Stephan Saalfeld <[hidden email]> wrote:

> Hi Kenneth,
>
>> [...]
>> Let's see…I think the interface might be:
>>        min, max - range of the window
>>
>> and the behavior would be to map:
>>         0…min     -> 0
>>         min…max   -> 0…255
>>         max…16384 -> 255
>
> isn't that exactly what is happening in ImageJ when you assign a LUT to
> a 16bit image and change its min and max (B&C)?
>
> Unfortunately, ImageJ doesn't save the LUT with a TIFF image so, for
> visualization purposes, you would have to save the image as RGB.
>
> Best,
> Stephan
>
>>
>> On May 8, 2013, at 17:50 , Daddymoen <[hidden email]> wrote:
>>
>>> Curtis,
>>>
>>> Thanks for your reply, the LUT you gave the link to will be useful.
>>>
>>> In my project I am converting  my  camera sensor intensity values (a range
>>> of 0 to 1024) in a .Tiff file  to an RGB .jpg image,   I am only interested
>>> in applying the LUT coloring over a small range of image values, perhaps a
>>> range of 75 to 100 intensity values.  The LUT needs to display subtle
>>> variations within this narrow range of values.  Ideally, each individual
>>> intensity value will have its own, color.  But, since the image has 1024
>>> total individual values, and the LUT has only 256 colors, the image has 4
>>> times as many values as the LUT has colors. in this case   When the LUT is
>>> applied to my image the LUT has, essentially,  256 "bins" that each
>>> containing  consecutive four intensity values.  Each of these four
>>> individual intensity values will be displayed as the same color.  So, if I'm
>>> trying to display subtle differences (such as single intensity value
>>> changes) these "four value wide bins" severely limit display of subtle
>>> features in my image data.
>>>
>>> What I'm looking for is a way to control the size of these LUT bins.  For
>>> example in a typical image I use, Intensity values from, say, 0 to 500 are
>>> of no interest.  If I could control LUT bin size I'd make fist bin contain
>>> intensity values form 0 to 500 and color them all black.. The intensity
>>> values between, say, from 501 and 575 are of interest, I'd make each of the
>>> bins hold only one value, each value with its own color.  Values from 576 to
>>> 1023 (in this example) are again of no interest, so the last bin in the LUT
>>> could contain all those values and also be colored black.
>>>
>>> So, I guess what I am really looking for is control of the LUT bin sizes.  I
>>> hope all that didn't add to the confusion :d)
>>>
>>> Daddymoen
>>>
>>>
>>>
>>> --
>>> View this message in context: http://imagej.1557.x6.nabble.com/LUT-with-bin-size-of-1-tp5002951p5002956.html
>>> Sent from the ImageJ mailing list archive at Nabble.com.
>>>
>>> --
>>> ImageJ mailing list: http://imagej.nih.gov/ij/list.html
>>
>> --
>> ImageJ mailing list: http://imagej.nih.gov/ij/list.html
>
> --
> ImageJ mailing list: http://imagej.nih.gov/ij/list.html

--
ImageJ mailing list: http://imagej.nih.gov/ij/list.html

[Daddymoen]

Kenneth,

I can work on figuring out how to do the windowing approach in a macro, thanks for pointing me in that direction..  It looks likes this approach will give the level of subtle detail my project needs.

Your preferred way of doing this, a plugin with some windowing flexibility, is the kind of approach I've been trying to find in many, many hours of Google searches. They either don't exist or I'm not using the right search keywords to find them.  Not finding anything like it, I've been trying to come close using a macro approach as I don't speak the Java programming language at all.  I speak barely enough C++ to have been able to create plugins using FilterMeister with Photoshop to make any progress at all on my project.  ImageJ is far more capable of handling 16-bit images than my very old version of PhotoShop.  So, since ImageJ macros are easier to learn to write than Java plugins, I work at using macros.  But macros are slow and clunky working with large images.

A plugin that allowed the windowing of 16-bit pixel values to focus on my values of interest and then using a LUT to pseudocolor a resulting 8-bit image could be ideal.  I could then window my 16-bit data to the values of interest in within my 1024 total number of possible values:
    0…450 -> 0
    451 -> 1  
    452 -> 2  
    …
    704 -> 254  
    705…16384 -> 255  

Then this 16-bit image data could be converted to 8-bit image data and my favorite LUT could then be applied.  I be happier than a pig at a salad bar!
 
[ Just as a side note:
I begin with my Canon G2, raw image and use DCRaw ( -v -D -4 -T) convert it without interpolation to a 16-bit .TIFF file.  The Canon G2 sensor is only 10-bit, hence the total of 1024 values.  I then split this image into four, half size images R, G1, G2, B using a macro I found on this Forum.  It is these half size, 16-bit images I need to pseudocolor.  If I had my choice a plugin would be able to handle 16-bit (16348 values) images so other folks with newer, better cameras can use the plugin to explore Digital Phantom Leaf Photography on their own. ]

Thanks for your help Kenneth.  If you get a hankering to write a plugin for this I'd be happy to beta test it ;d)

Daddymoen

[Stephan Saalfeld]

Daddymoen,

can you please try whether the following macro:

setMinAndMax(450, 705);
run("Fire");
run("RGB Color");

just does what you had in mind?

Best,
Stephan



On Thu, 2013-05-09 at 08:53 -0700, Daddymoen wrote:

> Kenneth,
>
> I can work on figuring out how to do the windowing approach in a macro,
> thanks for pointing me in that direction..  It looks likes this approach
> will give the level of subtle detail my project needs.
>
> Your preferred way of doing this, a plugin with some windowing flexibility,
> is the kind of approach I've been trying to find in many, many hours of
> Google searches. They either don't exist or I'm not using the right search
> keywords to find them.  Not finding anything like it, I've been trying to
> come close using a macro approach as I don't speak the Java programming
> language at all.  I speak barely enough C++ to have been able to create
> plugins using FilterMeister with Photoshop to make any progress at all on my
> project.  ImageJ is far more capable of handling 16-bit images than my very
> old version of PhotoShop.  So, since ImageJ macros are easier to learn to
> write than Java plugins, I work at using macros.  But macros are slow and
> clunky working with large images.
>
> A plugin that allowed the windowing of 16-bit pixel values to focus on my
> values of interest and then using a LUT to pseudocolor a resulting 8-bit
> image could be ideal.  I could then window my 16-bit data to the values of
> interest in within my 1024 total number of possible values:
>     0…450 -> 0
>     451 -> 1  
>     452 -> 2  
>     …
>     704 -> 254  
>     705…16384 -> 255  
>
> Then this 16-bit image data could be converted to 8-bit image data and my
> favorite LUT could then be applied.  I be happier than a pig at a salad bar!
>  
> [ Just as a side note:
> I begin with my Canon G2, raw image and use DCRaw ( -v -D -4 -T) convert it
> without interpolation to a 16-bit .TIFF file.  The Canon G2 sensor is only
> 10-bit, hence the total of 1024 values.  I then split this image into four,
> half size images R, G1, G2, B using a macro I found on this Forum.  It is
> these half size, 16-bit images I need to pseudocolor.  If I had my choice a
> plugin would be able to handle 16-bit (16348 values) images so other folks
> with newer, better cameras can use the plugin to explore Digital Phantom
> Leaf Photography on their own. ]
>
> Thanks for your help Kenneth.  If you get a hankering to write a plugin for
> this I'd be happy to beta test it ;d)
>
> Daddymoen
>
>
>
>
> --
> View this message in context: http://imagej.1557.x6.nabble.com/LUT-with-bin-size-of-1-tp5002951p5002961.html
> Sent from the ImageJ mailing list archive at Nabble.com.
>
> --
> ImageJ mailing list: http://imagej.nih.gov/ij/list.html

--
ImageJ mailing list: http://imagej.nih.gov/ij/list.html

[BenTupper]

On May 9, 2013, at 11:53 AM, Daddymoen wrote:

> Kenneth,
>
> I can work on figuring out how to do the windowing approach in a macro,
> thanks for pointing me in that direction..  It looks likes this approach
> will give the level of subtle detail my project needs.
>
> Your preferred way of doing this, a plugin with some windowing flexibility,
> is the kind of approach I've been trying to find in many, many hours of
> Google searches. They either don't exist or I'm not using the right search
> keywords to find them.  Not finding anything like it, I've been trying to
> come close using a macro approach as I don't speak the Java programming
> language at all.  I speak barely enough C++ to have been able to create
> plugins using FilterMeister with Photoshop to make any progress at all on my
> project.  ImageJ is far more capable of handling 16-bit images than my very
> old version of PhotoShop.  So, since ImageJ macros are easier to learn to
> write than Java plugins, I work at using macros.  But macros are slow and
> clunky working with large images.
>
> A plugin that allowed the windowing of 16-bit pixel values to focus on my
> values of interest and then using a LUT to pseudocolor a resulting 8-bit
> image could be ideal.  I could then window my 16-bit data to the values of
> interest in within my 1024 total number of possible values:
>    0…450 -> 0
>    451 -> 1  
>    452 -> 2  
>    …
>    704 -> 254  
>    705…16384 -> 255  
>
> Then this 16-bit image data could be converted to 8-bit image data and my
> favorite LUT could then be applied.  I be happier than a pig at a salad bar!
>

What you are describing can be done with a function like locate() in Numerical Recipes, "How to search and Ordered Table"  http://apps.nrbook.com/c/index.html  It's is know as Value_Locate() in IDL and findInterval() in R - I'm sure it available for a lot of other languages.  Given the LUT (in your case {451,452,...,704}) the function will determine which "bin" within the LUT your pixel falls.  This is handy for remapping pixels values to 'category' or bin values.

locate(LUT, 449) --> 0
locate(LUT, 450) --> 0
locate(LUT, 451) --> 1
locate(LUT, 703) --> 253
locate(LUT, 704) --> 254

First you have to set the bin values in the LUT.   Next, you'll have to iterate through each pixel of you image, but when you are done, you can stuff these bin locations (values 0-255) into a ImageProcessor.  Then you'll have to pick the color table that works for you.

You are welcome to adapt the old stuff I have in hand... https://dl.dropboxusercontent.com/u/8433654/ValueLocate_.jar  It has the ValueLocate_ class to demo for ImageJ and ValueLocate class that has two static methods that do all the work: one for floats and one for integers

Cheers,
Ben

> [ Just as a side note:
> I begin with my Canon G2, raw image and use DCRaw ( -v -D -4 -T) convert it
> without interpolation to a 16-bit .TIFF file.  The Canon G2 sensor is only
> 10-bit, hence the total of 1024 values.  I then split this image into four,
> half size images R, G1, G2, B using a macro I found on this Forum.  It is
> these half size, 16-bit images I need to pseudocolor.  If I had my choice a
> plugin would be able to handle 16-bit (16348 values) images so other folks
> with newer, better cameras can use the plugin to explore Digital Phantom
> Leaf Photography on their own. ]
>
> Thanks for your help Kenneth.  If you get a hankering to write a plugin for
> this I'd be happy to beta test it ;d)
>
> Daddymoen
>
>
>
>
> --
> View this message in context: http://imagej.1557.x6.nabble.com/LUT-with-bin-size-of-1-tp5002951p5002961.html
> Sent from the ImageJ mailing list archive at Nabble.com.
>
> --
> ImageJ mailing list: http://imagej.nih.gov/ij/list.html

--
ImageJ mailing list: http://imagej.nih.gov/ij/list.html

[Rasband, Wayne (NIH/NIMH) [E]]

On May 9, 2013, at 11:53 AM, Daddymoen wrote:

> Kenneth,
>
> I can work on figuring out how to do the windowing approach in a macro,
> thanks for pointing me in that direction..  It looks likes this approach
> will give the level of subtle detail my project needs.

Here is JavaScript code that uses windowing to interactively assign a 256 entry LUT to a 16-bit image. Run it by pasting it into a text window and typing ctrl-j (Macros>Evaluate JavaScript). You can create a "LUT Windowing" command by saving the code in the plugins folder as "LUT_Windowing.js" and running Help>Refresh Menus.

-wayne

  imp = IJ.getImage();
  if (imp.getBitDepth()!=16)
      IJ.error("16-bit image required");
  IJ.run(imp, "Fire", "");
  stats = imp.getStatistics();
  min = imp.getProcessor().getMin();
  max = imp.getProcessor().getMax();
  imp.setDisplayRange(min, min+255);
  imp.updateAndDraw();
  gd = GenericDialog("LUT Adjuster");
  gd.addSlider("Min:", stats.min, stats.max-255, min);
  listener = new DialogListener ({
      dialogItemChanged : function(gd, event) {
          value = gd.getNextNumber();
          imp.setDisplayRange(value, value+255);
          imp.updateAndDraw();
          return true;
      }
  });
  gd.addDialogListener(listener);
  gd.showDialog();
  if (gd.wasCanceled()) {
      imp.setDisplayRange(min, max);
      imp.updateAndDraw();
  }

> Your preferred way of doing this, a plugin with some windowing flexibility,
> is the kind of approach I've been trying to find in many, many hours of
> Google searches. They either don't exist or I'm not using the right search
> keywords to find them.  Not finding anything like it, I've been trying to
> come close using a macro approach as I don't speak the Java programming
> language at all.  I speak barely enough C++ to have been able to create
> plugins using FilterMeister with Photoshop to make any progress at all on my
> project.  ImageJ is far more capable of handling 16-bit images than my very
> old version of PhotoShop.  So, since ImageJ macros are easier to learn to
> write than Java plugins, I work at using macros.  But macros are slow and
> clunky working with large images.
>
> A plugin that allowed the windowing of 16-bit pixel values to focus on my
> values of interest and then using a LUT to pseudocolor a resulting 8-bit
> image could be ideal.  I could then window my 16-bit data to the values of
> interest in within my 1024 total number of possible values:
>    0…450 -> 0
>    451 -> 1  
>    452 -> 2  
>    …
>    704 -> 254  
>    705…16384 -> 255  
>
> Then this 16-bit image data could be converted to 8-bit image data and my
> favorite LUT could then be applied.  I be happier than a pig at a salad bar!
>
> [ Just as a side note:
> I begin with my Canon G2, raw image and use DCRaw ( -v -D -4 -T) convert it
> without interpolation to a 16-bit .TIFF file.  The Canon G2 sensor is only
> 10-bit, hence the total of 1024 values.  I then split this image into four,
> half size images R, G1, G2, B using a macro I found on this Forum.  It is
> these half size, 16-bit images I need to pseudocolor.  If I had my choice a
> plugin would be able to handle 16-bit (16348 values) images so other folks
> with newer, better cameras can use the plugin to explore Digital Phantom
> Leaf Photography on their own. ]
>
> Thanks for your help Kenneth.  If you get a hankering to write a plugin for
> this I'd be happy to beta test it ;d)
>
> Daddymoen
>
> --
> View this message in context: http://imagej.1557.x6.nabble.com/LUT-with-bin-size-of-1-tp5002951p5002961.html
> Sent from the ImageJ mailing list archive at Nabble.com.

--
ImageJ mailing list: http://imagej.nih.gov/ij/list.html

[Daddymoen]

Hey, Thankx guys.

I am testing the solutions some of you have posted and just want to let you all know I really appreciate the help.  I've got to go out of town for a few days so I won't be able to give meaningful feedback until early next week.  I think the solutions you've posted are one the right track.

Back soon,

Daddymoen

[ctrueden]

Hi Ken,

> > isn't that exactly what is happening in ImageJ when you assign a LUT
> > to a 16bit image and change its min and max (B&C)?
>
> Could be,  I don't know.

I think so: as Stephan says, ImageJ already supports mapping an 8-bit LUT
into any desired portion of a 16-bit image. Just set the displayed min &
max using Brightness & Contrast and the LUT will be stretched accordingly.
If you set the min & max to a range of values of length 256, the "bin size"
will end up being 1 as Daddymoen requests.

You might still want to write a custom windowing plugin if:

A) You want to apply the LUT non-linearly.

B) You want to apply more than 256 different LUT values at various
intensity levels.

Such plugins would generally need to produce RGB Color output images.

> In this day and age, I think we ought to have support for 16-bit LUTs.

ImgLib2 and ImageJ2 have support for 16-bit LUTs [1]. The code is
extensible, such that other sorts of LUTs could easily be introduced, as
well.

Regards,
Curtis

[1]
https://github.com/imagej/imglib/blob/v2.0.0-beta6/imglib2/core/src/main/java/net/imglib2/display/ColorTable16.java#L44


On Thu, May 9, 2013 at 9:06 AM, Kenneth Sloan <[hidden email]>wrote:

> Could be,  I don't know.  There are a lot  of nooks and crannies if ImageJ
> which remain a mystery to me.  Mostly because I tend to go straight to a
> Java solution.
>
> The limitation of LUTs to 8 bits has always struck me as quaint; I was
> using 12-bit LUTs in 1980 (see my paper on "Color Map Techniques".)
>
> In this day and age, I think we ought to have support for 16-bit LUTs.
>
> As for "not saving", that's really a TIFF design issue and ImageJ can't do
> much about it.  Again, I am ignorant about current TIFF capabilities, so
> thus may well be feasible.
>
> -Kenneth Sloan
> (von meinem iPhone4S gesendet)
>
> On May 9, 2013, at 2:39, Stephan Saalfeld <[hidden email]> wrote:
>
> > Hi Kenneth,
> >
> >> [...]
> >> Let's see…I think the interface might be:
> >>        min, max - range of the window
> >>
> >> and the behavior would be to map:
> >>         0…min     -> 0
> >>         min…max   -> 0…255
> >>         max…16384 -> 255
> >
> > isn't that exactly what is happening in ImageJ when you assign a LUT to
> > a 16bit image and change its min and max (B&C)?
> >
> > Unfortunately, ImageJ doesn't save the LUT with a TIFF image so, for
> > visualization purposes, you would have to save the image as RGB.
> >
> > Best,
> > Stephan
> >
> >>
> >> On May 8, 2013, at 17:50 , Daddymoen <[hidden email]> wrote:
> >>
> >>> Curtis,
> >>>
> >>> Thanks for your reply, the LUT you gave the link to will be useful.
> >>>
> >>> In my project I am converting  my  camera sensor intensity values (a
> range
> >>> of 0 to 1024) in a .Tiff file  to an RGB .jpg image,   I am only
> interested
> >>> in applying the LUT coloring over a small range of image values,
> perhaps a
> >>> range of 75 to 100 intensity values.  The LUT needs to display subtle
> >>> variations within this narrow range of values.  Ideally, each
> individual
> >>> intensity value will have its own, color.  But, since the image has
> 1024
> >>> total individual values, and the LUT has only 256 colors, the image
> has 4
> >>> times as many values as the LUT has colors. in this case   When the
> LUT is
> >>> applied to my image the LUT has, essentially,  256 "bins" that each
> >>> containing  consecutive four intensity values.  Each of these four
> >>> individual intensity values will be displayed as the same color.  So,
> if I'm
> >>> trying to display subtle differences (such as single intensity value
> >>> changes) these "four value wide bins" severely limit display of subtle
> >>> features in my image data.
> >>>
> >>> What I'm looking for is a way to control the size of these LUT bins.
>  For
> >>> example in a typical image I use, Intensity values from, say, 0 to 500
> are
> >>> of no interest.  If I could control LUT bin size I'd make fist bin
> contain
> >>> intensity values form 0 to 500 and color them all black.. The intensity
> >>> values between, say, from 501 and 575 are of interest, I'd make each
> of the
> >>> bins hold only one value, each value with its own color.  Values from
> 576 to
> >>> 1023 (in this example) are again of no interest, so the last bin in
> the LUT
> >>> could contain all those values and also be colored black.
> >>>
> >>> So, I guess what I am really looking for is control of the LUT bin
> sizes.  I
> >>> hope all that didn't add to the confusion :d)
> >>>
> >>> Daddymoen
> >>>
> >>>
> >>>
> >>> --
> >>> View this message in context:
> http://imagej.1557.x6.nabble.com/LUT-with-bin-size-of-1-tp5002951p5002956.html
> >>> Sent from the ImageJ mailing list archive at Nabble.com.
> >>>
> >>> --
> >>> ImageJ mailing list: http://imagej.nih.gov/ij/list.html
> >>
> >> --
> >> ImageJ mailing list: http://imagej.nih.gov/ij/list.html
> >
> > --
> > ImageJ mailing list: http://imagej.nih.gov/ij/list.html
>
> --
> ImageJ mailing list: http://imagej.nih.gov/ij/list.html
>

--
ImageJ mailing list: http://imagej.nih.gov/ij/list.html