Cómo ocultar una imagen en una rejilla espacial con Matlab

Se han hecho populares estas imágenes en Facebook, son fotos ocultadas a través de una densa rejilla espacial. Te mostramos cómo hacer esta ilusión óptica con Matlab.

Básicamente, se trata de disminuir el contraste de las fotos, alejarse de los tonos oscuros y luego introducir muchas franjas oscuras en la imagen. El resultado es que percibimos primero franjas oscuras y claras, pues entre ellas hay más contraste, cuando cambiamos de perspectiva (al inclinar la pantalla o la cabeza o alejarnos de la imagen) o sacudir la cabeza podemos ver la imagen oculta.

Se trata más de una curiosidad que de un verdadero sistema de criptografía, asi que diviértanse con el código y las imágenes que dejo en esta  entrada.

Preguntas para pensar
1) ¿Por qué aparece la imagen cuando cambiamos de perspectiva?

Ejercicios
1) Altera  el código para que sea una función de cuatro parámetros, que de de salida una imagen .gif

Imagen utilizada

Imagen de salida

Guión Matlab

% A limpiar la casa

 clear all; close all; clc;

% Cargar la imagen y ponerla en grises

im_fuente = rgb2gray(imread('maz.jpg'));

% cambia la clase de una variable

imgs = cast(im_fuente,'double'); 

% La imagen se ajusta a 60 tonos de gris, 

img = 60*((imgs)./(max(max(imgs))));

img = img + 195; % desplazar los tonos a 195

% al final tengo tonos de 195 a 255

[f c d] = size(img); % el proceso es para cada capa

% Paso es el número de columnas negras en la imagen final 

paso = floor(c/160); %redondea hacia abajo, frecuencia 1/160

for i = 1:2*paso:c

    img(:,i:i+paso,:) = 0; %img suele tener tres capas

end

im_final = cast(img,'uint8');

imshow(im_final); % ver para creer

%fin del guión

Más información en la ref.

Retirar datos atípicos (outliers) de una distribución de datos con Matlab

Los datos atípicos son datos que se alejan mucho de promedio de una distribución. Por lo general, se interpretan como errores experimentales aleatorios, por ello se suelen remover. En esta ocasión te muestro un script que usa cuartiles estadísticos para remover tales datos.

Preguntas para pensar

1)  En que caso un dato atípico brinda información experimental relevante y no debe removerse de la serie.

Ejercicios

1) Sugiere una modificación al guion presentado para usar la desviación-estándar como base para eliminar los datos atípicos.

GUIÓN MATLAB

%% Primer guión para remover datos atípicos

clc; clear; close all

%% Información de entrada

Y = [10 20 -150 40 50 60 70 200 90 100];

X = [2 4 6 8 10 12 14 16 18 20];

%% Cálculos

IQR = iqr(Y); %intervalo  intercuartil,

    % la diferencia entre el tercer  y el primer cuartil

    % de una distribución: 75%-25% de Y

    % σ= IQR * 0.7413

lowr=prctile(Y,25)-1.5*IQR; %Percentiles. Q1 - 1.5IQR.

highr=prctile(Y,75)+1.5*IQR; % Q3 + 1.5IQR

