CORREOS

jbarajas@unicauca.edu.co,barajascastillo@hotmail.com

Video navegacion de un robot movil en interiores no controlados

PUBLICACIÓN FINAL

En la figura anterior se observan los videos que fueron utilizados para verificar el funcionamiento del sistema de navegación.
A continuación se hace una descripción breve de cada uno de los videos utilizados:

Pasillo1: Este video video simula al robot móvil recorriendo un pasillo con bajas condiciones lumínicas, lo hace de izquierda a derecha avanzando continuamente

Pasillo2: Este video presenta condiciones medias de iluminación, en el se observan 3 posibles caminos alternativos en diferentes planos, además se simula al robot recorriendo el pasillo de un lado a otro avanzando continuamente a través de el.

Pasillo4: Recorriendo un pasillo en condiciones de luz altas.

Puerta2: Se recorre una pared hasta encontrar un camino alternativo en condiciones de luz bajas.

Video1: Un pasillo largo con condiciones altas de luz, con caminos alternativos ala derecha y a la izquierda.

Video3: El mismo pasillo2 pero en condiciones altas de luz .

Puerta: un video en condiciones media de luz en el que se recorre una puerta de extremo a extremo.

Video2: Un pasillo corto en condiciones altas de luz, se recorre a través de su centro hasta encontrar uno de los caminos alternativos.

Puerta1: es la continuación de pasillo1 después de recorrer el pasillo se encuentra las puertas del fondo.

En la siguiente figura se observan los resultados obtenidos del sistema de navegación visual implementado en matlab tras cargar el viseo pasillo2.

En la anterior tira de imágenes se observa que se detectan los tres posibles caminos alternativos, se los puede identificar en la figura anterior en la primera fila, tercera fila segunda columna, quinta fila segunda columna y las órdenes giren a la izquierda o derecha según la ubicación.

PROCESAMIENTO DE LAS FRAMES

Debido a que la velocidad a la que circulara el móvil es bastante pequeña y debido a que el video es de 25 frames por segundo, no se considero la necesidad de hacer un procesamiento de toda esta cantidad de imágenes ya que tomara de mucha carga computacional siendo esto totalmente innecesario, debido que la información por frame que cambia en esa pequeña cantidad de tiempo es muy poca y no será de mucha utilidad ala hora de guiar al robot o ubicar los caminos alternativos asi que como solución a esto se propone el muestreo de las imágenes cada cierta cantidad de frames.
Como cada video tiene 25 frames por segundo solo será necesario tomar un frame de los 25 para ser procesado cada segundo, quiere decir esto que se procesara una frame por segundo del video, el costo computacional por cada frame procesada es aproximadamente 1.3 segundos.
Cuando se utilizo la cámara web con resolución de 600*800 fue suficiente para dotar al sistema de la información necesaria y que este respondiera de manera correcta, dotando de un frame cada 1.2350 segundos aproximadamente a este ,que es lo que tarda el algoritmo en procesar cada imagen y mostrar el resultado, de esta manera eliminando la gran cantidad de información que provee la cámara que es de 24 cuadros por segundo que da la sensación al observador de estar viendo una imagen continua del mundo real pero que para el sistema no es necesaria.
Se experimento con diversas cámaras que proveían diferente resolución al sistema obteniendo los mejores resultados con cámaras mayores a 3 mega pixeles, con cámaras de menor resolución el sistema no era capas de detectar las líneas puesto que estas no se definían bien en la imagen tomada.
Se tubo problemas con las condiciones de luminosidad del entorno puesto que este no es controlado esta prueba fue efectuada con una cámara web con resolución de 600*800, se disminuyo en gran medida este problema utilizando una cámara con autoajuste de intensidad lumínica que dio óptimos resultados en ambientes con intensidad lumínica cambiante.

Resultados obtenidos.

