#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.
Pointer to the bitmap handle referencing the bitmap to be changed.
Table of uLUTLen
integers containing lookup values.
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:
(1 << pBitmap->BitsPerPixel)
Flags that indicate:
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:
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. |
Value | Meaning |
---|---|
REMAP_CHANGEHIGHBIT | [0x0010] Change the high bit of the bitmap (pBitmap ->HighBit) according to the used data in the pLUT. |
Value | Meaning |
---|---|
REMAP_NORMAL | [0x0100] The data in the pLUT is normal data, in this case the uLUTLen should be equal to 2^(HighBit - LowBit + 1). |
Value | Meaning |
---|---|
SUCCESS | The function was successful. |
< 1 | An error occurred. Refer to Return Codes. |
You can apply the change to red, green, blue, or all color channels.
The current intensity values correspond to the table indexes. The values of the entries are the new values to be applied.
The bitmap intensity level range depends on the resolution of the image:
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.
This function can be used to implement end user features such as Photoshop Curves.
To update a status bar or detect a user interrupt during execution of this function, refer to L_SetStatusCallback.
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.
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.
In order to speed up widely used image processing filters in LEADTOOLS, the grayscale value (master channel) of a colored image is calculated using the following formulas:
#define CalcGrayValue(r, g, b) ((L_UCHAR)(((L_UCHAR) (((2 * (L_UINT) (r)) + (5 * (L_UINT) (g)) + (L_UINT) (b) + 4) / 8))))
#define CalcGrayValue16(r, g, b) ((L_UINT16) (((2 * (L_UINT32) (r)) + (5 * (L_UINT32) (g)) + (L_UINT32) (b) + 4) / 8))
#define CalcGrayValue32(r, g, b) ((L_UINT32) (((2 * (L_UINT32) (r)) + (5 * (L_UINT32) (g)) + (L_UINT32) (b) + 4) / 8))
Required DLLs and Libraries
Win32, x64, Linux.
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 (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;
}
Help Collections
Raster .NET | C API | C++ Class Library | HTML5 JavaScript
Document .NET | C API | C++ Class Library | HTML5 JavaScript
Medical .NET | C API | C++ Class Library | HTML5 JavaScript
Medical Web Viewer .NET
Multimedia
Direct Show .NET | C API | Filters
Media Foundation .NET | C API | Transforms
Supported Platforms
.NET, Java, Android, and iOS/macOS Assemblies
Imaging, Medical, and Document
C API/C++ Class Libraries
Imaging, Medical, and Document
HTML5 JavaScript Libraries
Imaging, Medical, and Document