new_Y = Y(Y>lowr &   Y
new_X = X(Y>lowr &   Y

%%ver; es creer

hold on

plot(X, Y, 'bo','MarkerSize',20)

plot(new_X, new_Y, 'kx','MarkerSize',20)

hold off

%fin del guión

Juego de volados y casinos ricos

Guión:

%% ¿En cuanto tiempo un casino te deja sin dinero?
% este guion simula un juego de tirar una moneda entre un casino y un
% apostador.

%% Guión escrito por Vicente Torres Zúñiga; 18 de abril 2003.

clc; clear; close all % Limpia la memoria

casino = 100000; % Dinero con el que empieza el casino
apostador = 10; % Dinero con el que empieza el apostador

casino_zero = casino;
apostador_zero = apostador;

num_evento = 0; % Número de veces que han apostado, que se inicia en cero.

dinero_apostador(casino) = 0; % Tentativamente pongo este vector para
% hacer más rapida la asignición de memoria. Pero al final el vector puede
% ser más grande o pequeño que esta asignación

% Todas las apuestas son iguales, de una unidad. Es decir, en un juego
% se pierde o gana una unidad.

while (apostador > 0 && casino > 0)
num_evento = num_evento +1;
dinero_apostador(num_evento) = apostador;
moneda = rand(1); % rand brinda números pseudoaleatorios entre 0 y 1
if moneda >=0.5 % gana el casino
casino = casino +1;
apostador = apostador -1;

else % gana apostador
casino = casino - 1;
apostador = apostador +1;
end
end
porciento_perdida_casino = 100*max(dinero_apostador)/casino_zero; % porcentualmente cuanto es lo máximo que
% le puedo sacar al casino
porciento_ganancia_apostador = 100*(max(dinero_apostador)- apostador_zero)/apostador_zero; % porcentualmente cuanto es lo máximo que
% le puedo sacar al casino
num_juegos = num_evento; %cuantos juegos realizamos

% Vizualización
axes('fontsize',14,'fontweight','b')
plot(dinero_apostador,'b', 'LineWidth',6)

xlabel('Número de juego, N', 'fontsize',20,'fontweight','b')
ylabel('Dinero del apostador, D', 'fontsize',20,'fontweight','b')
title(['Al principio, el dinero del casino es ', num2str(casino_zero./apostador_zero), ' veces más grande que el del apostador'], 'fontsize',20,'fontweight','b')
set(gca, 'Fontsize',18, 'fontweight','b')
axis([0, num_juegos, 0, max(dinero_apostador)]);

salida = [porciento_ganancia_apostador, porciento_perdida_casino, num_juegos];

% fin del guión

Código Matlab para hacer un contador de franjas de interferencia

Resumen

Esta es una aplicación sencilla de Matlab para analizar imágenes. Se trata de cargar la imagen segmentada de un interferograma - sus franjas de interferencia deben ser verticales -. La imagen se transforma en matriz, se colapsa en vector, y se transforma en datos de ceros y unos. Al barrer la matriz se puede contar el numero de transiciones ,el cual es proporcional al número de franjas.

Muchos de los comandos que se emplean en este ejemplo los hemos explicado en anteriores entradas, y se mencionan sus funciones en el video.

Descarga el archivo: contador_de_franjas.rar que contiene el código, las imagenes originales, y las imágenes segmentedas para que puedas hacer los ejercicios propuestos.

Ejercicios

1) Optimice la velocidad de ejecución de este código. Comience eliminando las lineas de código que no se usan más adelante.

2) ¿Como se pueden eliminar los artefactos de ruido?, de modo que se mejore el desempeño del conteo de franjas

3) Transforme este guión en una función

4) Integre a video este código (esta tarea es avanzada)

Juntas, pero no revueltas: sub-gráficas en una misma figura de Matlab

Ejemplo del uso de subplot

El comando de Matlab subplot es lo suficientemente versátil para darle sendos ejes y características adicionales a las gráficas que coloquemos en una misma imagen.

Efectivamente, basta con indicar como se compondrá la matriz de la imagen (a,b) y que espacio p ocupará cada una de las gráficas; es decir, subplot (m, n, p) hace la división del espacio de la figura. Matlab asignara el espacio con en paneles regulares para cada gráfica. Este es un ejemplo simple de una rutina aplicada una figura compuesta de 2 gráficas.

Asignación simple de paneles

x= 1:0.1:2*pi;

subplot(2,1,1), plot(x)

subplot(2,1,2), plot(sin(x))

En general, el comando subplot brinda una figura de configuración simétrica de paneles, que son donde se colocan las gráficas. Y cada panel es independiente de los otros. Sin embargo, si el parámetro p es una matriz, entonces se puede ocupar más de un panel para una gráfica. Por tanto, en una misma figura se puede colocar una gráfica grande y otras más pequeñas. Por ejemplo usando el siguiente código:

Asignación asimétrica de paneles

x= 1:0.1:2*pi;

