LBitmap::RemapIntensity

#include "ltwrappr.h"

virtual L_INT LBitmap::RemapIntensity(pLUT, uLUTLen, uFlags)

L_INT * pLUT;

/* table of uLUTLen integers containing lookup values */

L_UINT uLUTLen;

/* length of the lookup table */

L_UINT uFlags;

/* flag that indicates the color channel to be affected */

Uses a lookup table to change the class object's bitmap intensity values. You can apply the change to red, green, blue, or all color channels.

Parameter

Description

pLUT

Table of uLUTLen integers containing lookup values.

uLUTLen

Length of the lookup table.  Possible values are:

 

If the REMAP_NORMAL flag is used in the uFlags parameter

 

2^(HighBit � LowBit + 1)

 

If the REMAP_NORMAL flag is not used in the uFlags parameter

 

Value

Meaning

 

65536

16-bit / sample image

 

4096

12-bit / sample image

 

256

8-bit / sample image

uFlags

Flags that indicate:

 

  • The color plane to update.

 

  • Whether to change the high bit or not.

 

  • Whether the pLUT contains normal or stretched data.

 

You can combine values of each group when appropriate by using a bitwise OR ( | ). The following are valid values:

 

Flags indicate the color plane to update:

 

Value

Meaning

 

CHANNEL_MASTER

[0] All channels.

 

CHANNEL_RED

[1] Red channel only.

 

CHANNEL_GREEN

[2] Green channel only.

 

CHANNEL_BLUE

[3] Blue channel only.

 

Flag indicates whether to change the high bit or not:

 

REMAP_CHANGEHIGHBIT

[0x0010] Change the high bit of the bitmap (pBitmap->HighBit) according to the used data in the pLUT.

 

Flag indicates whether pLUT contains normal data:

 

REMAP_NORMAL

[0x0100] The data in the pLUT is normal data, in this case the uLUTLen should be equal to 2^(HighBit � LowBit + 1).

Returns

SUCCESS

The function was successful.

< 1

An error occurred. Refer to Return Codes.

Comments

The current intensity values correspond to the table indexes. The values of the entries are the new values to be applied.

This function supports 12 and 16-bit grayscale and 48 and 64-bit color images. Support for 12 and 16-bit grayscale and 48 and 64-bit color images is available only in the Document/Medical toolkits.

The bitmap intensity level range depends on the resolution of the image. For 64-bit, 48-bit, and 16-bit bitmaps, the intensity levels range form 0 to 2^16-1. For 12-bit bitmaps, the intensity levels range from 0 to 2^12-1. For other resolutions, the intensity levels range from 0 to 255.

Be sure that pLUT contains the number of the bitmap intensity levels. For example if the bitmap is 16-bit (the maximum bitmap intensity level is 2^16 1).

To update a status bar or detect a user interrupt during execution of this function, refer to LBase::EnableStatusCallback.

This function supports signed data images.

This function does not support 32-bit grayscale images. It returns the error code ERROR_GRAY32_UNSUPPORTED if a 32-bit grayscale image is passed to this function.

Required DLLs and Libraries

LTDIS
LTFIL
LTIMGCLR

For a listing of the exact DLLs and Libraries needed, based on the toolkit version, refer to Files To Be Included With Your Application.

See Also

Functions:

LBitmap::GetUserLookupTable, LBitmap::GetFunctionalLookupTable, LBitmap::ChangeIntensity, LBitmap::GammaCorrect, LBitmap::HistoContrast, LBitmap::StretchIntensity, LBitmap::ChangeHue, LBitmap::Invert, LBitmap::ChangeContrast, LBitmap::ChangeSaturation, LBitmap::HistoEqualize, LBitmap::GetHistogram, LBitmap::WindowLevel, LBitmapBase::Fill, LBitmapBase::GetPixelColor, LBitmapBase::PutPixelColor, Class Members

Topics:

Raster Image Functions: Modifying Intensity Values

 

Changing Brightness and Contrast

 

Raster Image Functions: Changing Brightness and Contrast

Example

L_INT LBitmap__RemapIntensityExample(LBitmap & Bitmap, L_TCHAR * pszFile)
{
   L_INT nRet;
   L_UINT LookupTable[256];
   
   nRet =Bitmap.Load(pszFile);
   if(nRet !=SUCCESS)
      return nRet;
   LookupTable[0] = 255;
   LookupTable[255] = 0;
   nRet =Bitmap.GetFunctionalLookupTable((L_INT*)LookupTable, 256, 0, 255, 0, 
                                          FLT_LINEAR);
   if(nRet !=SUCCESS)
      return nRet;
   nRet =Bitmap.RemapIntensity((L_INT*)LookupTable, 256, CHANNEL_MASTER);
   if(nRet !=SUCCESS)
      return nRet;
   return SUCCESS;
}
L_INT LBitmap__RemapIntensity_Signed_Example(LBitmap & Bitmap)
{
   L_INT          nRet;
   L_INT *        pLookupTable = NULL;  /* Array to hold lookup table*/
   L_INT          nMaxValue, nMinValue;
   L_INT          nLutLen;
   nLutLen = 1 << (Bitmap.GetHandle()->HighBit - Bitmap.GetHandle()->LowBit + 1);//Get the real LUT length
   if(!Bitmap.GetHandle()->Flags.Signed)
      return FAILURE; //The image should be signed
   nMinValue   =  -1 * nLutLen/2; //This is the lowest expected value.
   nMaxValue   =  nLutLen/2 - 1;  //This is the highest expected value.
   pLookupTable = (L_INT *) malloc(nLutLen * sizeof(L_INT));
   if(pLookupTable == NULL)
      return ERROR_NO_MEMORY;
   memset(pLookupTable, 0, nLutLen * sizeof(L_INT));
   /*Get Lookup table where the array calculated by the linear function for all the items of the array is from 0 - nLutLen*/
   if(nMinValue < 0)
      pLookupTable[nMinValue + nLutLen]    = nLutLen/2 - 1;
   else
      pLookupTable[nMinValue]    = nLutLen/2 - 1;
   if(nMaxValue < 0)
      pLookupTable[nMaxValue + nLutLen]  = -1 * nLutLen/2; 
   else
      pLookupTable[nMaxValue]  = -1 * nLutLen/2;
   //Generate a negative LUT.
   nRet = Bitmap.GetFunctionalLookupTable(pLookupTable, nLutLen, -1 * nLutLen/2, nLutLen/2 - 1, 1, FLT_LINEAR|FLT_SIGNED);
   if(nRet !=SUCCESS)
      return nRet;
   //Invert the Image.
   nRet = Bitmap.RemapIntensity(pLookupTable, (L_UINT)nLutLen, CHANNEL_MASTER|REMAP_NORMAL);
   if(nRet !=SUCCESS)
      return nRet;
   return SUCCESS;
}