quitar - Aplicar efecto de escala de grises a la imagen usando NDK(C/C++) en Android

la pantalla de mi celular se puso en blanco y negro lg

Question

Quiero aplicar el efecto de escala de grises a la imagen usando NDK.

Para eso busqué mucho en Google, pero encontré el mismo resultado que devuelve la imagen algo así como negativo (esto es lo que creo).

Lo que quiero ::

Por ejemplo ::

Tengo esta imagen original

Después de aplicar el efecto de escala de grises debería ser así ::

Lo que he probado ::

Quiero lograr esta funcionalidad usando NDK, por lo que he creado una función en el archivo .cpp

JNIEXPORT void JNICALL Java_com_example_ndksampleproject_MainActivity_jniConvertToGray(JNIEnv * env, jobject obj, jobject bitmapcolor,jobject bitmapgray)
{
AndroidBitmapInfo infocolor;
void* pixelscolor;
AndroidBitmapInfo infogray;
void* pixelsgray;
int ret;
int y;
int x;
LOGI("convertToGray");
if ((ret = AndroidBitmap_getInfo(env, bitmapcolor, &infocolor)) < 0) {
LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
return;
}
if ((ret = AndroidBitmap_getInfo(env, bitmapgray, &infogray)) < 0) {
LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
return;
}
LOGI("color image :: width is %d; height is %d; stride is %d; format is %d;flags is %d",infocolor.width,infocolor.height,infocolor.stride,infocolor.format,infocolor.flags);
if (infocolor.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
LOGE("Bitmap format is not RGBA_8888 !");
return;
}
LOGI("gray image :: width is %d; height is %d; stride is %d; format is %d;flags is %d",infogray.width,infogray.height,infogray.stride,infogray.format,infogray.flags);
if (infogray.format != ANDROID_BITMAP_FORMAT_A_8) {
LOGE("Bitmap format is not A_8 !");
return;
}
if ((ret = AndroidBitmap_lockPixels(env, bitmapcolor, &pixelscolor)) < 0) {
LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
}
if ((ret = AndroidBitmap_lockPixels(env, bitmapgray, &pixelsgray)) < 0) {
LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
}
LOGI("unlocking pixels height = %d",infocolor.height);
// modify pixels with image processing algorithm
for (y=0;y<infocolor.height;y++) {
argb * line = (argb *) pixelscolor;
uint8_t * grayline = (uint8_t *) pixelsgray;
for (x=0;x<infocolor.width;x++) {
grayline[x] = 0.3 * line[x].red + 0.59 * line[x].green + 0.11*line[x].blue;
}
pixelscolor = (char *)pixelscolor + infocolor.stride;
pixelsgray = (char *) pixelsgray + infogray.stride;
}
LOGI("unlocking pixels");
AndroidBitmap_unlockPixels(env, bitmapcolor);
AndroidBitmap_unlockPixels(env, bitmapgray);
}

La función anterior me devuelve el resultado así:

Este efecto se ve como algo negativo de imagen.

Avísame si necesitas algo de mi parte ... Por favor, ayúdame a resolver este problema, ya que me he metido en esto de muchas horas.

Muchas gracias de antemano...

EDIT ::

Sugerencia de floppy12 ::

for (y=0;y<infocolor.height;y++) {
argb * line = (argb *) pixelscolor;
uint8_t * grayline = (uint8_t *) pixelsgray;
for (x=0;x<infocolor.width;x++) {
grayline[x] = (255-0.3 * line[x].red) + (255-0.59 * line[x].green) + (255-0.11*line[x].blue)/3;
}
pixelscolor = (char *)pixelscolor + infocolor.stride;
pixelsgray = (char *) pixelsgray + infogray.stride;
}

Salida ::

EDIT 2 ::

He hecho algunas modificaciones simples a la imagen y me devuelve la imagen de lo que quería, pero la imagen perdió su brillo.

Estos son los cambios que hice en la función nativa ...

for (y=0;y<infocolor.height;y++) {
argb * line = (argb *) pixelscolor;
uint8_t * grayline = (uint8_t *) pixelsgray;
for (x=0;x<infocolor.width;x++) {
grayline[x] = ((255-0.3 * line[x].red) + (255-0.59 * line[x].green) + (255-0.11*line[x].blue))/3;
}
pixelscolor = (char *)pixelscolor + infocolor.stride;
pixelsgray = (char *) pixelsgray + infogray.stride;
}

Resultado (la imagen es grayscaled pero pierde su brillo) ::

Answer 1

Para obtener una imagen en escala de grises, cada píxel debe tener la misma cantidad de rojo, verde y azul

Tal vez use el componente rojo y lo afecte tanto en verde como en azul en su cálculo de grayline

o usa la fórmula (R + G + B) / 3 = Gris

Las imágenes negativas normalmente se obtienen cambiando cada componente:

NegR = 255 - grayR

y así

Entonces podrías intentar calcular grayscal [x] = (255 - 0.3 * línea [x]) + ...

Editar para obtener brillo: para obtener un mejor brillo, intente agregar una cantidad fija a su cálculo en escala de grises:

G += Bness;

Aquí parece que Bness debería ser negativo siempre y cuando pase de 255 (negro) a 0 (blanco) por alguna extraña razón. Desea establecer un límite inferior para que no sea menor de 0 para su valor de grascale, luego intente:

G = max(0, G+Bness);

Recomiendo algo así como Bness = -25

Editar brillo de implementación:

// Declare a global variable for your brightness - outside your class
static uint8_t bness = -25;
// In your grayscale computation function
for y...
for x...
grayscale[x] = ( (255-0.3*line[x].red) + ..... ) /3 ;
int16_t gBright = grayscale[x] + bness;
grayscale[x] = MAX( 0, gBright );