subplot(2,2,[1 2]); plot(sin(x))

subplot(2,2,3); plot(log(x))

subplot(2,2,4); plot(exp(x))

Finalmente, hay que destacar que se puede utilizar el subplot dentro de ciclos de programación, de forma que se pueden automatizar colecciones de imágenes que siguen una línea de historica. Por ejemplo:

Ejemplo del uso de  subplot
en un ciclo for

y = zeros(4,15); % se inicializa un vector, para ser más eficiente

for k = 1:4 % seran cuatro colecciones de datos

y(k,:) = rand(1,15); % se crea un vector de 15 elementos aleatorios

subplot(2, 2, k) % el índice se usa para dar orden a la secuencia de gráficas

plot(y(k,:)); % se hace la gráfica

end

Precauciones

Utilizando scripts, solamente se pueden crear estas gráficas cuando ya se cuenta con la matriz completa. En otro caso hay que utilizar comandos como drawnow, del que ya anteriormente hemos mostrado unos ejemplos.

Preguntas para pensar

1) Describa un ejemplo especifico donde los subplot en un ciclo for son aplicados

Ejercicios

1) Obtenga la siguiente imagen utilizando diferentes comandos de Matlab

Ejercicio de esta entrada

Uso de operaciones vectoriales en lugar de ciclos for para aumentar el desempeño de Matlab

Consideremos el siguiente ciclo, reescrito directamente de C o Fortran

dx = pi/30;

nx = 1+ 2*pi/dx;

for i = 1:nx

     x(i) = (i-1) * dx;

     y(i) = sin(3*x(i));

end

Todas las declaraciones anteriores son validas en Matlab, pero son ineficientes en el proceso de crear tanto a x como a y. Recordemos, Matlab localiza memoria para las variables cada vez que se les añade un nuevo miembro. Como ya lo comentamos en anteriormente en una entrada sobre reasignación de memoria RAM.

Entonces el mejor modo de crear los mismos dos vectores x y y es mediante los siguientes comandos:

x = 0: pi/30:2*pi;

y = sin(3*x);

La primera declaración crea al vector x; con 61 elementos que son almacenados en zonas continuas del RAM. La segunda declaración crea una nueva matriz, y, con el mismo número de elementos que x.

Matlab está diseñado para desarrollar eficientemente operaciones de matrices y vectores. Para tomar la ventaja máxima del hardware de la computadora; por tanto debemos utilizar operaciones vectoriales lo más que podamos.

Un ejemplo más sofisticado

A pesar que Matlab ajusta automáticamente el tamaño de una matriz (o vector) es mucho mejor predesignar la memoria de la matriz. La preasignación garantiza que los elementos de la matriz se almacenaran en zonas continuas de la memoria RAM y que sólo se realizara una vez este proceso.

Consideremos este ejemplo (que admito es artificial, pero didáctico) para crear dos vectores x y y:

dx = pi/30;

nx = 1 + 2*pi/dx;

nx2 = nx/2;

for i = 1:nx2

    x(i) = (i-1)*dx;

    y(i) = sin(3*x(i));

end

for i = round(nx2):nx

     x(i) = (i-1)*dx;

     y(i) = sin(5*x(i));

end

Aquí, conocemos desde el principio el tamaño de los vectores x y y. Así que reasignaremos la memoria creando un vector antes de que sus elementos sean individualmente asignados. Por lo común se utilizan las funciones ones y zeros para la reasignación de memoria; por ejemplo, de este modo:

dx = pi/30;

nx = 1 + 2*pi/dx;

nx2 = nx/2;

x = zeros(1,nx); % pre-allocate row-vectors, x

y = zeros(1,nx); % and y

for i = 1:nx2

x(i) = (i-1)*dx;

y(i) = sin(3*x(i));

end

for i = round(nx2):nx

x(i) = (i-1)*dx;

y(i) = sin(5*x(i));

end

Sin embargo, las declaraciones x(i) y y(i) no han tomado ventaja de la vectorización, aunque los elementos de x y y han sido almacenados continuamente en la RAM.

