Trabajo Final
Procesamiento Digital de
Señales II: “Visión
Artificial”.
Universidad Nacional de San Luis, Facultad de Ciencias Físico,
Matemáticas y Naturales
Docentes: Petrino, Ricardo.
García, Jesús.
Calderón Sergio.
I ndice
Índice ... 1
Objetivos ... 3
Limitaciones ... 4
Descripción y desarrollo ... 5
Captura de imagen: ... 5
Detección de manos: ... 6
Comparación de imágenes: ... 8
Comparaciones de Control: ... 8
Comparación de procesamiento: ... 10
Lectura de la imagen: ... 10
Captura del nombre de la imagen: ... 10
Lectura de la imagen: ... 11
Calibración: ... 11
Procesamiento: ... 11
Etapa de control previo: ... 11
Etapa de procesamiento: ... 12
Etapa de segundo control: ... 12
Escritura de la imagen: ... 13
Escritura del nombre de la imagen: ... 13
Escritura de la imagen: ... 13
Conclusiones ... 14
Bibliografía ... 15
Anexo I ... 16
Anexo II ... 24
Momentos ... 24
Centro de Gravedad ... 24
Momentos Centrales ... 25
Año: 2012
Cargar Imagen: ... 28
Calibrar: ... 28
Edición: ... 29
Exportar imagen: ... 31
Objetivos
Como objetivo general, el presente trabajo pretende integrar los conocimientos adquiridos en el curso de
Procesamiento Digital de Señales II, desarrollando un código sobre la plataforma MATLAB, versión
7.10(R2010a).
Como objetivo específico, este pretende desarrollar una plataforma de interacción Humano – Máquina
mediante la cual, la computadora podrá identificar determinados movimientos del usuario e
interpretarlos para realizar una acción determinada. Utilizando para ello segmentación por color, por
características de la imagen y por momentos invariantes.
Año: 2012
Limitaciones
Debido a la metodología utilizada para la lectura del movimiento, se presentan las siguientes
limitaciones, y por lo tanto restricciones para el buen funcionamiento, del trabajo:
Deben evitarse la presencia de objetos rojos o tonalidad rojiza acentuada dentro del área de
captura de la cámara, esto se debe a que la primera segmentación se realiza sobre el color,
buscando por tonalidad de piel mediante la matriz de color rojo.
La distancia entre las manos y la cámara debe ser mayor a los 25 cm (veinticinco centímetros), de
forma que las manos sean capturadas completamente por la cámara, pero no mayo a 1 m (un
metro), debido a que una segunda segmentación se realiza por tamaño de área, buscando las de
mayor tamaño, con lo cual las manos deben ser los objetos de tonalidad rojiza de mayor tamaño
en la captura.
Los formatos de imagen permitidos para la lectura y/o escritura de la imagen son: .jpg, .bmp y
.tiff, debiendo estar la imagen a leer en el directorio raíz del programa, y guardándose la imagen
escrita en el mismo directorio.
Debido a la longitud de las operaciones a realizar para la lectura en tiempo real, es probable que
el programa trabaje de manera pausada, con lo cual los movimientos de mando deberán ser
lentos para adecuarse a este inconveniente.
Descripcio n y desarrollo
El presente trabajo culmina en el desarrollo de una Interfaz Gráfica de Usuario (GUI - Graphical User
Interface), en la cual el usuario podrá cargar una imagen determinada, y mediante el movimiento de sus
manos frente a la cámara web indicar a esta que acción realizar sobre ella. En esta instancia las acciones
se limitan a una ampliación horizontal, una ampliación vertical, una ampliación total o una rotación.
Para todo esto el programa realiza distintas operaciones, la cuales serán detalladas a continuación:
Captura de imagen: con la finalidad de generalizar la utilización del código a distintas
computadoras y/o cámaras utilizadas para la adquisición de datos, y que además esta ultima
trabaje en su mayor resolución, a fin de conseguir mejores resultados, el código presenta un primer
control en el cual analiza la información referente al dispositivo de video instalado, detectando las
distintas resoluciones a las cuales puede trabajar, y seleccionando la mayor de todas, esto es:
La función imaqhwinfo devuelve en la variable cam la información correspondiente al dispositivo
winvideo como una estructura,
El campo SupportedFormats entrega un arreglo de todos los formatos de captura admitidos por la
imagen (RGB24_352x288, YUY2_640x480, etc.), y los ordena de forma ascendente en cuanto a
resolución, con lo cual para obtener la mayor se utiliza el último elemento de dicho arreglo. Una
vez determinada la resolución a utilizar se establece un canal de video mediante la función
videoinput pasándole los parámetros correspondientes. Además se analiza el formato en que se
Año: 2012
Una vez completada la configuración del dispositivo, se inicia el canal de video mediante la
función start y al finalizar se debe cerrar mediante el comando delete, esto último es importante
tenerlo en cuenta ya que MATLAB no permite inicializar dos canales de video simultáneamente.
Finalmente la captura propiamente dicha se realiza con el comando getsnapshot, el cual devuelve la
imagen capturada por la cámara en ese momento.
Detección de manos: la detección de manos se realiza mediante detección de piel,
particularmente mediante detección de tonalidades rojizas (de esto la restricción de objetos rojos en
el campo visual de la cámara).
Para esto, una vez capturada la imagen se procede a restarle a la matriz R (correspondiente a las
tonalidades rojas), el promedio de ambas matrices, con el fin de disminuir los niveles donde el rojo
no es el predominante, mediante el uso de la función imsubtract
,
el resultado de esto es:
Luego de esto, se aplica a la imagen resultante un ajuste de contraste con el fin de mejorar la
definición de la misma, para ello se utiliza el comando imadjust, y luego mediante la función
graythresh se umbraliza la imagen, quedando de esta forma en blanco todos los objetos en los
cuales predomina la tonalidad roja en su color, de esto se obtienen los siguientes resultados:
Imagen Original
Imagen Resultante
A partir de esta ultima imagen se procede a rellenar los agujeros (imfill) para luego determinar
propiedades, como Area, BoundingBox, Centroid, etc., de cada objeto en la imagen, a partir del área
de estos, y haciendo uso del enfoque de la cámara, se buscan las dos áreas de mayor tamaño en la
imagen (de esto la restricción de distancia) suponiendo que estas serán las manos. Los resultados
de estos procesos son:
Este procedimiento es muy susceptible a la iluminación del ambiente, debido a que de no ser
uniforme, podría detectarse parcialmente las manos, como así también es susceptible a la presencia
de objetos de tonalidad rojiza, debido al trabajo directo sobre la matriz del rojo, con lo cual, en
definitiva, requiere un ambiente controlado, dentro de ciertos márgenes, para su correcto
funcionamiento.
El código final utilizado para la detección de manos queda como
Imagen sin Agujeros
Imagen Final
Año: 2012
Comparación de imágenes: para poder detectar e interpreta lo movimientos de las manos, es
necesario realizar una captura continua de imágenes, y compararla siguiendo un método
determinado. Estos métodos pueden realizarse a partir de las propiedades de la imagen, tales
como el área, la orientación, etc., como así también por su firma o sus momentos invariantes de
Hu
1
.
En el presente trabajo se realizan 3 tipos de comparaciones, dos de las cuales corresponden a
etapas de control, y la tercera al procesamiento propiamente dicho.
Comparaciones de Control:
dado que el procesamiento solo analiza el movimiento de la
imagen, detectando solo los objetos de mayor tamaño es necesario hacer un primer control,
de modo que este no inicie hasta haber detectado realmente las manos; además se debe
realizar un segundo control de forma permanente con el objetivo de constatar que aun se
encuentran presentes las manos de forma correcta.
El primer control debe ser preciso, dado que de este depende el correcto funcionamiento del
programa, en caso de fallar este, el procesamiento se realizaría de forma inadecuada,
detectando movimiento de objetos indeseados. Debido a esta precisión necesaria, y sumado el
hecho que al estar las manos en constante movimiento se pueden producir leves rotaciones de
estas, se opta por utilizar los momentos invariantes de Hu para este primer control. Previo al
control, debe realizarse una calibración, para establecer la imagen patrón de para este; esto se
debe a que las condiciones ambientales (objetos del entorno, iluminación, etc.) no serán
siempre las mismas con lo cual se vuelve necesario este primer paso. Este control, entonces,
consistirá en la comparación de los momentos invariantes de la imagen patrón con los
momentos invariantes de la última imagen capturada.
El segundo control debe ser más flexible que el primero, dado que se realiza de forma
continua, nuevamente se presenta el inconveniente de la iluminación, con lo cual debe
permitir que el proceso siga aun cuando la detección de las manos ha cambiado, pero estas
aun siguen presentes. Es por ellos que este se realiza a partir de las propiedades de la imagen.
Como la mayor parte de las propiedades de la imagen cambian ante variaciones de la
iluminación, el control se realiza por el área del BoundingBox que contiene la mano, es decir se
compara que el área del BoundingBox de la ultima detección no decaiga dentro de un rango
determinado del área del BoundingBox de la imagen inicial. A continuación se presenta un
caso de problemas de iluminación, el cual no genera inconvenientes al control:
Año: 2012
Se puede observar que si bien, a causas de la iluminación, las manos no fueron detectadas
completamente, el área del BoundingBox que las contiene no se vio afectada en gran medida,
con lo cual esta etapa de control interpretaría que la mano aun esta presente.
Comparación de procesamiento:
para decidir el tipo de procesamiento a realizar como así
también la magnitud de la modificación debe analizarse en la imagen la variación de la
posición de las manos en ella, conforme transcurre el tiempo. Para ello se realiza una
comparación de las características, entre la ultima imagen tomada y la primera imagen que se
tomo como valida en la etapa del primer control. Dado que el programa admite dos tipos de
procesos (ampliación o rotación) se utilizan dos características para analizar el movimiento
(Centroid, los centros para para la ampliación, y Orientation, la orientación para la rotación).
Haciendo uso de estas operaciones, el código del programa se divide en 4 partes fundamentales:
Lectura de la imagen: engloba las operaciones de captura del nombre de la imagen, y lectura
de la misma. En el código esto se observa como dos funciones separadas:
Captura del nombre de la imagen:
la interfaz posee un campo en el cual el usuario podrá
escribir el nombre de la imagen, el cual deberá cumplir con el siguiente formato: “nombre
imagen.extensión”. Por ello la función posee una etapa de control que asegura la correcta
especificación. Además dado que se ha limitado el programa a trabajar solo con formatos de
imagen “.jpg”, “.bmp” y “.tiff”, la función incluye el control correspondiente a las
extensiones. En caso de presentarse algún error en alguno de los controles, se contempla el
aviso correspondiente al usuario.
2
2
Código del programa, NOMBRE DE ENTRADA, Anexo 1.
Lectura de la imagen:
una vez adquirido el nombre se procede a la lectura de dicha
imagen, para ellos se utiliza la función imread. La función de lectura contempla además la
muestra de la imagen original en un sector de la interfaz, a fin de servir de referente de
comparación visual para el usuario.
3
Cabe aclarar que para poder ser leída la imagen debe encontrarse en el directorio raíz del
programa.
Calibración: esta etapa se vuelve de gran importancia al momento de generalizar los posibles
ambientes de trabajo del programa. Dadas las condiciones cambiantes de iluminación, y las
grandes variedades de formas y colores de los objetos del ambiente dentro del alcance de la
cámara, se hace necesario el uso de esta etapa con el fin de asegurar una detección correcta, como
así también el adecuado control previo al procesamiento. En esta función el usuario captura una
imagen, al presionar un botón, la cual luego es mostrada indicando los objetos detectados. El
usuario deberá repetir la acción hasta que la imagen mostrada detecte correctamente las o la
mano
4
, dependiendo de la operación a realizar. Es esta imagen la que luego se utilizara como
comparación para el primer control, con lo cual se debe asegurar que la detección sea los mas
precisa posible. Una vez detectada las manos, se calculan los momentos invariantes de estas, con
los cuales se realizará un posterior control, y por ultimo se determina si se va a realizar una
ampliación o una rotación de la imagen, utilizando para ello las propiedades de los objetos
detectados, en particular el Area de los objetos detectados. Si el Area, del objeto de mayor área, es
mayor a dos veces el Area, del segundo objeto de mayor área, supondrá la presencia de una única
mano abierta, con lo cual interpretará una acción de rotación, caso contrario supondrá la presencia
de dos manos, las que indicaran una acción de ampliación.
5
Procesamiento: en esta etapa se concentra la detección de la cámara y el procesamiento
propiamente dicho. Esta consta a su vez de una etapa previa de control, seguida del procesamiento
de la imagen cargada por el usuario, junto a la cual se realiza de forma continua el segundo
control.
6
Etapa de control previo:
partiendo de lo antes mencionado sobre los métodos de
comparación, este control se realiza mediante la comparación de los momentos invariantes de
Hu de la imagen de calibración y la ultima imagen capturada por la cámara. Para otorgarle
cierto grado de flexibilidad, debido a los cambios en las sombras a causa de la iluminación, la
Año: 2012
comparación se realiza con un margen de ±30%, sobre los dos primeros momentos de las
imágenes. De esta forma, si la imagen capturada posee su dos primero momentos dentro del
rango especificado se supondrá que se han detectado las manos de forma correcta con lo cual
la etapa de control será superada; en caso de no cumplirse la condición se repetirá la captura
de una nueva imagen y se realizaran los procesamientos y cálculos necesarios para una nueva
comparación hasta cumplirla.
Etapa de procesamiento:
una vez superado la etapa anterior, se vuelve a capturar una
imagen, a partir de la cual se hará el procesamiento adecuado para detectar las manos y así
comparar sus propiedades, como se menciono antes, para luego realizar la acción
correspondiente. De acuerdo a lo detectado durante la etapa de calibración, esta fase realizara
uno de dos procesos posibles.
Expansión: en este proceso se realizaran detecciones de desplazamientos horizontales y/o
verticales de las manos, a partir de los centros de los objetos detectados, y en base a los cuales
se realizara una modificación proporcional en el ancho y/o alto de la imagen
respectivamente. Para ello, luego de realizar la comparación pertinente, se utiliza el comando
imresize.
Rotación: en este proceso se detecta la rotación de la mano, basándose en la orientación del
objeto detectado, y a partir de ella se realiza una rotación proporcional a la primera. Para esto,
luego de las comparaciones necesarias, se hace uso del comando imrotate.
Etapa de segundo control:
previo procesamiento, y posterior a la etapa de control previo se
realiza un control adicional con el fin de constatar que los objetos detectados son los
deseados. En esta etapa el control se realiza partiendo de lo antes mencionado sobre métodos
de comparación, haciendo uso de las propiedades de la imagen, mas precisamente del
BoundingBox y de su área, calculada como el ancho del mismo por el alto de este, por las
razones expuestas anteriormente. Para otorgarle aun mas flexibilidad se establece que el
objeto detectado seguirá considerándose una mano mientras esta área no caiga por debajo de
dos tercios del área de los objetos detectados en la primera etapa de control, calculada del
mismo modo. Si el área de los últimos objetos detectados se mantienen por encima de este
umbral, se continuara con el procesamiento especificado; en caso de que el área decaiga por
debajo del mismo, se anulara la esta de procesamiento y se volverá a la etapa de control
previo en con el fin de volver a detectar las manos, conforme la imagen patrón otorgada por
la etapa de calibración.
Escritura de la imagen: al igual que la etapa de lectura, esta engloba dos tareas que en el
código se observan en dos funciones separadas:
Escritura del nombre de la imagen:
esta función prevé las mismas restricciones y
controles que el correspondiente a la captura del nombre en la lectura de la imagen.
Nuevamente se deberá cumplir con el formato de escritura “nombre imagen.extensión” y los
formatos admitidos serán “.bmp”, “.jpg” y “.tiff”.
7
Escritura de la imagen:
una vez escrito el nombre de la imagen de salida, se realizara la
escritura de la misma, la cual corresponde a la ultima imagen modificada en la etapa de
procesamiento, a partir del comando imwrite. Cabe aclarar que la imagen resultante será
guardada con el nombre y extensión determinados previamente, en el directorio raíz del
código.
8
Año: 2012
Conclusiones
Frente a un mundo tecnológico que evoluciona hacia dispositivos capaces de adaptarse e interaccionar
con los movimientos de sus usuarios, el desarrollo de software capaz de detectar movimientos y
acciones, pudiendo además interpretarlos y actuar de acuerdo a estos se vuelve una tarea de gran
importancia.
Ante este desarrollo existen, principalmente, dos grandes complicaciones a vencer. La primera radica en
la complejidad y extensión de las operaciones a realizar. El cálculo matricial para el acondicionamiento y
comparación de imágenes, se vuelve costoso y prolongado cuando existe un hardware dedicado y
optimizado para esto. Mientras que la segunda esta dada por la naturaleza cambiante y variada del
ambiente, tanto en los fondos que se puedan presentar como la iluminación ambiental. Esto hace
necesario el uso de múltiples focos de adquisición y/o una calibración previa al proceso propiamente
dicho.
Superados estos inconvenientes, las posibilidades de aplicación de dicho software abarcan una amplia
gama de necesidades y soluciones. Desde la industria, como un proceso básico de “visión artificial”,
permitiendo que la maquinaría posea la capacidad de trabajar interactuando con los operarios, hasta el
hogar, tanto en áreas de entretenimiento como en soluciones practicas ante necesidades recurrentes.
Puede observarse uno de los resultados del presente proyecto en
Bibliografí a
Libros:
Digital Image Processing Using MATLAB®. Rafael C. Gonzales. Richard E. Woods. Steven L.
Eddins. Prentice Hall, 2004.
Digital Image Processing, Second Edition. Rafael C. Gonzalez, Richard E.Woods. Prentice Hall.
2002.
Apuntes:
Descriptores de Imagen. Marcos Matín. 22 de Mayo 2002.
Sitios Web:
Año: 2012
Anexo I
function varargout = prueba(varargin)
% prueba M-file for prueba.fig
% prueba, by itself, creates a new prueba or raises the existing % singleton*.
%
% H = prueba returns the handle to a new prueba or the handle to % the existing singleton*.
%
% prueba('CALLBACK',hObject,eventData,handles,...) calls the local % function named CALLBACK in prueba.M with the given input arguments. %
% prueba('Property','Value',...) creates a new prueba or raises the % existing singleton*. Starting from the left, property value pairs are % applied to the GUI before prueba_OpeningFunction gets called. An % unrecognized property name or invalid value makes property % application
% stop. All inputs are passed to prueba_OpeningFcn via varargin. %
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one % instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES % Copyright 2002-2003 The MathWorks, Inc.
% Edit the above text to modify the response to help prueba % Last Modified by GUIDE v2.5 31-Oct-2012 12:16:25 % Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @prueba_OpeningFcn, ...
'gui_OutputFcn', @prueba_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
% --- Executes just before prueba is made visible.
function prueba_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn. % hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to prueba (see VARARGIN) % Choose default command line output for prueba
handles.output = hObject;
% Update handles structure
guidata(hObject, handles);
% UIWAIT makes prueba wait for user response (see UIRESUME) % uiwait(handles.figure1);
% --- Outputs from this function are returned to the command line.
function varargout = prueba_OutputFcn(hObject, eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT); % hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Get default command line output from handles structure
varargout{1} = handles.output;
% --- Executes on button press in iniciar.
function iniciar_Callback(hObject, eventdata, handles)
% hObject handle to iniciar (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)
global br; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
global ps; % %
global mom1; % CODIGO PRICIPAL %
global mom2; % % global cs; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% IMA=handles.imag; alto=imread('control.jpg'); alto2=imread('control2.jpg'); ok=imread('ok.jpg'); pausa=imread('pausa.jpg'); final=imread('final.jpg'); br=0; fin=0; %%%%%%%%%%%%%%% CAPTURA DE IMAGEN DESDE CAMARA %%%%%%%%%%%%%%%%%%
cam=imaqhwinfo('winvideo',1); % Obtiene datos del dispositivo de entrada (camara). %
cformat=size(cam.SupportedFormats); % Determina la cantidad de formatos de adquisicion posibles para dicho dispositivo. %
format=char(cam.SupportedFormats(cformat(2))); % Selecciona el ultimo de los formatos dado que siempre sera el de mayor resolucion. %
canalVideo=videoinput('winvideo',1,format); % Establece un canal de video con el formato de mayor resolucion. %
if format(1)=='Y' % %
set(canalVideo, 'ReturnedColorspace', 'rgb') % En caso de que la señal enviada por la camara sea en estado YUV o YCrCb solicita formato RGB. %
end % %
start(canalVideo); % Inicia el canal de video. %
while (br==0) % Mientras no se haya exportado la imagen. %
while (ps==0) % Mientras no se haya presionado el boton pausa. %
switch cs % La accion a realizar dependera de la imagen capturada en la calibracion. %
case 1 % Se capturaron dos manos con lo cual la accion interpretada es de ampliacion. %
while (fin==0 && br==0 && ps==0) % Este bucle realiza una accion de control, para que no inicie a procesar la imagen leida hasta que la captura sean %
axes(handles.axes5) % manos. %
imshow(alto) %%%%%%%%%%%%%%%% DETECCION DE MANOS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
P=getsnapshot(canalVideo); % Obtiene una imagen del video. %
ima_bg=imsubtract(P(:,:,1), rgb2gray(P)); % Realiza un resta entre la matriz del color rojo y la matriz promedio (escala de grises), para realzar esta tonalidad. %
ima_bg=imadjust(ima_bg); % Aumenta el contraste de la imagen. %
niv=graythresh(ima_bg); % Calcula umbral de la imagen. %
ima_bw=im2bw(ima_bg,niv); % Umbraliza la imagen. %
ima_bw2=imfill(ima_bw,'holes'); % Rellena agujeros, entendiendose estos como sectores negros que no estan conectados con el borde. %
ima_bw3= bwlabel(ima_bw2, 8); % Etiqueta objetos encontrados. %
flag=regionprops(ima_bw3,'Area','Centroid','BoundingBox'); % Determina las caracteristicas AREA, CENTRO y CUADRO DELIMITADOR de cada objeto. %
[N,M]=size(flag); % %
mano1=flag(1); % Los siguientes bucles se encargan de encontrar los dos objetos de mayor AREA, los cuales se suponene son las %
for i=2:N % manosn, mediante comparacion iterativa del AREA de todos los objetos encontrados. %
if flag(i).Area>mano1.Area % % mano1=flag(i); % % j=i; % % end % % end % % mano2=flag(1); % % for i=2:N % %
if flag(i).Area > mano2.Area && i~=j % %
mano2=flag(i); % % end % % end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% axes(handles.axes4) imshow(P) hold on
Año: 2012
man2=imfill(man2,'holes'); % %
mome1=invmoments(man1); % Se calculan los momentos invariantes de las manos, con el fin de utilizarlos para comparar con la %
mome2=invmoments(man2); % imagen de calibración. %
min11=((mom1(1)-0.3*mom1(1))<=mome1(1) && (mom1(1)+0.3*mom1(1))>=mome1(1)); % Se realizan las comparaciones dando un margen de +/- 30% dado %
min12=((mom1(2)-0.3*mom1(2))<=mome1(2) && (mom1(2)+0.3*mom1(2))>=mome1(2)); % a las variaciones que se dan por la iluminacion, sobre los dos %
min21=((mom2(1)-0.3*mom2(1))<=mome2(1) && (mom2(1)+0.3*mom2(1))>=mome2(1)); % primeros momentos. %
min22=((mom2(2)-0.3*mom2(2))<=mome2(2) && (mom2(2)+0.3*mom2(2))>=mome2(2)); % %
if (min11 && min12) || (min21 && min22) % Si se los momentos de la imagen estam demtro del rango, %
fin=1; % se finaliza el bucle, caso contrario se sigue hasta hayar las manos %
end % de forma correcta. %
end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
centrom1= mano1.Centroid; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
aream1=mano1.BoundingBox(3)*mano1.BoundingBox(4); % Se almacenan las propiedades de ambas manos de esta primer imagen para ser utilizadas %
centrom2=mano2.Centroid; % como punto de comparacion durante el procesamiento. %
aream2=mano2.BoundingBox(3)*mano2.BoundingBox(4); % %
cond=0; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
while (cond==0 && ps==0 && br==0) % Una vez detectadas las manos inicia el procesamientos, del cual se encarga este bucle, %
axes(handles.axes5) % mientra el area de las manos no decaiga a menos de 2/3 del area de la primera deteccion de %
imshow(ok) % manos. %
P=getsnapshot(canalVideo); % Se realiza nuevamente la DETECCION DE MANOS, con su respectivo procesamiento. %
ima_bg=imsubtract(P(:,:,1), rgb2gray(P)); % % ima_bg=imadjust(ima_bg); % % niv=graythresh(ima_bg); % % ima_bw=im2bw(ima_bg,niv); % % ima_bw2=imfill(ima_bw,'holes'); % % ima_bw3= bwlabel(ima_bw2, 8); % %
flag=regionprops(ima_bw3,'Area','Centroid','BoundingBox'); % %
[N,M]=size(flag); % % mano100=flag(1); % % for i=2:N % % if flag(i).Area>mano100.Area % % mano100=flag(i); % % j=i; % % end % % end % % mano200=flag(1); % % for i=2:N % %
if flag(i).Area > mano200.Area && i~=j % %
mano200=flag(i); % % end % % end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% axes(handles.axes4) imshow(P) hold on
rectangle('Position',mano100.BoundingBox,'EdgeColor','r','LineWidth',2) rectangle('Position',mano200.BoundingBox,'EdgeColor','r','LineWidth',2)
hold off %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
centrom100= mano100.Centroid; % Se almacenan las propiedades de la ultima captura, a fin de utilizarlas junto con las de la primer %
centrom200=mano200.Centroid; % captura para analizar el procesamiento deseado. %
hor=abs((centrom200(1)-centrom100(1))-(centrom2(1)-centrom1(1)));% Se calcula el desplazamiento horizontal desde la posicion inical (1° cap.) y la final (ultima cap.) %
ver=abs((centrom200(2)-centrom100(2))-(centrom2(2)-centrom1(2)));% De igual forma se calcula el desplazamiento vertical, ambos a partir del centro de las manos. %
fl=0; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
TOT=size(IMA); %%%%%%%%%
if((mano100.BoundingBox(3)*mano100.BoundingBox(4)<=aream1*(2/3) || mano200.BoundingBox(3)*mano200.BoundingBox(4)<=aream2*(2/3))) % %
cond=1; % Se comparan las areas, si la ultima es menor a 2/3 la primera, se cocidera se perdio mano %
else %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if hor>(2*ver) %%%%%%%%%%%%%%%%% AMPLIACION %%%%%%%%%%%%%%%%%
C=imresize(IMA,[TOT(1) round((1+ver/TOT(2))*TOT(2))]); % Si el desplazamiento horizontal es mayor a dos veces el desplazamiento vertical, interpreta una %
fl=1; % ampliacion horizontal, modificando la imagen de forma proporcional al desplazamiento. %
end % %
if ver>(2*hor) % Si el desplazamiento vertical es mayor a dos veces el desplazamiento horizontal, interpreta una %
C=imresize(IMA,[round((1+hor/TOT(1))*TOT(1)) TOT(2)]); % ampliacion vertical, modificando la imagen de forma proporcional al desplazamiento. %
fl=1; % %
else % %
if fl==0 %Si no suceden ninguno de los casos anteriores, interpreta una ampliacion total, tanto horizontal %
C=imresize(IMA,(1+ver/TOT(2))); % como vertical, modificando la imagen de forma proporcional al desplazamiento. %
end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% end axes(handles.axes2) imshow(C) end end fin=0; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 2 % Se capturo una sola mano con lo cual se interpreta que se realizara una rotacion. Se repiten %
while (fin==0 && br==0 && ps==0) % los pasos del caso anterior, el bucle se mantendra bajo las mismas condiciones citadas %
imshow(alto2,'Parent',handles.axes5) % Se realizan los mismos procedimientos que en la DETECCION DE MANOS solo que en %
P=getsnapshot(canalVideo); % este caso se detecta solo el area mas grande, que corresponde a la mano. %
ima_bg=imadjust(ima_bg); % %
niv=graythresh(ima_bg); % %
ima_bw=im2bw(ima_bg,niv); % %
ima_bw2=imfill(ima_bw,'holes'); % %
ima_bw3= bwlabel(ima_bw2, 8); % %
flag=regionprops(ima_bw3,'Area','BoundingBox','Orientation'); % %
[N,M]=size(flag); % % mano1=flag(1); % % for i=2:N % % if flag(i).Area>mano1.Area % % mano1=flag(i); % % j=i; % % end % % end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% axes(handles.axes4) imshow(P) hold on
rectangle('Position',mano1.BoundingBox,'EdgeColor','r','LineWidth',2,'Parent',handles.axes4)
hold off %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
man1 = imcrop(ima_bw, mano1.BoundingBox); % Nuevamente se recortan las manos y se calculan los momentos invariantes, paso seguido se %
man1=imfill(man1,'holes'); % repite la comparacion con los mismos fines que en el caso 1. %
mome1=invmoments(man1); % %
min11=((mom1(1)-0.3*mom1(1))<=mome1(1) && (mom1(1)+0.3*mom1(1))>=mome1(1)); % %
min12=((mom1(2)-0.3*mom1(2))<=mome1(2) && (mom1(2)+0.3*mom1(2))>=mome1(2)); % %
if (min11 && min12) % %
fin=1; % %
end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ang1=mano1.Orientation; % Se almacenan las propiedades de la primer captura para utilizarlas como comparacion para el %
aream1=mano1.BoundingBox(3)*mano1.BoundingBox(4); % procesamiento posterior. %
cond=0; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
while (cond==0 && ps==0 && br==0) % Una vez detectadas las manos se procede de igual forma que en el caso 1, captando una nueva %
axes(handles.axes5) % imagen para utilizarla para compara con la primera y de esta forma decidir el proceso de la imagen. %
imshow(ok) % % P=getsnapshot(canalVideo); % % ima_bg=imsubtract(P(:,:,1), rgb2gray(P)); % % ima_bg=imadjust(ima_bg); % % niv=graythresh(ima_bg); % % ima_bw=im2bw(ima_bg,niv); % % ima_bw2=imfill(ima_bw,'holes'); % % ima_bw3= bwlabel(ima_bw2, 8); % %
flag=regionprops(ima_bw3,'Area','Centroid','BoundingBox','Orientation'); % %
[N,M]=size(flag); % % mano100=flag(1); % % for i=2:N % % if flag(i).Area>mano100.Area % % mano100=flag(i); % % end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ang100=mano100.Orientation; % Se almacenan las propiedades deseadas de la imagen. %
axes(handles.axes4) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
imshow(P) hold on
rectangle('Position',mano100.BoundingBox,'EdgeColor','r','LineWidth',2)
hold off %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
rot=ang100-ang1; % Se calcula la variacion angular entre la primer imagen tomada y la ultima. %
if(mano100.BoundingBox(3)*mano100.BoundingBox(4)<=aream1*(2/3))%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
cond=1; % Al igual que en caso 1, si el area decae a 2/3 de la inicial, se concidera perdida de mano. %
else % %
C=imrotate(IMA,rot); % Se realiza la rotacion deseada modificando la imagen de forma proporcional %
axes(handles.axes2) % a la rotacion de la mano %
imshow(C) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% end end fin=0; end end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
IMA=C; % Cuando es precionado el boton de PAUSA, se sale del bucle anterior y se mantiene en este, hasta que %
axes(handles.axes5) % se presione el boton REANUDAR o se exporte la imagen resultante, finalizando el proceso. %
imshow(pausa) % %
Año: 2012
%
---function cargar_Callback(hObject, eventdata, handles) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% hObject handle to cargar (see GCBO) % % % eventdata reserved - to be defined in a future version of MATLAB % LECTURA DE IMAGEN DESEADA %
% handles structure with handles and user data (see GUIDATA) % %
global ps; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ps=0; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
h=handles.noma; % A partir del nombre ingresado en NOMBRE IMAGEN ENTRADA, se lee la imagen deseada, la cual %
A=imread(h); % debe estar en el directorio raiz del codigo. %
imshow(A,'Parent',handles.axes1); % %
handles.imag=A; % La imagen leida es almacenada en una variable para que pueda se leida por cualquier funcion. %
handles.imagf=A; % %
guidata(hObject,handles) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %
---function exportar_Callback(hObject, eventdata, handles) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% hObject handle to exportar (see GCBO) % % % eventdata reserved - to be defined in a future version of MATLAB % ESCRITURA DE IMAGEN FINAL %
% handles structure with handles and user data (see GUIDATA) % %
global br; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
global n; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C=handles.imagf; % Se toma la imagen final, del codigo principal, y se la guarda con el nombre obtenido en NOMBRE %
br=1; % SALIDA, se activa la bandera br, que indica el fin del proceso. %
imwrite(C,n); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
---function archivo_Callback(hObject, eventdata, handles)
% hObject handle to archivo (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)
function nom_entrada_Callback(hObject, eventdata, handles) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % hObject handle to nom_entrada (see GCBO) % % % eventdata reserved - to be defined in a future version of MATLAB % NOMBRE ENTRADA % % handles structure with handles and user data (see GUIDATA) % % % Hints: get(hObject,'String') returns contents of nom_entrada as text %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % str2double(get(hObject,'String')) returns contents of nom_entrada as a double
abrir=get(hObject,'String'); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
l=size(abrir); % Esta funcion se encarga de racibir en lonmbre del archivo de a ser modificado, el cual debe estar en %
fl1=0; % el directorio raiz del codigo. %
fl2=0; % El nombre del archivo de escribirse como "nom_arch.extrnsion" para que sea valido. %
for i=1:l(2) % Este bucle se encarga de controlar si se escribio la extension, de no ser asi se genera un mensaje con %
if abrir(i)=='.' % el error dado. %
fl1=1; % %
f=i; % %
end % %
end % %
if fl1==0 % %
msgbox('Falta extensión del archivo','Nombre archivo abrir'); % %
else % %
if abrir(f+1)=='j'||abrir(f+1)=='J' % Si la extension ha sido escrita, se procede a controla si es una formato valido. Los formatos validos %
if abrir(f+2)=='p'||abrir(f+2)=='P' % para este codigo son: fpg(FPG), bmp(BMP) y tiff(TIFF). En caso de que la extension especificada no %
if abrir(f+3)=='g'||abrir(f+3)=='G' % corresponda a un formato valido, se genera un mensaje notificando dicho error. %
fl2=1; % % end % % end % % end % % if abrir(f+1)=='b'||abrir(f+1)=='B' % % if abrir(f+2)=='m'||abrir(f+2)=='M' % % if abrir(f+3)=='p'||abrir(f+3)=='P' % % fl2=1; % % end % % end % % end % % if abrir(f+1)=='t'||abrir(f+1)=='T' % %
if abrir(f+2)=='i'||abrir(f+2)=='I' % %
if abrir(f+3)=='f'||abrir(f+3)=='F' % % if abrir(f+4)=='f'||abrir(f+4)=='F' % % fl2=1; % % end % % end % % end % %
end % %
if fl2==0 % %
errordlg('Formato extensión no válido', 'Nombre archivo abrir'); % %
end % %
end % %
handles.noma=abrir; % %
guidata(hObject,handles); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % --- Executes during object creation, after setting all properties.
function nom_entrada_CreateFcn(hObject, eventdata, handles)
% hObject handle to nom_entrada (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');
end
function nom_salida_Callback(hObject, eventdata, handles) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% hObject handle to nom_salida (see GCBO) % % % eventdata reserved - to be defined in a future version of MATLAB % NOMBRE SALIDA %
% handles structure with handles and user data (see GUIDATA) % % % Hints: get(hObject,'String') returns contents of nom_salida as text %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % str2double(get(hObject,'String')) returns contents of nom_salida as a double
global n; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
cerrar=get(hObject,'String'); % %
l=size(cerrar); % Se tienen en cuenta las mismas concideraciones que en NOMBRE ENTRADA, salvo que este sera el %
fl1=0; % nombre con el cual se guardar la imagen final. Las restricciones sobre el formato y las extensiones %
fl2=0; % son las mismas. %
for i=1:l(2) % % if cerrar(i)=='.' % % fl1=1; % % f=i; % % end % % end % % if fl1==0 % %
msgbox('Falta extensión del archivo','Nombre archivo guardar'); % %
else % % if cerrar(f+1)=='j'||cerrar(f+1)=='J' % % if cerrar(f+2)=='p'||cerrar(f+2)=='P' % % if cerrar(f+3)=='g'||cerrar(f+3)=='G' % % fl2=1; % % end % % end % % end % % if cerrar(f+1)=='b'||cerrar(f+1)=='B' % % if cerrar(f+2)=='m'||cerrar(f+2)=='M' % % if cerrar(f+3)=='p'||cerrar(f+3)=='P' % % fl2=1; % % end % % end % % end % % if cerrar(f+1)=='t'||cerrar(f+1)=='T' % %
if cerrar(f+2)=='i'||cerrar(f+2)=='I' % %
if cerrar(f+3)=='f'||cerrar(f+3)=='F' % % if cerrar(f+4)=='f'||cerrar(f+4)=='F' % % fl2=1; % % end % % end % % end % % end % % if fl2==0 % %
errordlg('Formato extensión no válido', 'Nombre archivo guardar'); % %
Año: 2012
% eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');
end
% --- Executes on button press in pausa. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function pausa_Callback(hObject, eventdata, handles) % % % hObject handle to pausa (see GCBO) % PAUSA % % eventdata reserved - to be defined in a future version of MATLAB % % % handles structure with handles and user data (see GUIDATA) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
global ps; % Activa la bandera ps, de forma que la edicion queda en estado pausado. %
ps=1; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% --- Executes on button press in calibrar. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function calibrar_Callback(hObject, eventdata, handles) % % % hObject handle to calibrar (see GCBO) % CALIBRACION % % eventdata reserved - to be defined in a future version of MATLAB % % % handles structure with handles and user data (see GUIDATA) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
global mom1; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
global mom2; % Esta etapa se realiza para obtener un imagen de referencia de las manos, ademas de decidir que tipo %
global cs; % de proceso se le ralizara a la imagen. Esta primer imagen se utiliza para control, de forma que el %
cam=imaqhwinfo('winvideo',1); % procesamiento no inicie hasta que el usuario se haya posicionado correctamente, es decir hasta que %
cformat=size(cam.SupportedFormats); % se hayan detectado las manos. %
format=char(cam.SupportedFormats(cformat(2))); % La captura de imagen y deteccion de manos repiten los procedimientos antes descritos. %
canalVideo=videoinput('winvideo',1,format); % %
if format(1)=='Y' % %
set(canalVideo, 'ReturnedColorspace', 'rgb') % %
end % %
msgbox('Calibrando, posicione las manos y espere que aparezca la imagen y luego presione "Ok".'); % %
start(canalVideo); % % P=getsnapshot(canalVideo); % % ima_bg=imsubtract(P(:,:,1), rgb2gray(P)); % % ima_bg=medfilt2(ima_bg, [3 3]); % % ima_bg=imadjust(ima_bg); % % niv=graythresh(ima_bg); % % ima_bw=im2bw(ima_bg,niv); % % ima_bw2=imfill(ima_bw,'holes'); % % ima_bw3= bwlabel(ima_bw2, 8); % %
flag=regionprops(ima_bw3,'Area','Centroid','BoundingBox','ConvexHull'); % %
[N,M]=size(flag); % % mano1=flag(1); % % for i=2:N % % if flag(i).Area>mano1.Area % % mano1=flag(i); % % j=i; % % end % % end % % mano2=flag(1); % % for i=2:N % %
if flag(i).Area > mano2.Area && i~=j % %
mano2=flag(i); % %
end % %
end % %
imshow(P,'Parent',handles.axes3) % %
hold on % %
rectangle('Position',mano1.BoundingBox,'EdgeColor','r','LineWidth',2,'Parent',handles.axes3) % %
rectangle('Position',mano2.BoundingBox,'EdgeColor','r','LineWidth',2,'Parent',handles.axes3) % %
hold off % %
man1 = imcrop(ima_bw, mano1.BoundingBox); % Se recortan las manos de la imagen para luego calcularles los momentos invariantes, los cuales seran%
man2 = imcrop(ima_bw, mano2.BoundingBox); % utilizados para realizar el primer control de deteccion el CODIGO PRICIPAL. %
man1=imfill(man1,'holes'); % % man2=imfill(man2,'holes'); % % mom1=invmoments(man1); % % mom2=invmoments(man2); % % closepreview(canalVideo); % % delete(canalVideo); % %
if mano1.Area>=mano2.Area*2 % Se detectan siempre dos objetos, y se determina una relacion de areas entre ellos, si el area mayor %
cs=2; % supera mas de dos veces el area del segundo objeto mayor, supone que detecto una mano, por lo %
else % supone una accion de rotacion, caso contrario supone que detecto dos manos, lo que implica una %
end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % --- Executes on button press in reanudar. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function reanudar_Callback(hObject, eventdata, handles) % % % hObject handle to reanudar (see GCBO) % REANUDACION % % eventdata reserved - to be defined in a future version of MATLAB % % % handles structure with handles and user data (see GUIDATA) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
global ps; % Desactiva la bandera ps, para que el procesamiento salga de estado de pausa (solo si br=0). %
ps=0; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% --- Executes during object creation, after setting all properties.
function figure1_CreateFcn(hObject, eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called
