Ayúdame, usa la programación en lenguaje C para crear una imagen en escala de grises de 256*256

Conversión de imagen en color a imagen en escala de grises

BOOL ColortoGrayScale(HWND hWnd)

{

DWORD SrcBufSize, DstBufSize, DstLineBytes <; /p>

LPBITMAPINFOHEADER lpImgData;

LPSTR lpPtr;

HLOCAL hTempImgData;

LPBITMAPINFOHEADER lpTempImgData;

LPSTR lpTempPtr <; /p>

HDC hDc;

HFILE hf;

LARGO x, y

BITMAPFILEHEADER DstBf

BITMAPINFOHEADER DstBi; ;

LOGPALETTE *pPal;

HPALETTE hPrevPalette;

HLOCAL hPal;

DWORD NewNumColors;

WORD NewBitCount;

flotante Y;

DWORD i;

carácter sin firmar Rojo, Verde, Azul, Gris

NewNumColors=NumColors; //NewNumColors es el número de colores de la nueva imagen

NewBitCount=bi.biBitCount; //NewBitCount es el número de bits de color de la nueva imagen

if(NumColors== 0) ​​//Imagen en color verdadero

{

NewNumColors=256;

NewBitCount=8;

}

//Debido a que la cantidad de bits de color puede haber cambiado, por lo que debe volver a calcular la cantidad de bytes ocupados por cada línea y el tamaño del búfer de la nueva imagen

//

DstLineBytes=(DWORD)WIDTHBYTES( bi.biWidth*NewBitCount);

DstBufSize=(DWORD)(tamañode(BITMAPINFOHEADER) NewNumColors*

tamañode(RGBQUAD) (DWORD )DstLineBytes*bi.biHeight);

//DstBf y DstBi son los nuevos BITMAPFILEHEADER y BITMAPINFOHEADER

//Copia la información del encabezado original

memcpy(( char *)amp; DstBf, (char *) amp; bf, tamaño de (BITMAPFILEHEADER));

memcpy((char *)amp; DstBi, (char *)amp; bi, tamaño de (BITMAPINFOHEADER) );

// Realizar los cambios necesarios

DstBf.bfSize=DstBufSize sizeof(BITMAPFILEHEADER);

DstBf.bfOffBits=(DWORD)(NewNumColors*sizeof( RGBQUAD)

tamaño de (BITMAPFIL

EHEADER)

sizeof(BITMAPINFOHEADER));

DstBi.biClrUsed=0

DstBi.biBitCount=NewBitCount

// El tamaño del búfer de la imagen original

SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);

if((hTempImgData=LocalAlloc(LHND, DstBufSize))==NULL)

{

MessageBox(hWnd, "¡Error al asignar memoria!", "Mensaje de error", MB_OK|

MB_ICONEXCLAMATION

); devolver FALSO ;

}

lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);

lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData

memcpy(lpTempImgData, lpImgData, DstBufSize);

//Reemplaza la información del encabezado original con el nuevo BITMAPINFOHEADER

memcpy(lpTempImgData, (char *)amp; DstBi, sizeof(BITMAPINFOHEADER));

//lpPtr apunta a los datos de la imagen original

lpPtr=(char * )lpImgData sizeof(BITMAPINFOHEADER) );

//lpTempPtr apunta a los datos de la nueva imagen

lpTempPtr=(char *)lpTempImgData sizeof(BITMAPINFOHEADER);

//Para el nuevo ajuste de color, la placa asigna memoria

hPal=LocalAlloc(LHND, sizeof(LOGPALETTE) NewNumColors

* sizeof(PALETTEENTRY)); >pPal =(LOGPALETTE *)LocalLock( hPal);

pPal-gt; palNumEntries = (WORD) NewNumColors

pPal-gt; p>if(NumColors==0) ​​//Color verdadero

for (i = 0; i lt; 256; i) { //Escala de grises de (0, 0, 0) a (255, 255 , 255)

pPal-gt;palPalEntry[i].peRed=(BYTE)i;

pPal-gt;palPalEntry[i].peGreen=(BYTE)i;

pPal- gt;palPalEntry[i].peBlue=(BYTE)i;

pPal-gt;palPalEntry[i].peFlags=(BYTE)0;

*(lpTempPtr )=( carácter sin firmar)i;

*(lpTempPt

r )=(carácter sin firmar)i;

*(lpTempPtr )=(carácter sin firmar)i;

*(lpTempPtr )=0;

}

else

for (i = 0; i lt; NewNumColors; i ) { //Colorear imagen con paleta

Azul=(unsigned char ) (*lpPtr );

Verde=(carácter sin firmar)(*lpPtr);

Rojo=(carácter sin firmar)(*lpPtr);

Y= (flotante) (Rojo*0,299 Verde*0,587 Azul*0,114);

Gris=(BYTE)Y;

lpPtr;

//Del valor Y original se calcula a partir de los colores de la paleta y se escribe en la nueva paleta

pPal-gt; palPalEntry[i].peRed=Gray;

pPal-gt; palPalEntry [i]. peGreen=Gris;

pPal-gt; palPalEntry[i].peBlue=Gris;

pPal-gt; palPalEntry[i].peFlags=0;

*(lpTempPtr )=(carácter sin firmar)Gris;

*(lpTempPtr )=(carácter sin firmar)Gris;

*(lpTempPtr )=(carácter sin firmar) Gris;

*(lpTempPtr )=0

}

if(hPalette!=NULL)

DeleteObject(hPalette

//Generar una nueva paleta lógica

hPalette=CreatePalette(pPal);

LocalUnlock(hPal);

LocalFree (hPal);

hDc=GetDC(hWnd);

if(hPalette){

hPrevPalette=SelectPalette(hDc, hPalette, FALSE);

p>

RealizePalette(hDc);

}

if(NumColors==0) ​​​​//Solo las imágenes en color verdadero necesitan procesar datos de mapa de bits

for(y=0;ylt;bi.biHeight;y){

lpPtr=(char *)lpImgData (SrcBufSize-LineBytes-y*LineBytes);

lpTempPtr =(char *)lpTempImgData (DstBufSize-DstLineBytes-y*DstLineBytes);

for(x=0; xlt; bi.biWidth; x ){

Azul=(carácter sin firmar )(* lpPtr );

Verde=(carácter sin firmar)(*lpPtr );

Rojo=(carácter sin firmar)(*lpPtr );

Y =(flotar

)(Rojo*0,299 Verde*0,587 Azul*0,114);

//Calcule el valor Y a partir de los datos del mapa de bits y escríbalo en la nueva imagen

Gris=(BYTE)Y

*(lpTempPtr )=(unsigned char)Gray;

}

}

if(hBitmap!=NULL)

p>

DeleteObject(hBitmap);

//Generar un nuevo mapa de bits

hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData,

( LONG)CBM_INIT,

(LPSTR)lpTempImgData sizeof(BITMAPINFOHEADER)

NewNumColors*sizeof(RGBQUAD),

(LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);

if(hPalette y hPrevPalette){

SelectPalette(hDc, hPrevPalette, FALSE)

RealizePalette(hDc);

}

hf=_lcreat("c:\\gray.bmp", 0);

_lwrite(hf, (LPSTR) & DstBf, tamaño de (BITMAPFILEHEADER));

_lwrite(hf, (LPSTR)lpTempImgData, DstBufSize);

_lclose(hf);

//Liberar memoria y recursos

ReleaseDC(hWnd, hDc);

LocalUnlock(hTempImgData);

LocalFree(hTempImgData);

GlobalUnlock(hImgData); /p>

devuelve VERDADERO;

}