La solución propuesta para el procesamiento continuo de imágenes con un banco de videos ,la cual era de muestrear continuamente cada cierta cantidad de imágenes ,mostro buenos resultados ya que no era necesario procesar la gran cantidad de información que provenían de el video cargado ,que era de 30 frames por segundo, fue suficiente con procesar cada cierta cantidad de frames para dotar al sistema de la información suficiente para que este respondiera a los cambios de dirección en el camino y la detección de caminos alternativos ya que se considera que el robot no va a gran velocidad.

Cuando se utilizo la cámara web con resolución de 600*800 fue suficiente para dotar al sistema de la información necesaria y que este respondiera de manera correcta, dotando de un frame cada 1.2350 segundos aproximadamente a este ,que es lo que tarda el algoritmo en procesar cada imagen y mostrar el resultado, de esta manera eliminando la gran cantidad de información que provee la cámara que es de 30 cuadros por segundo que da la sensación al observador de estar viendo una imagen continua del mundo real pero que para el sistema no es necesaria.

Se experimento con diversas cámaras que proveían diferente resolución al sistema obteniendo los mejores resultados con cámaras mayores a 3 mega pixeles, con cámaras de menor resolución el sistema no era capas de detectar las líneas puesto que estas no se definían bien en la imagen tomada.

Se tubo dificulatades con las condiciones de luminosidad de algunos entornos , puesto que este no es controlado ,esta prueba fue efectuada con una cámara web con resolución de 600*800, se disminuyo en gran medida este problema utilizando una cámara con autoajuste de intensidad lumínica que dio óptimos resultados en ambientes con intensidad lumínica cambiante.

Diseño de la solución del sistema para procesamiento continúo de imágenes.

Para dar solución al problema de la adquisición continua de imágenes se procedió a crear dos soluciones, la primera solución fue crear un archivo de videos tomados con una cámara Samsung de 5 megapixeles, estos videos simularan a un robot móvil el cual sigue una trayectoria en un entorno cerrado a través de un pasillo en entornos no controlados ,esta cámara fue colocada sobre una silla con ruedas la cual se encontraba a una altura de 47cm la cámara fue coloca en dirección al horizonte y ubicada paralela a esta ,se tomo el programa que se realizo para el procesamiento de fotos de pasillos y caminos alternativos y se le agrego un pequeño código para que tomara muestras cada cierta cantidad de imágenes del video(Frames),esto debido a que la velocidad a la que circulara el móvil es bastante pequeña y debido a que el video es de aproximadamente de 30 frames por segundo, no se considero la necesidad de hacer un procesamiento de toda esta cantidad de imágenes ya que tomara de mucha carga computacional siendo esto totalmente innecesario, debido que la información por frame que cambia en esa pequeña cantidad de tiempo es muy poca y no será de mucha utilidad ala hora de guiar al robot o ubicar los caminos alternativos asi que como solución a esto se propone el muestreo de las imágenes cada cierta cantidad de frames.
Adquisición de imágenes y video con Matlab

“Pasos para la adquisición de imágenes:

Creación: Crear un objeto de entrada de vídeo

Configuración: Definir las propiedades del objeto y visualizar propiedades de la configuración

Adquisición: Se adquieren datos del objeto de entrada de vídeo

Finalización: Se borra el objeto de entrada de vídeo que ha sido
Creado”
Tomado de Http:omarsanchez.net/Documents/Imagen_Fundamentos_II.pdf
A continuación se observa el código agregado para el muestreo de frames.
Clc

obj= mmreader('puerta1.mpg') cargamos el video
g=0;variable auxiliar
numFrames = get(obj, 'numberOfFrames');extraemos el numero de frames
if numFrames > 50
Fra = 50; linitamos el numero de frames que queremos procesar
else
Fra= numFrames;
end

for i=1: Fra ciclo for para cada frame a procesar

g=3*i; % en esta parte indicamos cada cuatas frames hacer el %%procesamiento

if(g< numFrames )
RGB = read(obj,g); guardamos la frame para su respective procesamiento


RGB = imresize(RGB, [300 400]); %B devuelve la imagen que es la escala veces el tamaño de la entrada A.
I = rgb2gray(RGB); % convert to intensity
BW = EDGE(I,'canny',[0.1 0.2],2); % extract edges
Continua el mismo programa anterior….
end