Así que mejoraremos estas declaraciones mediante un poco de vectorización. Por ejemplo, escribiendo:

x = 0:pi/30:2*pi; % vectorized calculation of x

nx = length(x);

nx2 = nx/2;

y = x; % pre-allocate memory for y

for i = 1:nx2

     y(i) = sin(3*x(i));

end

for i = round(nx2):nx

    y(i) = sin(5*x(i));

end

Finalmente, podemos observar que los cálculos de y puede también ser vectorizados. Por ejemplo, de este modo:

x = 0:pi/30:2*pi; % vectorized calculation of x

nx = length(x);

nx2 = nx/2;

y = x; % pre-allocate memory for y

y(1:nx2) = sin(3*x(1:nx2)); % compute first part of y

y(round(nx2):nx) = sin(5*x(round(nx2):nx)); % and the second part

En mi computadora, resulta que el aumento de velocidad fue de aprox. 1.2 veces. Es decir, utilizar los cálculos basados en vectores fue notoria la mejora. Sin embargo, en este ejemplo son pocos los elementos de los vectores. Mientras más grande es la matriz o vector, más significativo será utilizar vectorización en lugar de una reconstrucción de la matriz por medio del ciclo for.

Por cierto, para medir el tiempo de estos ejemplos, los he escrito como rutinas (scripts que los nombre ejemplo_vector.m) y utilice los siguientes comandos para medir el tiempo.

clear; tic; ejemplo_vector; disp( ['se tardo ' num2str(toc) 's.'] );

Y la salida de este ejemplo es la siguiente imagen:

Uso de pre-asignación de memoria en Matlab para aumentar la velocidad de cálculos

Fun home 1

Como en cualquier otra actividad, programar requiere seguir reglas para ser efectivo. Del mismo modo en que deberíamos limpiar nuestro cuarto de vez en cuando; debemos economizar la memoria de la computadora.

Por ello, en esta entrada, platicaré de las bases de la preasignacion de memoria (memory preallocation) en Matlab. La preasignación de memoria es una práctica excelente de programación que SIEMPRE debemos seguir.

¿De qué trata la preasignación de memoria en Matlab?

A diferencia de los otros lenguajes de programación, como C; Matlab “cuida” de la asignación de memoria automáticamente. Así cuando ejecutas un programa, Matlab reserva espacios de memoria para los datos de todas las variables que se utilizan. Y esto se basa en información local, de un modo similar como en el caso de los tipos de datos o el espacio necesario para todos los elementos.  Veamos un ejemplo con código Matlab:

X = 1:100;

Y = cos(X);

En la línea 1, Matlab identifica que X es un vector compuesto de 100 elementos de formato doble. Entonces reserva la memoria necesaria para cuando se emplee.

En la línea 2, Y es del mismo tamaño que X, de modo que Matlab reserva memoria antes de llenar el espacio con la información de la función cos(X).

Una consecuencia de este mecanismo es que CADA VEZ que se le pide a Matlab almacenar un nuevo conjunto de datos, Matlab realiza el proceso de asignar algo de memoria. Por ejemplo:

X = 1:100;

X(101) = 1;

En este ejemplo, X está compuesto inicialmente de 100 elementos; luego cuando se le ordena a Matlab que llene el elemento 101, implícitamente se le pide a Matlab que reasigne algo de memoria para que se pueda incluir el nuevo elemento de X.

¿Por qué tanto alboroto con la preasignación de memoria?

Para todos los datos en una matriz, Matlab requiere un proceso de memoria continua. Como resultado, si el espacio de memoria para el espacio 101 es solicitado; entonces Matlab copia todos los valores originales de X y los coloca en un nuevo sitio donde hay espacio para hasta los 101 elementos.

Veamos un ejemplo más extremo, si X esta hecho 100 mil elementos en lugar de 100, el tamaño de memoria para X es grande y estos grandes espacios de memoria no son tan fáciles de localizar. Es como querer estacionar un autobús turístico en el centro de la ciudad… toma bastante tiempo.

