L_RemapBitmapIntensity

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 (MAKE_IMAGE_PATH(TEXT("sample5.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(MAKE_IMAGE_PATH(TEXT("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) 
   { 
      free(pLookupTable); 
      return nRet; 
   } 
 
   //Invert the Image. 
   nRet = L_RemapBitmapIntensity(pBitmap, pLookupTable, nLutLen, CHANNEL_MASTER|REMAP_NORMAL); 
   if (nRet != SUCCESS) 
   { 
      free(pLookupTable); 
      return nRet; 
   } 
 
   free(pLookupTable); 
 
   return SUCCESS; 
}