la segunda solución fue mediante la utilización de una web-cam de 600*800 ubicada con las mismas características mencionadas en la solución 1,solo que se tomara cada frame que se adquiera de la cámara web cada 1.2350 segundos aproximadamente que es el tiempo que le toma al programa el procesamiento de cada imagen, al realizar pruebas se obtuvo que este es suficiente tiempo para que la imagen siguiente le dote de información nueva al sistema para hacer las correcciones necesarias de posición o de ubicación del camino.

A continuación se observa el código para la obtención de imágenes en tiempo real con cámara web.
vid = videoinput('winvideo',1);% Define objeto para adquirir imagen
preview(vid);% muestra el video
for i=1:30 % indico al programa que es para 30 frames

RGB = getsnapshot(vid);% capturo la imagen en ese instante t del video.


RGB = imresize(RGB, [300 400]); %B devuelve la imagen que es la escala veces el tamaño de la entrada A.
I = rgb2gray(RGB); % convert to intensity
BW = EDGE(I,'canny',[0.1 0.2],2); % extract edges
Continua el mismo programa...

Se observa que solo fue necesario cambiar las cabeceras del programa anterior para la adquisición continua de imágenes.

Análisis del costo computacional

En este proyecto se ha realizado un sistema de percepción visual en tiempo real cuya fiabilidad y robustez depende directamente de la velocidad en el tratamiento de las imágenes. Un robot Capaz de procesar mayor cantidad de imágenes por segundo podrá detectar, seguir y predecir a mayor velocidad los cambios en su entorno y en definitiva de interactuar con este con mayor fiabilidad. Con el fin de evaluar la velocidad de procesamiento del presente proyecto se ha realizado un estudio del tiempo de ejecución del algoritmo sobre distintas plataformas de Procesamiento.

Para realizar dicho estudio en unas condiciones similares a las de funcionamiento real, se tomo un video del banco de videos el cual simula a un robot con una cámara montada que realiza un recorrido por un entorno cerrado no controlado.

En el video se pretende recoger una razonable variedad de escenas con las que el robot podría encontrarse durante un recorrido.

A fin de realizar una comparativa, se realizaron pruebas de ejecución del algoritmo implementado sobre un conjunto de imágenes muestreadas por el algoritmo del video en dos plataformas de procesamiento.
Se tomaron 50 frames del video con las cuales se corrió el algoritmo y se promediaron los tiempos que les tomo procesar cada frames las diferentes plataformas de procesamiento.

Promedios obtenidos:
5.45 segundos por frame con un procesador AMD Turion 64x2 2.1GHz
1.23 segundos por frame con un procesador AMD Atlon 64x2 2.8GHz
Los resultados muestran que el algoritmo responde bien con un procesador de 2.8 GHz pero con un procesador de 2.1 GHz el sistema no tiene buenos resultados ya que este tiempo de ejecución del algoritmo no dotaría de la información necesaria del entorno al sistema para responder de manera adecuada al propósito para el cual fue echo.

implementación de la solución y resultados

DISEÑO DEL PROYECTO

clear all
close all
clc

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%PREPROCESAMIENTO DE LA IMAGEN%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

RGB = imread('20.jpg');%cargamos la imagen
RGB = imresize(RGB, [300 400]);% devuelve la imagen que es la escala veces el tamaño de la entrada A.
I = rgb2gray(RGB); % convierte a escala de grises

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%PROCESAMIENTO DE LA IMAGEN%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

BW = EDGE(I,'canny',[0.1 0.2],2); %extraemos los ejes,ajustando los parametros
[H,theta,rho] = hough(BW);%%aplicamos la transformada de Hough
P = houghpeaks(H,20,'threshold',50); %%encontramos los picos
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%SEGMENTACION%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
try %%%%%%%%%solucion del error en caso de no detectar ninguna linea
lines = houghlines(BW,theta,rho,P,'FillGap',10,'MinLength',40);
catch
d=size(lines)
end
d=size(lines)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
buscando=0;
imshow(RGB),hold on
if d(1,2) > 1 %%%%%%solucion del error en caso de no encontrar ninguna linea mediante Hough
a=0;
p=0;
b1=0;%%%inicializamos las variables auxiliares
b2=0;
lon=0;

