Problema
Un laboratorio de edición de fotos te pide resaltar los bordes de una imagen en escala de grises. Cada píxel es un brillo de 0 (negro) a 255 (blanco). Para cada píxel, mira su vecindario de 3 × 3 y calcula dos sumas ponderadas con los kernels de Sobel:
Gx = -1 0 1 Gy = -1 -2 -1
-2 0 2 0 0 0
-1 0 1 1 2 1El centro del kernel se coloca sobre el píxel, su fila superior sobre la fila de arriba y su columna izquierda sobre la columna de la izquierda. Multiplica cada vecino por el peso correspondiente y súmalos para obtener gx y gy. Cuando un vecino queda fuera de la imagen, usa en su lugar el píxel más cercano del borde (limita la fila al rango 0 … rows − 1 y la columna al rango 0 … cols − 1). La intensidad del borde es min(255, |gx| + |gy|), así que siempre es un entero entre 0 y 255. Lee siempre de la imagen original, nunca de píxeles que ya modificaste.
Implementa edge_detection(image).
Entrada
image: la imagen como una lista de filas; todas las filas tienen la misma longitud.
Salida
Devuelve una cuadrícula nueva del mismo tamaño en la que cada valor es la intensidad de borde de ese píxel.
Restricciones
1 ≤ rows, cols ≤ 50
0 ≤ píxel ≤ 255
Ejemplos
Entrada:
image = [
[10, 10, 10],
[10, 10, 10],
[10, 10, 10]
]
Salida esperada:
expected = [
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]
]
Entrada:
std::vector<std::vector<long long>> image = {
{10, 10, 10},
{10, 10, 10},
{10, 10, 10}
};
Salida esperada:
std::vector<std::vector<long long>> expected = {
{0, 0, 0},
{0, 0, 0},
{0, 0, 0}
};
Entrada:
long[][] image = new long[][] {
new long[] {10, 10, 10},
new long[] {10, 10, 10},
new long[] {10, 10, 10}
};
Salida esperada:
long[][] expected = new long[][] {
new long[] {0, 0, 0},
new long[] {0, 0, 0},
new long[] {0, 0, 0}
};
Explicación
Todos los vecindarios son uniformes, así que las dos sumas valen 0 en todas partes y el resultado es todo ceros.
Entrada:
image = [
[0, 0, 100],
[0, 0, 100],
[0, 0, 100]
]
Salida esperada:
expected = [
[0, 255, 255],
[0, 255, 255],
[0, 255, 255]
]
Entrada:
std::vector<std::vector<long long>> image = {
{0, 0, 100},
{0, 0, 100},
{0, 0, 100}
};
Salida esperada:
std::vector<std::vector<long long>> expected = {
{0, 255, 255},
{0, 255, 255},
{0, 255, 255}
};
Entrada:
long[][] image = new long[][] {
new long[] {0, 0, 100},
new long[] {0, 0, 100},
new long[] {0, 0, 100}
};
Salida esperada:
long[][] expected = new long[][] {
new long[] {0, 255, 255},
new long[] {0, 255, 255},
new long[] {0, 255, 255}
};
Explicación
Para el píxel del medio, la columna derecha suma 100 + 200 + 100 = 400 y la izquierda suma 0, así que gx = 400, gy = 0 y la intensidad se limita a 255. Los píxeles de la columna derecha también dan 255, porque los vecinos de su derecha que no existen copian el valor del borde, 100. Los píxeles de la columna izquierda solo ven 0 a ambos lados, así que se quedan en 0.
Cómo abordarlo
Inténtalo primero por tu cuenta y luego abre las pistas una a una.
Pista 1
Escribe una función auxiliar que devuelva el píxel en (r, c) después de limitar r y c al interior de la cuadrícula.
Pista 2
gx solo usa las columnas izquierda y derecha del vecindario; gy, solo las filas de arriba y de abajo.
Pista 3
Construye la salida en una cuadrícula aparte; si modificas la entrada sobre la marcha, los píxeles siguientes salen mal.
Complejidad esperada
tiempo O(rows × cols), espacio extra O(rows × cols)
Referencias
Este reto está adaptado para CodeUtility. Sigue el enunciado y las restricciones indicadas arriba.