Es especialmente en los ciclos for cuando este proceso de asignación de memoria es notorio. Por ejemplo en esta rutina (script) al que llame ejemplo_memoria0:

for i=1: 100000

Y(i)=cos(i);

end

En este caso, a cada paso en el ciclo for, se le pide a Matlab que añada un elemento a la matriz Y. De hecho, se le pide a Matlab que engrose a Y en memoria a cada paso.

Al principio del proceso, es fácil y rápido; pues Y es pequeño. Pero a medida que progresa el ciclo, Y se hace cada vez más grande, de modo que Matlab debe encontrar espacios de memoria mucho más grandes. Por lo que se vuelve una pesadilla de asignare

La solución es simple: preasignación de memoria

La idea se basa en que tú sabes de antemano cual será el tamaño del vector, por ello se lo debes comunicar a la computadora antes de que entre en el ciclo for. Por ejemplo, la mayoría de las personas utilizan funciones como ones o zeros de este modo:

Y = zeros(100000,1);

for i= 1:100000

   Y(i) = cos(i);

end

En mi computadora viejita y sobre-explotada, la primera versión tarda: 21.6511 s; y utilizando la pre-asignación de memoria tarda en ejecutarse: 0.009333 s. Es decir, estos cambios significaron que: ¡¡~688 VECES AUMENTÓ LA VELOCIDAD DEL CÁLCULO!!

Ahora, se puede aumentar la velocidad un poco más. En lugar de gastar el tiempo llenado con ceros una matriz, se le puede pedir a Matlab que llene solamente el último elemento de un vector. Por ejemplo:

Y (100000) =0;

for i= 1:100000

Y(i) = cos(i);

end

En este último caso, la rutina tardo 0.009074 s. Este ahorro de tiempo es especialmente significativo cuando se construyen diversas matrices de gran tamaño.

Preguntas para pensar:

1) ¿Cuáles otras prácticas de programación se deben emplear para aumentar la eficiencia de nuestros programas?

Ejercicios

1) En la línea de comandos de Matlab, yo utilicé los siguientes comandos para medir el tiempo de ejecución de mi rutina:

clear, tic; ejemplo_memoria0; disp( ['se tardo ' num2str(toc) 's.'] );

a) ¿Qué hace los comandos tic y toc?

b) En este caso, ¿Por qué es necesario transformar un número en cadena de caracteres?

c) Crea una tabla con los tres ejemplos mostrados en esta entrada donde se muestre la diferencia de velocidades en los procesos de cálculo,

Funciones y comparación de cadenas de caracteres

Este es un código que muestra como se pueden comparar cadenas caracteres. Es en respuesta a la duda (que se comento en clase) de un ejercicio para la creación de funciones.

Por favor, prueben la función e interpreten el proceso de trabajo, usen los comando tic toc de Matlab para ver cuanto tiempo tarda en ejecutarse, y si pueden modifiquen para disminuir este tiempo.

Y si tienen dudas, pueden dejar un comentario en esta entrada.

%% Esta fucion permite calcular entre la funcion seno y coseno.

% Acepta escalares y matrices
% Si se escribe mal la palabra se termina el programa

function y = trigos(cadena)
display('¿Qué función deseas usar?'); % estos son mensajes para orientar al usuario
display(' ');
display('Escribe la palabra <> si quieres usar la función coseno.');
display('o escribe la palabra <> si quieres usar la función seno');
palabra = input('Cualquier otra palabra te saca de esta funcion \n','s'); % aqui se almacena la cadena

 if strcmp(palabra, 'coseno') == 1 ; % strcmp compara las cadenas, si son iguales da un valor de 1
         y = cos(cadena);
 elseif strcmp(palabra, 'seno') == 1 ;
         y = sin(cadena);
 else strcmp(palabra, 'coseno') || strcmp(palabra, 'seno') == 0 ; % esta parte permite versatilidad en las salidas nulas
         display('la función no esta declarada. Adios :)'); % se le orienta al usuario que sucede en el programa
 end

% fin de la funcion
%%%

Cómo poner un cross-hair (cursor de línea) en las figuras de Matlab

Gráfica con tres cursores de linea

