 |
 |
|
 |
Profr: Dr. Francisco Javier Hernández López (fcoj23@cimat.mx)
Enviar tareas al correo: ProcVideo@hotmail.com (nombre_tarea_# , ej.: FranciscoHernandez_tarea_1)
Temario
Calificaciones:
| Num.
Ctrl. |
T1a_ConversionColor |
Comentarios
|
T1b_CombinacionImagenes |
Comentarios |
T_1b_CambiarColor_DeteccionBordes |
Comentarios |
T_3a_EstimacionMovimiento |
Comentarios |
T4_Exposición |
Comentarios |
T5 |
Comentarios |
T6 |
Comentarios |
Promedio_T |
Examen_I |
Proyecto |
||
| Tunas |
10 |
10 |
0 |
T3_3 | 0 |
T3_3 | 0 |
T3_3 |
0 |
T3_3 | |||||||||
| Thres |
10 |
8 |
T6_1 | 8 |
T1bCCDB_2 |
10 |
T3aEM_1 |
10 |
8 |
T5ROC_1 |
|||||||||
| 14016274 |
10 |
9 |
T1bCI_1 | 8 |
T1bCCDB_1 |
0 |
T3_3 | 0 |
T3_3 |
10 |
|||||||||
| 456 |
0 |
T3_3 |
0 |
T3_3 |
0 |
T3_3 | 0 |
T3_3 | 0 |
T3_3 |
0 |
T3_3 | |||||||
| 123 |
8 |
T1_1, T1aCC_1 |
10 |
8 |
T1bCCDB_3 |
0 |
T3_3 | 10 |
0 |
T3_3 | |||||||||
| 2403 |
10 |
0 |
T3_3 | 0 |
10 |
0 |
3 |
T6ROC_1 |
|||||||||||
| 1407 |
7 |
T1aCC_2, T1aCC_3 |
10 |
0 |
10 |
0 |
0 |
T3_3 | |||||||||||
| KALIAN18 |
10 |
T1aCC_4 |
10 |
10 |
10 |
10 |
10 |
||||||||||||
| 1234 |
7 |
T1aCC_2, T1aCC_3, T1aCC_6 |
9 |
T1aCC_6 , T1bCCDB_4 |
9 |
T3aEM_2 | 10 |
10 |
0 |
T3_3 | |||||||||
| 1991 |
10 |
T1aCC_5 |
0 |
T3_3 | 0 |
10 |
8 |
T5HOM_1 |
10 |
||||||||||
Comentarios:
- T1_1: Tener cuidado con el tipo de dato en el que se esten procesando los frames, ya sea en OpenCV (CV_8UC(1), CV_32FC(1), etc.) o en MatLab (uint8, double, etc.).
- T1_2:
%elementos de la matriz, hacemos:
suma_matriz = matriz(:);
Esto en MatLab solo te convierte la matriz en un vector, para sumar los elementos te faltó la función sum:
suma_matriz = sum(matriz(:))
- T1_3: Retardo en la entrega de la tarea.
- T1_4: El paso donde calculas (1-α)B está mal realizado,
deberías observar la imagen B en los pixeles donde α es
cero. Por lo tanto, tu resultado final es incorecto.
- T1_5: Faltó binarizar α, debe tener valores 0 o 1.
- T1_6: El resultado final tiene ruido en los bordes por la
forma en que binarizas la α: a=a-254;
- T1_7: El resultado final que obtienes es en escala de gris por que solo estas utilizando el primer canal (Red), dado que tus operaciones dentro de tu ciclo son: A(i,j)*alpha(i,j). Si pones: A(i,j,2)*alpha(i,j) entonces procesas el canal 2(Blue).
- T1_8: Sugerencia para binarizar α: a(a<127)=0;
a(a>127)=1; sin usar ciclos for en MatLab.
- T1_9: Desde la primer pasada a las imágenes, puedes hacer lo siguiente: image4.at<Vec3b>(i, j)[0] = image1.at<Vec3b>(i, j)[0] * red + image2.at<Vec3b>(i, j)[0] * (1-red); en OpenCV.
- T1_10: Faltó enviar el código en archivo .m, .cpp o los pasos que seguiste usando CALIMAN.
- T1_11: Hay inconsistencias en tu reporte. Por ejemplo,
calculas ab, pero luego no la utilizas y aparece una
nueva variable "al" que no definiste. Algo que quizá viendo
el código podría corregirse.
- T1a_1: El inciso b) no se realizó de forma correcta, una forma de realizar esta parte en la posición que elegiste podría ser:
figure(4);
[H_I_rst,W_I_rst,~]=size(I_rst);
I_result=I_rgb;
I_result(65:65+H_I_rst-1,220:220+W_I_rst-1,:)=I_rst;
imshow(I_result);
- T1a_2: Hay muchas faltas de ortografía en tu
reporte.
- T1a_3: No se logró pintar el rectángulo amarillo sobre el
rostro del tenista.
- T1a_4: En el código que tienes comentado, el error es que
el bigImage debería de ser la imagen del tenista
"tenis.jpg", y el smallImage debería de ser tu imagen
"uvuvuwe.jpg". Además hay que modificar las coordenadas para
que la smallImage coincida con el rectángulo amarillo del
inciso a).
- T1aCC_1: Tu programa no convierte bien de RGB a RGB Normalizado, debido a que las tres componentes R, G y B las tienes de tipo uchar, y cuanto realizas la suma (R+G+B) esta suma solo puede llegar hasta 255.
- T1aCC_2: La conversión a RGB Normalizada no es correcta.
- T1aCC_3: La tarea consiste en implementar la función de la
respectiva transformación, no solo utilizar las funciones de
MatLab.
- T1aCC_4: La causa por la que tuviste que dividir los
valores de suma [0 128 128] entre 256, es que tu arreglo
image_double está en el rango [0,1], entonces el 128 debe
ser mapeado al 0.5 en el rango [0,1].
- T1aCC_5: En tu función de conversión a RGB Normalizado,
hay que tomar en cuenta que RGBsum puede ser cero, entonces
hay que agregar una condición cuando esto suceda y asignar
los valores r=0,g=0 y b=0.
- T1aCC_6: Hay que entregar el código y reporte por
separado.
- T1b_1: Tu programa solo convierte en imagen binaria a la imagen alpha, pero no combina las imágenes greenscreen.bmp y fondo.bmp. El detalle que tienes en la binarización de alpha, es que como tu variable f es de tipo CV_8UC3, entonces conviene asignar el valor 255 cuando se rebaza el umbral.
- T1bCI_1: En tu función image2Binary(image), consideraste
la comparación estrictamente igual (===), debiste considerar
la comparación (> 127 ) para binarizar la imagen alpha.
Con esto, no tendrías los detalles que tienes en los
contornos de tu imagen resultante.
- T1bCCDB_1: Faltó calcular la magnitud del gradiente y aplicar el umbral para obtener los bordes.
- T1bCCDB_2: La correlación de las derivadas en x y y están mal aplicadas. Tus ciclos:
for(int k=0;k<3;k++)
for(int l=0;l<3;l++){}
deberías cambiarlo por:
for(int k=-1;k<2;k++)
for(int l=-1;l<2;l++){}
y
entonces el pixel central sería (i,j) en lugar de
(i-1,j-1)
- T1bCCDB_3: Al aplicar tus filtros de derivadas, hay que tener cuidado con el tipo de dato. Operaste uchar, por eso las derivadas no tienen datos negativos solo positivos.
- T1bCCDB_4: El umbral que estas aplicando en ambas
versiones que implementaste no es el adecuado para calcular
los bordes de la imagen, más bien estas detectando todo el
objeto.
- T2_1: Tenias que considerar que $L=256$, una imagen en escala de gris tiene 256 niveles de intensidad. Tu programa no considera el valor de intensidad 255: round((hC(value)/(rows*cols))*(254)).
- T2_2: Para desplegar el histograma puedes usar plot o bar, pero no ambos en la misma figura.
- T2_3: Tu histograma acumulado está mal calculado.
- T2_4: Tu programa manda un error, estas obteniendo el tamaño de la imagen con [N,M]=size(I1);, entonces tines N filas y M columnas, sin embargo al recorrer tus imágenes O e I2:
for i=1:M
O(i,j)=T(I2(i,j)+1);
end
end
tu indice $i$ recorre por columnas y tu indice $j$ recorre por renglones, lo cual es un problema cuando tus imágenes no son cuadradas.
- T2_5: Tu vector de transformación $T$ está mal calculado. Al igual que para el histograma acumulado, solo necesitas un ciclo.
- T2_6: En la parte donde haces equ(k)=acum(k)*256; estas considerando como valor máximo el 256 y este debería de ser el 255.
- T2_7: Tu asignación H = hist; deberías de ponerla después de calcular hist, no dentro de los ciclos que recorren la imagen.
- T2_8: El histograma acumulado debe ser una función creciente, intenta lo siguiente en tu código:
for k in
range(len(h)-1):
h[k+1]+=h[k]
- T3_1: La estrategia de emparejamiento de bloques está mal implementada:
El error
debe calcularse entre dos ventanas, una centrada en el pixel
que estas observando (axisx,axisy) en tu imagen I_kr0
y
otra centrada en el pixel ya con el desplazamiento candidato
(kernelx,kernely) en tu imagen I_kr1.
- T3_2: El resultado que muestras no es coherente con el desplazamiento observado entre las dos imagénes de prueba.
- T3_3: No entregó la tarea.
- T3_4: Hay todavía algo mal en la implementación, si metemos un ejemplo donde solo hay una simple traslación, ya sea en x o en y, tu programa arroja movimiento en los dos ejes.
- T3_5: El desplazamiento que tienes en el reporte no
concuerda con el desplazamiento calculado por tu programa.
- T3_6: Puedes evitar esta reasignación: E(d1+N/2 +1,d2+N/2 + 1)=0 +E(d1 + N/2 +1,d2+N/2 + 1);
- T3_7: Tu indMove, moveX y moveY son vectores de tamaño 307 cada uno, pero el resultado final debería ser un solo indice y un solo movimiento en x,y.
- T3_8: El error está mal calculado. Para cada candidato $d$, debes calcular un error, al final te quedas con la $d$ que hace que el error sea mínimo.
- T3_9: Te conviene considerar lo siguiente:
for
d1=-d:d
for d2=-d:d
epsilon(idx)=0;
for x1=1:M
for x2=1:N
Y
epsilon(idx)=epsilon(idx)+diferencia*diferencia;
- T3_10: Para ejemplos controlados, si puedes tener como mínimo el error cero, pero debes tomar en cuenta que en ejemplos no controlados, si hay que buscar errores mínimos mayores que cero.
- T3_11: En el reporte mencionas que despX es desplazamiento horizontal y despY es desplazamiento vertical, pero en tu programa es lo contrario.
- T3_12: La función cuadrática la confundiste con la función Lorentziana.
- T3_13: Faltó calcular los desplazamientos óptimos ($d_x$,$d_y$).
- T3_14: Para visualizar tu superficie de error mejor utiliza: mesh(error). Al restar las imágenes considera que los datos deben de ser de un tipo diferente al uchar o uint8.
- T3_15: El desplazamiento que propones entre tus imágenes es de 50 pixeles, entonces tu N debería de ser de por lo menos 100, para tener un rango de desplazamientos entre [-50,50].
- T3_16: Al momento de evaluar el error: error =
float(new_frame[i,j]) - float(reference_frame[abs(i -
candidateX), abs(j - candidateY)]), esta mal considerar el
valor absoluto al momento de aplicar los desplazamientos
candidatos.
Una forma correcta de evitar el acceso a memoria no asignada
es:
pos_x_new=i - candidateX;
pos_y_new=j - candidateY;
if pos_x_new>=0 and pos_x_new<reference_frame.shape[0]
and pos_y_new>=0 and pos_y_new<reference_frame.shape[1]:
error = float(new_frame[i,j]) -
float(reference_frame[pos_x_new, pos_y_new])
- T3_17: Hay un problema con la instrucción:
np.append(img_error, phi(error)), podrías cambiarla por:
global_error=global_error+phi(error)
- T3_18: El reporte no tiene contenido.
- T3_19: Para la resta de las imágenes debes de considerar
el tipo de dato.
- T3_20: La estrategia que usaste para calcular el error mínimo, está mal implementada.
- T3_21: Hay un detalle en tu programa en la línea: for el in sortedVector:, la variable sortedVector debe ser: outVector
- T3_22: Faltó programar la función Lorentziana.
- T3_23: Puedes evitar acceder a memoria no asignada de la siguiente manera:
if(l>=0 and l<self.m and k>=0 and k<self.n):
er1=er1+self.fi(int(self.im2[i,j])-int(self.im1[l,k]))
- T3_24: Solo consideraste desplazamientos positivos.
- T3_25: Solo implementaste la función cuadrática.
- T3_26: Tu rango de desplazamientos candidatos fue de [-25,1] en dx y dy, por esta razón no encontraste el desplazamiento óptimo.
- T3_27: Tu función de error está mal calculada: d[i,j] =d[i,j] + (imagen1.at<unsigned char>(k, p) - imagen1.at<unsigned char>(k-1-i, p-1-j)); Estas usando la misma imagen: imagen1
- T3_28: Al tener tu ciclo en i: for (int i = 0; i < imageH; i++) y tu ciclo en k: for (int k = imageW/2; k < imageH-3; k++), cuando k = imageW/2=25 y i= imageH-1=49, entonces k-1-i es negativo, por lo tanto el programa manda un error de acceso a memoria.
- T3_29: Tarea corregida en Tarea4
- T3aEM_1: El resultado puede ser más preciso si agregas una variable temporal que guarde la imagen I1 antes de tu ciclo while:
I1_temp=I1;
while(delta>0.0001) %Condicion de paro
y en lugar de interpolar con las \deltas, mejor interpola con
el vector d=(dx,dy):
%I1_new=Interpolar(I1,DeltaD(1),DeltaD(2)); %Interpolo la
imagen
I1_new=Interpolar(I1_temp,dx,dy); %Interpolo la imagen
- T3aEM_2: La construcción de la matriz A y el vector b del
algoritmo de Lucas-Kanade no esta bien. Se construyen
recorriendo todos los pixeles de la imagen, no los
desplazamientos candidatos del emparejamiento de bloques.
- T4_1: Detalle en el código en la linea 63:
imagesc(b_mediana); no existe la variable b_mediana
- T4_2: La mediana está mal estimada, lo que estas haciendo en tu código es:
después calculas la mediana con: median(BG_mediana, 3), pero como tu arreglo es bidimensional, entonces BG_mediana va a tener la misma información,
de esta forma lo que finalmente comparas, es el modelo del fondo calculando el promedio y calculando solo la suma de los N frames.
- T4_3: No es correcta la comparación que realizas en tu reporte, al final había que comparar el resultado de la substracción (b_prom y b_med) usando los dos modelos de fondo (promedio y la mediana).
- T4_4: Faltó dar formato a tu archivo de salida, por ej.: fprintf(fid,'%d %d\n',M(i,1),M(i,2));
- T4_5: Faltó guardar el archivo de salida "M.txt" de forma automática.
- T4_6: En la parte donde haces: double x = (p0.x -
p1.x)*(p0.x - p1.x);, sería mejor declarar otra variable,
digamos res_x=p0.x - p1.x; y luego multiplicar esta
variable por si misma double x= res_x*res_x;
- T4_7: Al momento de decidir si hay movimiento en el frame actual, faltó considerar que el campo de movimiento para el primer frame debe ser cero.
- T4_8: El código no es el reporte, faltó entregar el código
a parte en un archivo .m o un archivo .cpp.
- T4_9: Tu programa es lento por que estas re-calculando el mismo promedio y varianza de las diferencias entre los frames para cada pixel de la imagen. Basta con calcularlos una sola vez.
- T4_10: Al momento de calcular el promedio y la varianza tienes un detalle en tu código: for z=i:cols; debería ser for z=1:cols
- T4_11: Hay un error de signo en las derivadas parciales del Error: s(y,x) = B(y,x) - A(y,x) + (dA_x(y,x)*dx) + (dA_y(y,x)*dy);
Debería de ser: s(y,x) = B(y,x) - A(y,x) - (dA_x(y,x)*dx) -
(dA_y(y,x)*dy);
- T4_12: En lugar de separar el calculo de la d_x y d_y, hay que calcularlas de forma simultánea.
- T4_13: El desplazamiento óptimo final, en tu caso, podría calcularse acumulando cada uno de los desplazamientos de cada iteración.
- T5_1: Retardo en la entrega de avance del proyecto y exposición.
- T5_2: No presentó.
- T5_3: La matriz A (matrixA) está mal calculada, especifícamente el valor a22 = a11Sum; este debería ser la derivada parcial de la imagen I_{k-1} c.r.a. y.
- T5_4: El vector de terminos independientes \vec{b} lo calculaste como una matriz, y además la derivada temporal está mal calculada.
- T5_5: Debes checar el orden de los ejes coordenados con respecto a tu imagen, y que correspondan con los desplazamientos, por ejemplo: (dx,dy) -> (movimiento en las columnas, movimiento en las filas).
- T5_6: El desplazmiento global se debe aplicar a la imagen de referencia I_k0, no a la que vas actualizando en cada iteración.
- T5ROC_1: Tus resultados P, PDR y F son muy pequeños, esto se debe a que en la lectura de los datos de las imágenes I y GT de tus funciones TruePositives, TrueNegatives, FalsePositives y FalseNegatives, usaste el Vect3b, pero las dos imágenes deben ser uchar. El foregroundMask es de tipo uchar, tu gt hay que transfromarlo a uchar, puedes usar la función cvtColor(gt_aux, gt, cv::COLOR_BGR2GRAY);
- T5HOM_1: Faltó la reproyección de los puntos con la
homografía correspondiente.
- T6_1: Faltó entregar el reporte.
- T6_2: Puedes aprovechar los parámetros de la función median de MatLab: median(BG_medianatemp,3). De esta forma calculas la mediana para todo tu volumen en la tercera dimensión (tiempo).
- T6_3: En tu reporte dices que los videos de prueba provienen de la base de datos del VOT, sin embargo esto es erroneo, los videos provienen de la base de datos del changedetection.
- T6_4: En tu código consideraste la suma de las
intensidades de los pixeles de cada frame como el valor a
ordenar, al final tu mediana es uno de los N frames (o el
promedio entre dos frames), por está razón, tus medidas ROC
son ligeramente más bajas que usando el promedio. Nota que
esto es diferente a calcular para cada pixel la mediana de
todos los posibles valores que puede tomar en los N frames.
- T6_5: En tu reporte mencionas que utilizaste el mismo modelo de fondo promedio visto en clase, sin embargo en tu código aplicaste un umbral:
if(frame_Gray(j,k) < BG_promedio(j,k) + 20)
BG_promedio(j,k)=BG_promedio(j,k)+frame_Gray(j,k);
end
No hay una explicación acerca de esto en tu reporte, solo se
observa que hay huecos negros en tu modelo de fondo promedio.
- T6_6: Plagio de tarea.
- T6_7: En tu código consideraste el filtro de la mediana espacial, sin embargo, el ejercicio es calcular la mediana temporal para cada pixel (ver T6_2).
- T6_8: Tienes un detalle en tu código al momento de calcular la mediana de los N frames, esto lo puedes arreglar de la siguiente manera:
k=1;
for i=ini:fin
frame_RGB=read(video,i);%escala RGB
frame_Gray=double(rgb2gray(frame_RGB));%double y gray
for i_r=1:video.Height
for i_c=1:video.Width
%BG_mediantemp(i_r,i_c,i) = frame_Gray(i_r,i_c);
BG_mediantemp(i_r,i_c,k) = frame_Gray(i_r,i_c);
end
end
k=k+1;
end
Sin embargo, nota que la copia de los frames a tu variable
BG_mediantemp, es muy lento, podrías cambiar los dos ciclos
internos, por solo la siguiente asignación:
BG_mediantemp(:,:,k) =
frame_Gray(:,:);
- T6_9: La actualización de tu modelo de fondo no puede ser
el filtro de la mediana espacial de la imagen binaria $b$.
- T6_10: En tu reporte no realizaste la comparación cuantitativa.
- T6_11: Tienes un detalle al restar el valor de intensidad de tipo uchar con el valor de tu modelo de fondo de tipo uchar:
r = (grayVideo -
BGmediana).astype(np.double)
La
conversión a double debería de ser antes, por ejemplo:
r =
(grayVideo.astype(np.double) - BGmediana.astype(np.double))
- T6ROC_1: Faltaron los puntos 2 y 3 de la tarea, es decir los análisis cualitativo y cuantitativo.
- T7_1: El programa que implementaste no corresponde a la
tarea asignada.
- T8_1: Ya que BG y T en tus funciones SAD y SSD, son del tipo unit8, entonces al momento de realizar las restas, no permites valores negativos, por esta razón no encuentras el template aunque lo recortes de la imagen original.
- T8_2: Para el caso de tu función Entropiaaa, el mínimo lo estas buscando en Hist, la cual en tu código, todo el tiempo es cero.
- T8_3: Faltó probar la Entropía Conjunta.
- T8_4: Confundiste la medida de Entropía Conjunta por la Correlación cruzada normalizada.
- T8_6: Ya que la inicialización de tu variable que guarda
los residuales es 1, tus procedimientos para calcular SAD,
SSD y Correlación cruzada, pueden fallar. Para tus
procedimientos SAD y SSD conviene que pongas una
inicialización más grande, por ejemplo: ones
(size(I2))*1e8; y para la correlación cruzada te conviene
que sea pequeña: zeros (size(I2));
- T8_7: Faltó buscar la posición del mínimo o el máximo de la medida de similitud utilizada.
- T8_8: Faltó adjuntar el archivo de la función que calcula el histograma conjunto.
- T8_9: Faltó programar las medidas: SAD, SSD y Entropía Conjunta.
- T8_10: En el cálculo de la correlación cruzada
normalizada, hay que considerar que el promedio de las
intensidades del template solo se calcula una sola vez.
- T8_11: Faltó analizar las medidas usando templates que no
fueran extraidos de la imagen original.
- T9_1: Avance de proyecto: regular.
Proyectos:
Posibles proyectos: ProcesamientoVideo_Proyectos.pdf
Bibliografía:
- Alan C. Bovik. 2009. The Essential Guide to Video Processing (2nd ed.). Academic Press.
- Richard Szeliski. 2010. Computer Vision: Algorithms and Applications (1st ed.). Springer-Verlag New York, Inc., New York, NY, USA.
- Corke, Peter. Robotics, vision and control: fundamental algorithms in MATLAB. Vol. 73. Springer Science & Business Media, 2011.
-
Sonka, Milan, Vaclav Hlavac, and Roger Boyle. Image processing, analysis, and machine vision. Cengage Learning, 2014.
-
Bouwmans, T., Porikli, F., Höferlin, B., & Vacavant, A. Background modeling and foreground detection for video surveillance. 2015.