z=length(lines);
for k = 1:z %%hacer para todas las lineas detectadas
xy = [lines(k).point1; lines(k).point2];%% dibujar cada una de las lineas

plot(xy(1,1),xy(1,2),'x','LineWidth',2,'Color','yellow');%%%colorear el punto en x,y de la linea de inicio en amarillo
plot(xy(2,1),xy(2,2),'x','LineWidth',2,'Color','red');%%%%%%colorear el punto en x,y de la linea de inicio en rojo

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%EXTRACCION DE CARACTERISTICAS%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%se eliminan lineas verticales y horizontales que no son de interes
%se toman los puntos mas cercanos al piso como las lineas de interes para
%guiar al robot

% se ubican las lineas de interes de la derecha
if(xy(1,1)+20150 && xy(2,1)>200)
plot(xy(:,1),xy(:,2),'LineWidth',2,'Color','green');

if (xy(2,2)>a)
a= xy(2,2);
b=k


end

b1=1;%%variable auxiliar
end


%se ubican las lineas de interes de la derecha izquierda
if(xy(1,1)+20xy(2,2)+10 && xy(1,2) >150 && xy(1,1)<200)>p)
p= xy(1,2)
d=k


end
b2=1;%%variable auxiliar
end



end


if (b1==1&&b2==1) %%en caso de ubicar las dos lineas del camino que cumplan con las condiciones entrar.

xyd = [lines(b).point1; lines(b).point2];
plot(xyd(2,1),xyd(2,2),'x','LineWidth',8,'Color','blue');
xyi = [lines(d).point1; lines(d).point2]; % dibujar en azul los puntos que serviran de guia al robot
plot(xyi(1,1),xyi(1,2),'x','LineWidth',8,'Color','blue');
lon=norm(lines(d).point1- lines(b).point2) %%encontar la norma de los puntos en azul

mitadcamino=xyi(1,1)+(lon/2)%%%ubicar la pocicion en x donde esta la mitad del camino

%%%%ubico con x la posicion del camino a seguir con respecto a la pocicion
%%%%de la camara.
plot(mitadcamino,xyi(1,2),'x','LineWidth',20,'Color','white');% centro del camino en blanco
plot(200,xyi(1,2),'x','LineWidth',20,'Color','black');%centro de la camara en negro

diferencia=mitadcamino-200%%% calculo la desviacion de la camara con respecto al camino

if(lon >120)%%establesco que la longitud de los puntos de las lineas del camino a seguir tiene que ser mayor a 120 pixeles

if (diferencia >-20 && diferencia <20)>21)
title('gire ala derecha')
end

if (diferencia <-21) title('gire ala izquierda') end end end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if (b1==1 && b2==0)%%%en caso de encontrar solo una linea con las caracteristicas %%ya sea a la derecha o ala izquierda tomar la decicion. title('gire ala izquierda') end if (b1==0 && b2==1) title('gire ala derecha') end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if (b1==0 && b2==0) %%% en caso de no encontrar ninguna linea que cumpla con las caracteristicas mostrar buscando... title('buscando...') buscando=1; %% variable auxiliar end if (lon <120 b1="=" b2="=" buscando="1;" buscando="=" bw =" edge(I,'sobel',[],'vertical');" p =" houghpeaks(H,20,'threshold',50);" lines =" houghlines(BW,theta,rho,P,'FillGap',20,'MinLength',80);" hi="size(lines)%lines=" hi="size(lines)"> 1
t=0;
incp=0;
absoluto=0;
con=0;
aga=0;
lineas=0;
z=length(lines);

for k = 1:z
xy = [lines(k).point1; lines(k).point2];
plot(xy(1,1),xy(1,2),'x','LineWidth',2,'Color','yellow');
plot(xy(2,1),xy(2,2),'x','LineWidth',2,'Color','red');


if(xy(1,1)*1.15>xy(2,1)&& xy(1,1)*0.8t)
t= xy(2,2);
t1=k
aga=1;
end

end

end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



if aga==1 %%%% si encuentra ese punto mas a bajo colorearlo de azul con una x%%%%%%%%%%%%%%%%%%%%%
xyp = [lines(t1).point1; lines(t1).point2];
plot(xyp(2,1),xyp(2,2),'x','LineWidth',20,'Color','blue');
y1=xyp(1,2)
x1=xyp(1,1)
y2=xyp(2,2)
con=0;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%condiciones sobre donde no puede estar ubicado el punto azul
if x1 >389
x1=389
end

if x1 <11 x1="11" k1 =" y1:y2" h1="I(k1,x1-10);" lineas="(y2-y1);" h2="I(k1,x1+10);" lineas="(y2-y1);">15) %%si la variaciones son mayores a 15 entonces incrementa con
con=con+1;