Cuando requerimos explorar una gráfica es una gran ayuda contar con un cursor de línea (cross-hair) vertical o horizontal.

graphics.cursorbar, que es un objeto interno de Matlab, es una solución para tener tal aditamento en nuestras gráficas.

Se inicializa el graphics.cursorbar al sustituir un eje (lo que no es muy útil), o graficando una línea (que es más inteligente). Este objeto se puede personalizar utilizando propiedades como BottomMarker, TopMarker, CursorLineColor, CursorLineStyle, CursorLineWidth, TargetMarkerSize, TargetMarkerStyle, ShowText, Orientation, Position (la cual es una propiedad oculta), entre otras.

Ahh!, por supuesto, también están presentes las propiedades regulares (UserData, Visibility, Parent etc.).

Una vez que el cursor de línea es creado, este puede ser movido por medio del cursor del raton, como el código muestra:

%%%% inicia código

x=0:.01:7; y=plot(x,sin(x));

hCursorbar = graphics.cursorbar(y); drawnow

hCursorbar.CursorLineColor = [1,.2,.3]; % default=[0,0,0]='k'

hCursorbar.CursorLineStyle = ':'; % default='-'

hCursorbar.CursorLineWidth = 1; % default=1

hCursorbar.Orientation = 'vertical'; % =default

hCursorbar.TargetMarkerSize = 10; % default=8

hCursorbar.TargetMarkerStyle = 'o'; % default='s' (square)

%%%% fin del código

Ahora bien, en muchas gráficas se puede desear tener dos o más cursores de línea. Por ejemplo una horizontal y otra vertical (x,y), o bien dos verticales (x_1, x_2); esto se puede hacer en base del sig. código:

x=0:.01:7; y=plot(x,sin(x));

hCursorbar1 = graphics.cursorbar(y);

hCursorbar2 = graphics.cursorbar(y);

% ahora a personalizar la apariencia de hCursorbar1 y a hCursorbar2

Preguntas para pensar

1) Menciona dos aplicaciones especificas y concetras donde es importante tener esta aditamento gráfico

Ejercicios

3) Crea un imagen con dos subgráficas donde esten contenidas dos sendos cursores en linea. Es decir en total tendremos cuatro cursores de linea.

4) En una interface de usuario con gráfica introduce estos cursores de linea.

Usos y abusos de la barra de espera de Matlab

La barra de espera de Matlab es un adorno. Le da la sensación al usuario que algo está sucediendo mientras espera que su programa se ejecute. Sin embargo, al ser un complemento que se ejecuta y despliega un gráfico, pues consume memoria de la computadora. Si se ejecuta el Profiler se puede observar cuanta memoria consume, gasto que es significativo en pequeños programas, y tal vez sea necesaria para programas elaborados y que sean para usuarios finales. El código de la barra de espera es:

h=waitbar(0,'Por favor, espere...');

FindelCiclo=4000;

for i=1:FindelCiclo

waitbar(i/FindelCiclo,h); % calculos

end

delete(h);

Preguntas para pensar 

1) Si los complementos en los programas de computo gastan memoria. ¿Por qué se utilizan?, ¿Se puede demostrar su efectividad o que mejoran la amigabilidad de un programa?

Ejercicios 

1) Introduce una barra de espera en un programa grande previamente elaborado, y utiliza los comandos tic toc para calcular la diferencia de tiempo antes y después de emplear la barra de espera.

Código Matlab para acondicionar y filtrar señales de electrocardiogramas.

Sergey Chernenko nos muestra, explica y regala el código Matlab para detectar una característica importante de las señales provenientes de un electrocardiógrafo: el pico R de un electrocardiograma.

Para estudiar este excelente ejemplo de procesamiento de señales en ciencias medicas, lo mejor es bajar el archivo zip, con el código original.

Hay que estudiarlo para comentarlo en la clase.

