Convolución discreta

Convolución discreta
Una de las propiedades más importantes de los sistemas es la linealidad. Esta propiedad a su vez se divide en dos propiedades conocidas como propiedad aditiva y propiedad de escalamiento. La propiedad aditiva establece que si al sistema ingresa la suma de varias señales, la respuesta del sistema será la suma de las respuestas a cada una de las entradas individuales.
La propiedad de escalamiento u homogeneidad establece que si una señal $x(t)$ tiene como respuesta una señal $y(t)$, al ser escalada la entrada (o multiplicada por una constante) $\alpha x(t)$, su salida será también escalada por la misa constante $\alpha y(t)$. Juntas, la propiedad de escalamiento y la aditiva se conocer como propiedad de superposición, la cual se sintetiza en la siguiente ecuación.
\begin{equation}\label{eq:superpos_1} \alpha {x_1}\left( t \right) + \beta {x_2}\left( t \right) \to \alpha {y_1}\left( t \right) + \beta {y_2}\left( t \right) \end{equation}
Otra de las propiedad importante de los sistemas es la propiedad de invarianza la tiempo, detallada en la siguiente ecuación.
\begin{equation}\label{eq:inv_tiempo} \begin{matrix} {x\left( t \right) \to y\left( t \right)} \cr {x\left( {t - {t_0}} \right) \to y\left( {t - {t_0}} \right)} \cr \end{matrix} \end{equation}
En sí, un sistema es invariante al tiempo cuando una desplazamiento en la señal de entrada produce el mismo desplazamiento en la señal de salida o respuesta del sistema. Es decir, el sistema no cambia sus características a lo largo del tiempo.
Cuando un sistema cumple con la propiedad de linealidad (o propiedad de superposición) y la propiedad de ser invariante al tiempo se conoce como sistema lineal e invariante al tiempo, abreviado como SLTI. Muchos sistemas empleados en comunicaciones son SLTI. De ahí la importancia de conocer las características de este tipo de sistema y la forma de encontrar la respuesta del mismo o salida del sistema.
Para un sistema discreto, la forma de encontrar la salida de este sistema es a través de una operación conocida como suma de convolución. Para llegar a este resultado, lo primero es representar la señal discreta $x[n]$ como una combinación lineal del impulsos desplazados ponderados.
\begin{equation}\label{eq:impulso_des_pond} x\left[ n \right] = \sum\limits_{k = - \infty }^{ + \infty } {x\left[ k \right]\delta [n - k]} \end{equation}
Dado que el sistema es lineal, la respuesta será también una combinación lineal, pero de las respuestas a cada una de las entradas individuales. Como la señal ha sido representada como una suma de señales impulso, la respuesta a esta señal se asigna de la siguiente manera:
\begin{equation}\label{eq:impulso_des_pond2} \delta [n - k] \to {h_k}[n] \end{equation}
De esa forma, la salida total del sistema será la superposición de las salidas a cada una de las entradas.
\begin{equation}\label{eq:impulso_des_pond3} y\left[ n \right] = \sum\limits_{k = - \infty }^{ + \infty } {x\left[ k \right]{h_k}[n]} \end{equation}
Si el sistema es invariante al tiempo, la respuesta a un impulso desplazado será la misma respuesta a un impulso en $n=0$ simplemente desplazada.
\begin{equation}\label{eq:impulso_des_pond4} \delta [n - k] \to {h_0}[n - k] \end{equation}
De esa forma, la salida del sistema es calculada con la siguiente ecuación, que es conocida como la suma de convolución o convolución discreta.
\begin{equation}\label{eq:impulso_des_pond5} y\left[ n \right] = \sum\limits_{k = - \infty }^{ + \infty } {x\left[ k \right]h[n - k]} \end{equation}

Impulso y escalón unitarios

