se añade el archivo Markdown que contiene el ejercicio desarrollado. Tambien e...

se añade el archivo Markdown que contiene el ejercicio desarrollado. Tambien e ñaden las imagenes necesarias para el correto renderizado del mismo

Entrega.md

+# *Mi nombre es Jesus David Bermudez Sanchez, soy estudiante de la Maestria en Fisica de la Universidad Nacional de Colombia, Sede Bogotá*
+
+---
+
+### Importamos y cargamos la imagen
+
+Lo primero que hacemos es cargar la imagen de las estrellas como un arreglo de numpy; para ello usamos la "funcion" `imread()`. 
+
+La imagen queda guardada como un arreglo 3-dimensional de numpy.
+
+
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+
+zapatoca = plt.imread('./data/zapatocaImage.jpeg')
+
+plt.imshow(zapatoca)
+plt.show()
+```
+
+
+    
+![png](output_2_0.png)
+    
+
+
+### Creamos las estrellas.
+Siguiendo un proceso manual, se escogieron ocho de las estrellas que aparecen en la foto.
+
+Todas estas estrellas se guardaron en una lista que llamamos `lista_estrellas`
+
+
+```python
+
+estrellita_1=zapatoca[237:250,210:226]
+estrellita_2=zapatoca[142:155,382:405]
+estrellita_3=zapatoca[370:385,440:460]
+estrellita_4=zapatoca[308:325,616:638]
+estrellita_5=zapatoca[455:467,315:334]
+estrellita_6=zapatoca[50:59,987:995]
+estrellita_7=zapatoca[540:565,650:675]
+estrellita_8=zapatoca[493:507,678:692]
+
+lista_estrellas=[estrellita_1,
+                 estrellita_2,
+                 estrellita_3,
+                 estrellita_4,
+                 estrellita_5,
+                 estrellita_6,
+                 estrellita_7,
+                 estrellita_8]
+
+plt.figure(figsize=(20,10))
+columns = 4
+for i, image in enumerate(lista_estrellas):
+    plt.subplot(len(lista_estrellas) / columns + 1, columns, i + 1)
+    plt.imshow(image)
+```
+
+    /usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:22: MatplotlibDeprecationWarning: Passing non-integers as three-element position specification is deprecated since 3.3 and will be removed two minor releases later.
+
+
+
+    
+![png](output_4_1.png)
+    
+
+
+### Creamos las estrellas rojas, verdes y azules
+
+Creamos una lista llamada `lista_estrellas_rojas` la cual va a contener la "capa" roja de las estrellas que escogimos anteriormente. Identicamente para la "capa" verde y la "capa" azul.
+
+
+```python
+lista_estrellas_rojas=[x[:,:,0] for x in lista_estrellas]
+
+lista_estrellas_verdes=[x[:,:,1] for x in lista_estrellas]
+
+lista_estrellas_azules=[x[:,:,2] for x in lista_estrellas]
+```
+
+### Convertir a blanco y negro.
+
+Para convertir a blanco y negro las imagenes en la lista `lista_estrellas`, multiplicamos cada pixel en cada capa por un determinado valor, y sumamos estos valores.
+
+En palabras mas sofisticadas, hacemos una suma "pesada" de las "capas" roja, verde y azul.
+
+Luego, usando _list comprehension_ creamos una lista llamada `lista_estrellas_bn` que contiene las estrellas que escogimos, pero en blanco y negro. 
+
+Es decir, cada elemento de esta lista tiene `shape=(filas,columnas)`
+
+
+```python
+def color_to_bn(arr):
+    """
+    Esta funcion recibe una imagen en un array 3D.
+    
+    Retorna la imagen en banco y negro en un array 2D.
+    """
+    bn_array=(0.2989*arr[:,:,0])+(0.5870*arr[:,:,1])+(0.1140*arr[:,:,2])
+    return bn_array
+
+# 
+lista_estrellas_bn=[color_to_bn(x) for x in lista_estrellas]
+```
+
+### Creamos las estimaciones.
+
+El metodo `leastsq` de scipy requiere de un arreglo de estimaciones iniciales. 
+
+A cada estrella le estamos ajustando una Gaussiana simetrica, es decir, una funcion de la forma 
+
+$$
+G(x,y)=A+B \cdot Exp\left[\frac{-((x-x_0)^2+(y-y_0)^2)}{2\,\sigma^2}\right]
+$$
+
+Esta funcion, requiere 5 parametros. 
+
+Para cada estrella se crea entonces un arreglo que contiene un estimado a "ojo" de los 5 parametros.
+
+Este procedimiento se realiza para las ocho estrellas y todos estos arreglos se guardan en una lista que hemos llamado `guess_estrellas` 
+
+
+```python
+guess_estrella_1=[120.,100,2.,8.,7.]
+guess_estrella_2=[120.,100,2.,11.,6.]
+guess_estrella_3=[120.,100,2.,10.,7.]
+guess_estrella_4=[120.,100,2.,11.,8.]
+guess_estrella_5=[120.,100,2.,9.,6.]
+guess_estrella_6=[120.,100,2.,4.,4.]
+guess_estrella_7=[120.,100,2.,12.,12.]
+guess_estrella_8=[120.,100,2.,7.,7.]
+
+guess_estrellas=[guess_estrella_1,guess_estrella_2,guess_estrella_3,
+                 guess_estrella_4,guess_estrella_5,guess_estrella_6,
+                 guess_estrella_7,guess_estrella_8]
+
+#plt.imshow(lista_estrellas_bn[7],cmap='gray')
+#plt.colorbar()
+#plt.show()
+```
+
+### Ajustamos la Gaussiana
+
+A continuacion creamos una funcion que llamamos `FWHM(a,b)` que recibe dos parametros.
+
+El primero es un arreglo 2d que representa la imagen de un estrella, y el segundo es un arreglo que contiene los 5 estimados iniciales de los parametros que queremos encontrar para ajustar una Gaussiana.
+
+Creamos la funcion que tomamos como modelo, la cual corresponde a la ecuacion que escribimos anteriormente de una Gaussiana simetrica.
+
+Creamos la función de error que devuelve las diferencias entre los valores de brillo dads por la gaussiana y los valores reales. 
+
+ACLARACIóN: Esta función de error debe retornar un arreglo 1D de numpy para que sea aceptada por `leastsq(...)`. De modo que al final hacemos np.ravel.
+
+Yo esperaría que esta función Error en el caso 2-D retornara un arreglo 2d de numpy del mismo tamaño que el de la estrella que esta ajustando y que no hubiera ningun problema con `leastsq`, pero lastimosamente, no funciona asi.
+
+Finalmente retornamos el valor de _anchura a media altura_ que, de acuerdo con Wikipedia, para el caso de la Gaussiana, corresponde a 
+$$
+FWHM \approx 2,35482 \cdot \sigma
+$$
+
+
+```python
+from scipy.optimize import leastsq 
+def FWHM(estrella_array,guess):
+    """
+    Esta funcion recibe dos parametros:
+    
+    El primero es una 'estrella' en un array bidimensional.
+    El segndo es un arreglo que contenga los estimados iniciales de los parametros
+    para ajustar la gaussiana.
+    
+    Retorna la FWHM de la gaussiana simetrica que mejor se ajusta a cada una
+    """
+    
+    # Se crean los ejes "x" y "y"
+    eje_y=np.arange(0,estrella_array.shape[0]) # eje y = filas = eje vertical
+    eje_x=np.arange(0,estrella_array.shape[1]) # eje x = columnas = eje horizontal
+ 
+    
+    # Creamos los arreglos "X" y "Y" requeridos 
+    X,Y = np.meshgrid(eje_x,eje_y)
+    
+    # El orden de los parametros es 
+    # p[0]=cte de suma
+    # p[1]=cte multiplicativa
+    # p[2]= desviacion estandar
+    # p[3]= centro en x
+    # p[4]= centro en y
+
+    def gauss_2d(params,x,y):
+
+        expone=-((x-params[3])**2 + (y-params[4])**2) / (2*params[2]**2)
+        zmodel = params[0]+params[1]*np.exp(expone)
+        return zmodel
+    
+    def Error(tpl,x,y,z):
+        zmodel = gauss_2d(tpl,x,y)
+        errors = (zmodel - z)
+        return np.ravel(errors)
+    
+    bestt,suss = leastsq(Error, guess, args=(X,Y,estrella_array))
+
+    return 2.35482*bestt[2]
+    
+```
+
+### Valores de FWHM para diferentes estrellas.
+
+Creamos 4 listas.
+
+La primera contiene los 8 valores obtenidos de FWHM en el caso de las estrellas a blanco y negro.
+
+Las otras 3 listas contiene los 8 valores obtenidos de FWHM para cada una de las "capas" de las imagenes originales.
+
+
+```python
+lista_FWHM = [FWHM(lista_estrellas_bn[i],guess_estrellas[i]) for i in range(0,8)]
+lista_FWHM_rojas = [FWHM(lista_estrellas_rojas[i],guess_estrellas[i]) for i in range(0,8)]
+lista_FWHM_verdes = [FWHM(lista_estrellas_verdes[i],guess_estrellas[i]) for i in range(0,8)]
+lista_FWHM_azules = [FWHM(lista_estrellas_azules[i],guess_estrellas[i]) for i in range(0,8)]
+```
+
+## Promedios de cada lista
+
+
+```python
+print("El promedio de los valores de FWHM para las estrellas a blanco y negro es",
+      sum(lista_FWHM)/len(lista_FWHM))
+print("--"*40)
+print("El promedio de los valores de FWHM para las estrellas rojas es",
+      sum(lista_FWHM_rojas)/len(lista_FWHM_rojas))
+print("--"*40)
+print("El promedio de los valores de FWHM para las estrellas verdes es",
+      sum(lista_FWHM_verdes)/len(lista_FWHM_verdes))
+print("--"*40)
+print("El promedio de los valores de FWHM para las estrellas azules es",
+      sum(lista_FWHM_azules)/len(lista_FWHM_azules))
+```
+
+    El promedio de los valores de FWHM para las estrellas a blanco y negro es 4.861596468360681
+    --------------------------------------------------------------------------------
+    El promedio de los valores de FWHM para las estrellas rojas es 4.650082418024009
+    --------------------------------------------------------------------------------
+    El promedio de los valores de FWHM para las estrellas verdes es 4.880889943876611
+    --------------------------------------------------------------------------------
+    El promedio de los valores de FWHM para las estrellas azules es 5.142712711971354
+
+
+## Hacemos los histogramas
+
+
+```python
+plt.figure(figsize=(20,10))
+# plt.subplot(# de filas, # de columnas, # del recuadro donde queremos hacer esta gráfcia en particular)
+plt.subplot(2, 2, 1)                       
+plt.hist(x=lista_FWHM, bins='auto', color='k',
+                            alpha=0.7, rwidth=0.85)
+plt.title('FWHM para estrellas a blanco y negro')
+plt.ylabel('Frecuencia')
+
+# plt.subplot(# de filas, # de columnas, # del recuadro donde queremos hacer esta gráfcia en particular)
+plt.subplot(2, 2, 2)                       
+plt.hist(x=lista_FWHM_rojas, bins='auto', color='r',
+                            alpha=0.7, rwidth=0.85)
+
+plt.title('FWHM para la capa roja')
+plt.ylabel('Frecuencia')
+
+# plt.subplot(# de filas, # de columnas, # del recuadro donde queremos hacer esta gráfcia en particular)
+plt.subplot(2, 2, 3)                       
+plt.hist(x=lista_FWHM_verdes, bins='auto', color='g',
+                            alpha=0.7, rwidth=0.85)
+plt.title('FWHM para la capa verde')
+plt.ylabel('Frecuencia')
+
+# plt.subplot(# de filas, # de columnas, # del recuadro donde queremos hacer esta gráfcia en particular)
+plt.subplot(2, 2, 4)                       
+plt.hist(x=lista_FWHM_azules, bins='auto', color='b',
+                            alpha=0.7, rwidth=0.85)
+plt.title('FWHM para la capa azul')
+plt.ylabel('Frecuencia')
+
+plt.show()
+```
+
+
+    
+![png](output_18_0.png)
+    
+
+
+## Conclusiones
+
+Vemos que la _anchura a media altura_ para las estrellas a blanco y negro, y para las capas roja y azul presentan resultados muy similares.
+
+El valor entre 9 y 11 corresponde a la FWHM de la estrella mas grande que se ve en la figura.
+
+La resolucion espacial promedio para la capa azul fue de 5.14, lo cual nos dice que seria mas dificil "resolver" las fuentes puntuales si solamente tuvieramos la informacion de esta longitud de onda.
+
+En nuestro caso, la longitud de onda con la resolucion mas baja, y por tanto, que nos permitiría diferenciar mejor entre estrelas sería $\lambda=$rojo
+
+
+### Bibliografia
+
++ https://stackoverflow.com/questions/41210823/using-plt-imshow-to-display-multiple-images
+
++ https://www.mathworks.com/help/matlab/ref/rgb2gray.html
+
++ https://github.com/rougier/matplotlib-tutorial
+
+
+```python
+
+```