L_WindowLevelFillLUTExt

#include "l_bitmap.h"

L_LTDIS_API L_INT L_WindowLevelFillLUTExt (pLUT, ulLUTLen,rgbStart, rgbEnd, nLow, nHigh, uLowBit, uHighBit, nMinValue, nMaxValue, nFactor, uFlags)

Fills the user-allocated 16-bit LUT with values range between rgbStart and rgbEnd colors according to the selected LUT type.

Returns

Comments

Use this function to fill in the LUT, used in L_WindowLevelExt or L_WindowLevelBitmapExt, according to LUT type flag.

This function fills a 16-bit LUT. If you want to fill an 8-bit LUT, see L_WindowLevelFillLUT.

The LUT will be filled as follows:

The nFactor parameter is used for log, exp and sigmoid functions only. If nFactor = 0 the function performs a linear interpolation between the two points nLow and nHigh and stores the results in the lookup table, regardless of the value in uFlags.

If uFlag is FILLLUT_EXPONENTIAL the value of nFactor modifies the lookup table values (see figure below) according to the following equations:

where :

nFirstValue = exp(0).

nLastValue = exp(nFactor)

x = the intensity value of the selected point

uStart = the nLow parameter of this function

uEnd = the nHigh parameter of this function

If uFlag is FILLLUT_ LOGARITHMIC the value of nFactor modifies the lookup table values (see figure below) according to the following equations:

where:

nFirstValue = 0.

nLastValue = ln(1 + nFactor)

x = the intensity value of the selected point

uStart = the nLow parameter of this function

uEnd = the nHigh parameter of this function

If uFlag is FILLLUT_ SIGMOID the value of nFactor modifies the lookup table values (see figure below)according to the following equations:

where:

nFirstValue = 1./(1+exp(2.*nFactor/10.*(nStart - Center)/ (uEnd- uStart))).

nLastValue = 1./(1+exp(2.*nFactor/10.*(nEnd - Center)/ (uEnd- uStart))).

Center = (nEnd + nStart)/2.

x = the intensity value of the selected point

uStart = the nLow parameter of this function

uEnd = the nHigh parameter of this function

If uFlag is FILLLUT_LINEAR, nFactor is ignored. The function fills the lookup table linearly.

You must allocate the memory for the LUT before calling this function. You can calculate the required size with (sizeof(RGBQUAD) * (1<<(pBitmap->HighBit - pBitmap->LowBit + 1))), as seen in the example below.

For example, suppose you are working with a 12 bit grayscale image. There are 4096 intensity levels in a 12 bit image (2 raised to the 12th power). Normally, the interval between 0 and 4095 for unsigned data would be mapped to colors between (0, 0, 0) and (0xFFFF, 0xFFFF, 0xFFFF). With this function, any value that falls between the low level and the high level will be mapped to colors between the start color and the end color. If you do not want a mapping function, set the start and end colors equal.

If you only want to map the values between 1972 and 3273 (in a 12-bit unsigned image), then set nLow to 1972, set nHigh to 3273, and set FILLLUT_INSIDE option. To map the values less than 1972 and greater than 3273, select FILLLUT_OUTSIDE option.

For information on saving bitmaps that have been window leveled, refer to Saving Window-Leveled Bitmaps.

Required DLLs and Libraries

Platforms

Windows 2000 / XP/Vista, Windows CE.

See Also

Example

L_INT WindowLevelFillLUTExtExample(pBITMAPHANDLE pBitmap)
{
   L_INT nRet;
   L_RGBQUAD16* pLUT;
   L_INT    nMin, nMax;
   L_INT    nLowBit, nHighBit;
   L_UINT   uSigned;
   L_RGBQUAD16 rgbRed = {0xFFFF, 0, 0, 0};
   L_RGBQUAD16 rgbBlue = {0, 0, 0xFFFF, 0};

   /* allocate the lookup table */
   pLUT = (L_RGBQUAD16 *)malloc(sizeof(L_RGBQUAD16) * (L_INT32)(1<<(pBitmap->HighBit - pBitmap->LowBit + 1)));

   /* get the bitmap's min/max values */
   nRet = L_GetMinMaxBits(pBitmap, &nLowBit, &nHighBit);
   if(nRet != SUCCESS)
      return nRet;
   nRet = L_GetMinMaxVal(pBitmap, &nMin, &nMax);
   if(nRet != SUCCESS)
      return nRet;
   
   nLowBit  = pBitmap->LowBit;
   nHighBit = pBitmap->HighBit;
   
   if(pBitmap->Flags.Signed)
      uSigned = FILLLUT_SIGNED;
   else
      uSigned = FILLLUT_UNSIGNED;
    
   /* fill the LUT with a color gradient */
   nRet = L_WindowLevelFillLUTExt(pLUT,
                               1<<(pBitmap->HighBit - pBitmap->LowBit + 1),
                               rgbRed,          /* RED              */
                               rgbBlue,         /* BLUE             */
                               23000,           /* Starting value   */
                               45000,           /* Ending value     */
                               nLowBit,         /* Bitmap's LowBit  */
                               nHighBit,        /* Bitmap's HighBit */
                               nMin,            /* Bitmap's MinVal  */
                               nMax,            /* Bitmap's MaxVal  */
                               10,              /* nFactor */
                               FILLLUT_INSIDE | FILLLUT_LINEAR | uSigned); /* Fill Inside*/
   if(nRet != SUCCESS)
      return nRet;


   /* window level the bitmap using the new LUT */
   nRet = L_WindowLevelBitmapExt(pBitmap,
                               nLowBit,
                               nHighBit,
                               pLUT,
                               1<<(pBitmap->HighBit - pBitmap->LowBit + 1),
                               ORDER_BGR);
   if(nRet != SUCCESS)
      return nRet;

   /* free the table */
   free(pLUT);
   return SUCCESS;
}