L_RemapBitmapIntensity

#include "l_bitmap.h"

L_LTIMGCLR_API L_INT L_RemapBitmapIntensity(pBitmap, pLUT, uLUTLen, uFlags)

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

Returns

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 in the Document and Medical Imaging 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 L_SetStatusCallback.

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

Platforms

Windows 2000 / XP/Vista, Windows CE.

See Also

Example

This example will invert loaded bitmap by using lookup table affected by linear function

 L_INT RemapBitmapIntensityExample(L_VOID)
{
   L_INT nRet;
   L_UINT LookupTable[256];  /* Array to hold lookup table*/
   BITMAPHANDLE LeadBitmap; /*Bitmap handle to hold the loaded image */

   /* Load the bitmap, forced to 24 per pixel */
   nRet = L_LoadBitmap (TEXT("%UserProfile%\\My Documents\\LEADTOOLS Images\\IMAGE3.CMP"), &LeadBitmap, sizeof(BITMAPHANDLE), 24, ORDER_BGR, NULL, NULL); 
   if(nRet !=SUCCESS)
      return nRet;
   /*Get Lookup table where the array calculated by the linear function for all the items of the array is from 0 - 255*/
   LookupTable[0] = 255;
   LookupTable[255] = 0; 
   nRet = L_GetFunctionalLookupTable ((L_INT *)LookupTable, 256,0, 255, 0, FLT_LINEAR);
   if(nRet !=SUCCESS)
      return nRet;
   nRet = L_RemapBitmapIntensity(&LeadBitmap, (L_INT *)LookupTable, 256, CHANNEL_MASTER);
   if(nRet !=SUCCESS)
      return nRet;
   nRet = L_SaveBitmap(TEXT("%UserProfile%\\My Documents\\LEADTOOLS Images\\Result.BMP"), &LeadBitmap, FILE_BMP, 24, 0, NULL);
   if(nRet !=SUCCESS)
      return nRet;
   //free bitmap 
   if(LeadBitmap.Flags.Allocated)  
      L_FreeBitmap(&LeadBitmap);  
   return SUCCESS;
}

//This example will convert all images to signed image and it will invert its data.
 L_INT RemapBitmapIntensity_Signed_Example(pBITMAPHANDLE pBitmap)
{
   L_INT          nRet;
   L_INT *        pLookupTable = NULL;  /* Array to hold lookup table*/
   L_INT          nMaxValue, nMinValue;
   L_INT          nLutLen;

   nLutLen = 1 << (pBitmap->HighBit - pBitmap->LowBit + 1);//Get the real LUT length

   if(!pBitmap->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 = L_GetFunctionalLookupTable (pLookupTable, nLutLen, -1 * nLutLen/2, nLutLen/2 - 1, 1, FLT_LINEAR|FLT_SIGNED);
   if(nRet !=SUCCESS)
      return nRet;

   //Invert the Image.
   nRet = L_RemapBitmapIntensity(pBitmap, pLookupTable, nLutLen, CHANNEL_MASTER|REMAP_NORMAL);
   if(nRet !=SUCCESS)
      return nRet;

   return SUCCESS;
}