Red de conocimiento informático - Material del sitio web - ¿Cómo binarizar imágenes usando lenguaje C?

¿Cómo binarizar imágenes usando lenguaje C?

/************************************************ * *********************

* Esta función se utiliza para realizar operaciones de segmentación de umbral en imágenes

* Parámetros:

* LPSTR lpDIBBits - puntero de la imagen DIB de origen

* LONG lWidth - ancho de la imagen de origen (unidad: píxeles)

* LONG lHeight - alto de la imagen de origen (Unidad : píxeles)

**************************************** ** ******/

BOOL ImageChangeProc::ThresholdDIB(LPSTR lpDIBBits,LONG lWidth, LONG lHeight)

{

// Apuntando a la imagen de origen Puntero LPSTR lpSrc

// Puntero a la imagen en caché

LPSTR lpDst

// Puntero a la imagen DIB en caché

LPSTR lpNewDIBBits;

HLOCAL hNewDIBBits;

// Variable de bucle

long i

long j; p > unsigned char pixel;

long lHistogram[256];

// Umbral, valor de gris máximo y mínimo, valor de gris promedio de dos áreas

unsigned char Threshold,NewThreshold,MaxGrayValue,MinGrayValue,Temp1GrayValue,Temp2GrayValue;

//Variable intermedia utilizada para calcular el valor promedio de grises regional

long lP1,lP2,lS1,lS2 ;

//Número de iteraciones

int IterationTimes;

LONG lLineBytes;

hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight

if (hNewDIBBits == NULL)

{

// No se pudo asignar memoria

return FALSE;

// Bloquear memoria.

// Bloquear memoria

lpNewDIBBits = (char * )LocalLock( hNewDIBBits

// Inicializar memoria recién asignada

lpDst); = (char *)lpNewDIBBits;

memset(lpDst, (BYTE)255, lWidth * lHeight);

lLineBytes = WIDTHBYTES(lWidth * 8); > for (i = 0; i < 256;i++)

{

lHistograma[i]=0

}

; //Obtener datos.

// Obtener histograma

MaxGrayValue = 0;

MinGrayValue = 255

for (i = 0;i < lWidth ; i++)

{

for (j = 0;j < lHeight ;j++)

{

lpSrc = (char * ) lpDIBBits + lLineBytes * j + i;

píxel = (carácter sin firmar)*lpSrc

lHistograma[píxel]++; p> //Modifica el valor de gris máximo y mínimo

if(MinGrayValue > pixel)p>

{

MinGrayValue = pixel

}

if(MaxGrayValue < píxel)

{

MaxGrayValue = píxel

}

}

}

}

// Iterar para obtener el mejor umbral

NewThreshold = (MinGrayValue + MaxGrayValue)/2; /p>

Umbral = 0;

for(IterationTimes = 0; Umbral != Nuevo Umbral && IterationTimes < 1000;IterationTimes ++)

{

Umbral = NuevoUmbral;

lP1 = 0;

lP2 = 0; lS1 += lHistograma[i]; for (IterationTimes = 0; Umbral !

for (i = Umbral+1;i

{

lP2 += lHistograma[ i ]*i;

lS2 += lHistograma[i];

}

if(lS1==0||lS2==0)

p>

{

// Liberar memoria

LocalUnlock(hNewDIBBits).

LocalFree(hNewDIBBits).

Devuelve FALSO ;

}

Temp1GrayValue = (carácter sin firmar)(lP1 / lS1);

Temp2GrayValue = (carácter sin firmar)(lP2 / lS2); ;

lt; lAltura ; j++)

{

lpSrc = (char *)lpDIBBits + lLineBytes * j + i; lpDst = (char *)lpNewDIBBits + lLineBytes * j + i;

píxel = (unsigned char)*lpSrc

if(pixel <= Umbral)

p>

{

*lpDst = (unsigned char)0

}

De lo contrario

{

*lpDst = ( char unsigned)255

}

}

}

// Copiar imagen

memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);

// Liberar memoria

{ localUnlock(hNewDIBBits) = (carácter sin firmar)

{ localUnlock(hNewDIBBits) = (carácter sin firmar) 0;

}

}LocalUnlock(hNewDIBBits

LocalFree(hNewDIBBits

// devolver

devolver VERDADERO

}

Referencia:/t/20030909/13/2240079.html