Como nos comenta el mismo Sergey en su sitio Web, la tarea básica en el procesamiento de electro-cardiogramas (ECG) es la detección de los picos R. Sin embargo, debido a la respiración del paciente, la detección es complicada; pues se presenta en los ECGs artefactos que complican la detección de los picos R. Por ejemplo, las distancias irregulares entre los picos, la forma irregular en los picos, la presencia de componentes de baja frecuencia en los ECGs.

Es por ello que se deben contar con varias etapas de procesamiento que reduzcan la influencia de estos factores. Sergey nos muestra un caso donde una señal ECG original se le eliminan las frecuencias bajas por medio de FFT (Fast-Fourier-Transform). En la segunda etapa, se usa un filtro pasa banda, el cual localiza los máximos significativos en la señal. En la etapa final, se eliminan los datos más alejados del promedio. Este proceso permite la detección de los picos R.

Código para encontrar la señal principal mediante el filtro de la función max

Les dejo uno de los ejemplos que me enviaron para hacer la evaluación.


% Inicio  del código

%% ejemplo del uso de las funciones FFT y MAX para limpiar una señal

%% con ruido
%% 12 sept 2011

% limpieza de la memoria
clc
clear
close all

% Señales con ruido
x=0:1/255:1;
y= 10*sin(2*pi*29*x)+  ...
   3*sin(2*5*x)+ ...
   2.5*sin(rand*25*2*pi*x)+...
   3.5*cos(rand*155*2*pi*x)+...
   2.5*sin(300*pi*x);

% Transformada de Fourier simple
Y=fft(y);
[a,b]=max(Y);
%indiceAmplitudmax=b;
% haciendo el vector con ceros
Y1=Y*0;
% sustituyendo en el espacio del indice el numero complejo que representa
% el maximo
Y1(b)=(a);
%tomando unicamente la parte real de la parte inversa de la transformada de
%Fourier. La parte imaginaria no nos da más información en esta parte
inversa= real(ifft(Y1));

% visualizando en la misma grafica la señal con ruido y limpia
hold on
plot(x,y,'r');
plot(x,inversa, 'k')
hold off

% Fin del código

Pregunta para pensar:

¿qué implica en la señal de principal (color negro) que sea un número complejo el máximo del espectro en la Transformada de Fourier?,  ¿acaso son son dos señales?  o ¿cambios de fase?.

Códigos adicionales para gráficas y código de filtro pasabajas para mejorarlo

Les pongo el Código para la tarea, deben hacer que funcione el filtro.



%%%%%%%%%%%%%%%%%%
clc
clear
close all

%señal a trabajar

x = 0:0.0001:5*pi;
 y = sin(x) + sin(100*x);

 subplot(2,1,1)
 plot(x, y, 'c')


 for corrida = 1:6
     for k = 2:(length(x)) -1 ;
   
 y(k)  = 0.25*(y(k-1) + 2*y(k) + y(k+1));
     end
 end

 subplot(2,1,2)
  plot(x, y, 'y')
%%%%%%%%%%%%%%%%%%

Por otro lado, estos son los comandos extra para hacer otro tipo de gráficas:

X = [linspace(0,pi*3/8,20); linspace(pi*5/8, pi, 20)];

Y = sin(X); % Tanto la X como la Y son matrices

plot(X,Y) % Esto no es lo que se esperaba!!! Hay que teneren cuenta que se imprime por columnas

pie(X)

pie(X, Explode)

x = [1 1 2 3 5 8];

ex = [0 1 0 0 1 0];

pie(x, ex);

hist(X)

hist(X, nbins)

x = randn(1,10000);

hist(x);

% Generamos números aleatorios con distribución normal y

uniforme

x = [randn(10000, 1) rand(10000, 1)*6-3]

hist(x, 50);

x = 0.5:0.5:4;

y = 1./x;

barh(x, y)

Barras apiladas

x = 0.5:0.5:4;

y = 1./x;

Y = [y' fliplr(y)'];

bar(x, Y)

x = 0.5:0.5:4;

y = 1./x;

Y = [y' fliplr(y)'];

bar(x, Y, 'stacked')

x = randn(1,100);

y = randn(1,100);

scatter(x, y)

scatter(x, y, rand(1, 100)*1000, [1 0.5 0])