end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%en absoluto guardo la variacion de cada uno de los pixeles de la
%%%izquierda y la derecha buscando homogeneidad
if(h1>h2)
absoluto=h1-h2
end

if(h1(lineas/2)) %%si la variaciones que encontro con son mayores
%%%a la mitad de los pixeles de las lineas verticales alladas entonces
%%%se detecta como camino alternativo
for k1 = y1:y2


plot(x1+20,k1,'x','LineWidth',10,'Color','blue');
plot(x1-20,k1,'x','LineWidth',10,'Color','blue'); %%dibujo el camino alternativo


end
end
end


end


end


RESULTADOS OBTENIDOS

En esta sección se muestra algunos resultados de la experimentación realizada con el método propuesto. Para validar el método se ha realizado dos tipos de pruebas. Mediante la primera se pretende determinar el éxito en la detección de caminos alternativos en imágenes que efectivamente muestran caminos alternativos que el robot pueda encontrar durante su trayectoria. Con la segunda se pretende comprobar que el método detecta correcta mente las líneas de las esquinas de las paredes para poder guiarse a través del pasillo por el cual el robot tendrá que navegar .En el primer caso se han usado un total de 10 imágenes de distintos tipos de caminos alternativos tomadas desde diferentes perspectivas y desde diferentes distancias simulando a un robot que circula por los pasillos, a pesar de que se menciono que la cámara debía estar fija a una altura apuntando siempre a un determinado ángulo se vario la altura y el ángulo para ver la robustez del sistema obteniendo solo malos resultados si se variaba mucho el ángulo ,como era de esperarse puesto que el sistema solo detecta las líneas que sean verticales con cierto porcentaje de inclinación para lo que fue diseñado. En la segunda prueba se han usado 20 imágenes desde diferentes perspectivas sin variar la altitud que fue en un principio de 47 cm dando como resultado que el sistema no detecta ningún falso positivo demostrando un comportamiento robusto.

La figura 5 muestra en la primera fila imágenes de los pasillos con puertas, en la segunda fila se muestra las imágenes tratadas para obtenerlas a escala de grises, en la tercera fila se muestra los resultados de aplicar los filtros de Canny (fila3 colmna1) para detectar los bordes de las esquinas para guiar al robot y Sobel vertical (fila3 columna2) con el cual se obtuvieron mejores resultados que con Canny para el caso de detectar caminos alternativos como es en este caso las puertas.
En la cuarta fila se muestran el conjunto total de segmentos que obtiene el detector basado en la
Transformada de Hough y por ultimo en la fila 5 se hace un filtrado de las líneas que no son de interés y se obtiene la detección del camino y por lo tanto la orden de control respectiva según la ubicación del robot (ver figura 5 fila 5 columna 1), además de ubicación del camino alternativo detectando las esquinas de la puerta (ver figura 5 fila 5 columna2).

FIGURA 5: De arriba a abajo. Imagen original. Todos los
Segmentos detectados. Segmentos candidatos seleccionados.
Puerta mas cercana detectada y camino detectado.