Impulso y escalón unitario La estrategia para procesar o tratar una señal es representar (o descomponer) dicha señal en una combinación lineal de señales base. En el análisis de la señal en el tiempo, dicha señal base es el impulso unitario $\delta[n]$ (para tiempo discreto) y $\delta(t)$ para tiempo continuo. Un impulso discreto está definido conforme la siguiente ecuación. \begin{equation}\label{eq:impul_discreto} \delta \left[ n \right] = \left\{ \begin{matrix} {1,} & {n = 0} \cr {0,} & {n \ne 0} \cr \end{matrix} \right. \end{equation} Es decir, un impulso es una señal que tiene un valor no nulo apenas en un instante de tiempo.
El escalón unitario discreto es aquella señal que puede considerarse constante a partir del instante 0. Se denota como $u[n]$. \begin{equation}\label{eq:esca_discreto} u\left[ n \right] = \left\{ \begin{matrix} {1,} & {n \ge 0} \cr {0,} & {n < 0} \cr \end{matrix} \right. \end{equation} En la gráfica de la Figura siguiente del escalón se observa que de alguna forma puede ser representado como un conjunto de señales impulso.
Es así, que el escalón unitario discreto puede generarse a partir del impulso unitario a través de la siguiente ecuación. \begin{equation}\label{eq:esca_discreto_imp1} u[n] = \sum\limits_{k = 0}^{ + \infty } {\delta \left[ {n - k} \right]} \end{equation} En esta última ecuación, el impulso se va desplazando dentro de una ventana fija del sumatorio. Una expresión alternativa es presentada en la siguiente ecuación, donde la ventana del sumatorio es móvil y el impulso fijo. \begin{equation}\label{eq:esca_discreto_imp2} u[n] = \sum\limits_{m = - \infty }^n {\delta [m]} \end{equation} Un impulso puede obtenerse a partir de la primera diferencia del escalón a través de la ecuación siguiente. \begin{equation}\label{eq:esca_discreto_imp3} \delta \left[ n \right] = u[n] - u[n - 1] \end{equation} En tiempo continuo, el escalón e impulso unitario tienen una representación semejante. Un escalón unitario continuo está definido conforme la ecuación siguiente. \begin{equation}\label{eq:esca_continuo} u(t) = \left\{ \begin{matrix} {1,} & {t > 0} \cr {0,} & {t < 0} \cr \end{matrix} \right. \end{equation} Esta señal es constante a partir de $t>0$.
Para definir al impulso unitario, usamos la función $\delta_{\delta}(t)$ detallada en la ecuación siguiente. \begin{equation}\label{eq:delta_sub_Delta} {\delta _\Delta }(t) = \left\{ \begin{matrix} {{1 \over \Delta },} & {0 < t < \Delta } \cr {0,} & {otro{\kern 1pt} {\kern 1pt} {\kern 1pt} valor} \cr \end{matrix} \right. \end{equation} Esta señal $\delta_{\delta}(t)$ tiene siempre área igual a uno para todo valor de $\Delta$. De esa forma, el impulso unitario se define como el límite de esta señal cuando $\Delta$ tiende a cero. \begin{equation}\label{eq:delta_sub_Delta2} \delta (t) = \mathop {\lim }\limits_{\Delta \to 0} {\delta _\Delta }(t) \end{equation} La gráfica del impulso unitario continuo es semejante al impulso discreto, con la diferencia que el valor que se colocar cerca de la flecha es su área.
Tal como el caso discreto, el impulso se puede obtener a partir del escalón a través de la derivada usando la ecuación siguiente. \begin{equation}\label{eq:delta_escalon_1} \delta (t) = {{\partial u(t)} \over {\partial t}} \end{equation} Y el escalón a través del impulso con las ecuaciones siguientes. \begin{equation}\label{eq:delta_escalon_2} u(t) = \int\limits_{ - \infty }^t {\delta (\tau )} d\tau \end{equation} \begin{equation}\label{eq:delta_escalon_3} u(t) = \int\limits_0^\infty {\delta (t - \sigma )} d\sigma \end{equation}

Exponencial periódica compleja

Exponencial periódica compleja
Una señal $x(t)$ es periódica si se repite su formato a lo largo del tiempo. Matemáticamente, una señal es periódica si cumple $x(t)=x(t+T)$ para todo tiempo $t$, donde $T$ es el periodo de la señal. Este periodo es un número mayor que cero y está definido como el mínimo tiempo para el cual $x(t)=x(t+T)$ se cumple.
Una clase particular de señales continuas periódicas son las exponenciales complejas $e^{j\omega_0 t}$, donde $\omega_0$ es la frecuencia angular medida en radianes por segundo (rad/s). Esta señal es periódica con periodo $T=2\pi/\omega_0$. La frecuencia angular $\omega_0$ también se puede expresar en hertz (Hz) usando la relación $\omega_0=2\pi f$, donde $f$ es la frecuencia nominal. Si usamos la relación de Euler $e^{j\omega_0t}=cos(\omega_0t)+jsen(\omega_0t)$ podemos notar que en sí una exponencial compleja es un par de señales senoidales.
Esta señal exponencial compleja es muy importante en el procesamiento de una señal debido a que es una auto-función (o eigen-función) de los sistemas lineales e invariantes al tiempo (SLTI). Es decir, si una exponencial compleja continua entra a un SLTI, la respuesta de este sistema es la misma exponencial compleja simplemente multiplicada por una constante compleja $H(s)$ (llamado eigen-valor). Esto lo veremos en la parte del análisis de Fourier de señales.
En el caso de las exponenciales complejas discretas $x[n]=e^{j\omega_0n}$, no toda exponencial compleja es periódica. Se debe cumplir que $\omega_0/2\pi$ debe ser un número racional $M/N$ , donde $N$ es el periodo que es igual a $N=\omega_0/2\pi$. Otra diferencia con su contra parte continua es que esta señal es periódica cada $2\pi$, es decir $e^{j\omega_0n}=e^{j(\omega_0+2\pi)n}$. Conforme la frecuencia angular va de 0 a $\pi$, la frecuencia de esta señal aumenta y mientras va de $\pi$ hasta $2\pi$ la frecuencia disminuye. Es así, que si una señal exponencial compleja tiene su concentración de frecuencia en torno de 0, $2\pi$ o múltiplos pares de $\pi$ se dice que es una señal de baja frecuencia. Si su frecuencia está concentrada en torno de $\pi$ o múltiplos impares de $\pi$, es una señal de alta frecuencia.

Transformación de la variable independiente

En las señales en tiempo continuo $x\left( t \right)$ (variable independiente $t$) o tiempo discreto $x\left[ n \right]$ (variable independiente $n$) se modifica de tres maneras su variable independiente.
1. Desplazamiento o corrimiento($x\left( {t - {t_0}} \right)$): dividida en adelanto y atraso dependiendo si el valor de ${t_0}$ es mayor o menor que cero (es decir, si es positivo o negativo).
Considerando un escalón unitario discreto, una señal $x[n-3]$ corresponderá a un escalón atrasado tres muestras. En sí, esta nueva señal tendrá un desplazamiento hacia la derecha del eje. Este tipo de transformación es denominada atraso de la señal.
El adelanto en el tiempo de una señal se muestra en la siguiente figura, donde se grafica la función $x[n+3]$
Para el tiempo continuo $t$ es un comportamiento semejante: un adelante corresponde a un corrimiento de la señal hacia la izquierda. Si el corrimiento es hacia la derecha, se considera que la señal ha sido atrasada.
2. Reflejo o inversión($x(-t)$ o $x[-n]$): esta transformación mapea toda la información desde 0 al otro lado del eje. Es semejante a colocar un espejo sobre el eje $y$ y observar el "reflejo" de la señal o dibujar la señal en una hoja de papel y observarla desde la parte de atrás de la hoja. Así, las señales de las figuras siguientes son el reflejo una de otra.
3. Escalamiento($x(\alpha t)$): esta transformación corresponde a comprimir la señal o expandirla en el tiempo. La señal se comprime cuando $\alpha$ es mayor que uno y se expande cuando $\alpha$ es fracción.
Considerando la señal rectangular de la figura siguiente:
Una transformación por $\alpha=2$ produce en la señal una reducción en su duración.
Una transformación por $\alpha=0.5$ produce en la señal una ampliación en su duración.

Papito no nació para las ocho horas

Sin duda uno de los mejores descubrimientos del 2013 fue Cuarteto de Nos. Una combinación extraordinaria de rima, humor, sarcasmo y realismo hacen de muchas de las canciones de este grupo uruguayo verdaderas joyas de la música. Y una de ellas, Pobre Papá, me dejó pensando en las ocho horas de trabajo diario. Así que un día usé el fenomenal Python y línea tras línea conseguí un código que marca el horario de salida del trabajo.

Este sencillo código lo he venido usando ya bastante tiempo. Le doy F5 todos los días.

Leyendo el extraordinario libro Abre tu mente a los números de la Dra. Barbara Oakley descubrí una idea interesante: el trabajo duro combinado con un ocio saludable es una combinación que mejora nuestra productividad en los estudios (o el trabajo).

Así que aquí está: saber la hora exacta de salida de esas ocho horas que se aprovecharon usando el modo concentrado y el modo difuso...

hora_ent_m   =7
minuto_ent_m =32
hora_sal_m   =12
minuto_sal_m =44
hora_ent_t   =14
minuto_ent_t =33

print(str(hora_ent_m)+':'+str(minuto_ent_m))
print(str(hora_sal_m)+':'+str(minuto_sal_m))
print(str(hora_ent_t)+':'+str(minuto_ent_t))

hora_m=hora_sal_m-hora_ent_m;
minu_m=minuto_sal_m-minuto_ent_m;
if minu_m<0:
    hora_m=hora_m-1;
    minu_m=60+minu_m;
print('-'*40)
print('Horas manana: '+str(hora_m)+':'+str(minu_m))
#Restan
rth=7-hora_m
rtm=60-minu_m
if rtm>=60:
    rtm=00;
    rth=rth+1
if rtm<10:
    print('Horas restantes: '+str(rth)+':0'+str(rtm))
else:
    print('Horas restantes: '+str(rth)+':'+str(rtm))
#Salida
hora_salida=hora_ent_t+rth
minuto_salida=minuto_ent_t+rtm
if minuto_salida>=60:
    minuto_salida=minuto_salida-60
    hora_salida=hora_salida+1
if minuto_salida<10:
    print('Hora de salida: '+str(hora_salida)+':0'+str(minuto_salida))
else:
    print('Hora de salida: '+str(hora_salida)+':'+str(minuto_salida))
Aquí el resultado:

Captura de vídeo en GUI Matlab

Con este programa se pretende mostrar la forma de capturar vídeo e imágenes en una interfaz gráfica.
El campo tag del axes que presenta el vídeo es axes1 y del axes que contiene la imagen capturada es axes2. El código en la sección de inicialización del programa es el siguiente:
function video_gui_OpeningFcn(hObject, eventdata, handles, varargin)
movegui(hObject,'center')
set(handles.axes1,'XTick',[ ],'YTick',[ ])
set(handles.axes2,'XTick',[ ],'YTick',[ ])
imaqreset
handles.output = hObject;
guidata(hObject, handles);
Con la herramienta Object browser podemos ver el campo tag de cada elemento de la GUI. (Ver Figura siguiente).
El botón de inicio de la GUI abre un programa que de forma automática detecta las cámaras de vídeo (Ver Figura siguiente).
En la función de apertura contiene el código del Listado siguiente.
function sel_camera_OpeningFcn(hObject, eventdata, handles, varargin)
imaqreset;
set(handles.ok_b,'Enable','off')
hw=imaqhwinfo('winvideo');
handles.cam=hw;
set(handles.lista_camaras,'String',{hw.DeviceInfo.DeviceName})
handles.output = hObject;
guidata(hObject, handles);
Con el pop up menu seleccionamos qué cámara usar. Dentro de la función asociada a este elemento (mostrada en el Listado siguiente) está la programación que extrae las principales características de la cámara seleccionada.
function lista_camaras_Callback(hObject, eventdata, handles)
pos=get(handles.lista_camaras,'Value');
hw=handles.cam;
id=hw.DeviceIDs{pos};
set(handles.id_camara,'String',id)
formatos=hw.DeviceInfo(pos).SupportedFormats;
set(handles.formatos,'String',formatos)
list_f = [formatos{1:end}];
si=strfind(list_f,'RGB24_320x240');
if isempty(si)
    es_web_ext=0;% Laptop: YUY2
else
    es_web_ext=1;% External: RGB
end
handles.es_web_ext=es_web_ext;
handles.id=id;
guidata(hObject, handles)
set(handles.ok_b,'Enable','on')
Al presionar el botón Ok se exportan las características de la cámara seleccionada. El Listado siguiente contiene el código de la función del botón. Note que se usan variables globales para exportar esta información a la primera GUI.
function ok_b_Callback(hObject, eventdata, handles)
global id es_web_ext
es_web_ext = handles.es_web_ext;
id = handles.id;
close (handles.camara)
Regresando a la programación del la primera GUI, una vez seleccionada la fuente de vídeo, el botón de inicio muestra la secuencia de imágenes en el primer axes de la GUI (Ver Listado siguiente).
function inicio_b_Callback(hObject, eventdata, handles)
set(handles.inicio_b,'Enable','off')
start(handles.vidobj);
vidRes = get(handles.vidobj,'VideoResolution');
nBands = get(handles.vidobj,'NumberOfBands');
hImage = image(zeros(vidRes(2), vidRes(1), nBands),'Parent',handles.axes1);
preview(handles.vidobj,hImage);
guidata(hObject, handles);
Con el botón de captura, cuya programación se muestra en el Listado siguiente, obtenemos la imagen a partir del vídeo.
function captura_Callback(hObject, eventdata, handles)
try
    rgb = getsnapshot(handles.vidobj);
    if handles.es_web_ext==0
        rgb = ycbcr2rgb(rgb);
    end
    image(rgb,'Parent',handles.axes2);
    axes(handles.axes2)
    axis off
catch    
    disp('No hay imagen para mostrar')
end
Finalmente, el botón de parada detiene la proyección de vídeo y permitirá seleccionar una nueva fuente de vídeo. (Ver Listado siguiente.)
function parar_b_Callback(hObject, eventdata, handles)
set(handles.inicio_b,'Enable','on')
stoppreview(handles.vidobj)

GUI de Matlab para encontrar el punto de corte de dos funciones.

Dadas dos funciones, vamos a encontrar el punto de corte a través de una GUI de Matlab. La interfaz gráfica genera ambas funciones al presionar un botón. Luego, se calcula el punto de corte, se asigna su coordenada a un cuadro de texto estático. La siguiente gráfica muestra el entorno de esta GUI.
Programamos que el segundo botón esté desactivado cuando inicia a correr el programa. Esto lo hacemos en la parte correspondiente del archivo .m OpeningFcn.
% --- Executes just before corte_graficas is made visible.
function corte_graficas_OpeningFcn(hObject, eventdata, handles, varargin)
set(handles.pushbutton2,'Enable','off')
handles.output = hObject;
guidata(hObject, handles);
El código que se ejecuta el presionar el primer botón se muestra a continuación. Se generan dos funciones y se colocan sus valores en handles para poder exportar estos valores a otra función del archivo .m.
% --- Executes on button press in pushbutton1.
function pushbutton1_Callback(hObject, eventdata, handles)
x = 0:0.01:10;
y1 = x .^2 + 2;
y2 = x .^3 ;
handles.x=x;
handles.y1=y1;
handles.y2=y2;
handles.axes1;
plot(x, y1, x, y2);
ylim([0,10])
set(handles.pushbutton2,'Enable','on')
guidata(hObject, handles);
Finalmente, el botón etiquetado como Corte ejecuta el código que encuentra el punto de corte de las dos gráficas y presenta la coordenada en el cuadro estático de texto.
% --- Executes on button press in pushbutton2.
function pushbutton2_Callback(hObject, eventdata, handles)
idx = find(handles.y1 - handles.y2 < eps, 1); %// Index of coordinate in array
px = handles.x(idx);
py = handles.y1(idx);
set(handles.text1,'String',['x= ',num2str(px),' y= ',num2str(py)])
handles.axes1;
hold on
plot(px, py, 'ro', 'MarkerSize', 18)
hold off