Métodos

En esta página se describen los métodos y técnicas utilizados en el proyecto. Se explican los algoritmos estudiados, las herramientas usadas y las tecnologías y procesos implicados en la construcción del proyecto.

Imagen inicial

Se utilizan imágenes de una estructura fork sintética que esta parpadeando. En un principio las imagenes que tenemos son parecidas a la siguiente:

Figura 1: Imagen base

Tratamiento temporal

Debido a la naturaleza del fenómeno en una imagen instantánea podemos no tener toda la información requerida, es por esto que se implementa una pequeña parte de análisis temporal. Para esto se decidirá trabajar con varias imágenes del mismo objeto observado a lo largo del tiempo y se procederá a realizarle operaciones matemáticas al stack de imágenes. Dependiendo de las caraceterísticas podemos querer la media , la mediana o la varianza.

Figura 2: Imagen media

Figura 3: Imagen mediana

Figura 4: Varianza de la imagen

Ampliación

Posteriormente ya que contamos con imágenes relativamente pequeñas (27px x 27px) se procede a aumentar su tamaño con una interpolación bicúbica mediante la función de scipy zoom obteniendo los siguientes resultados:

Figura 5: Imagen media ampliada digitalmente 5 veces

Cálculo de MSSR

Se procede al cálculo de la media desplazada(MS), para esto es necesario la determinación de un parámetro hs que es representativo del tamaño del kernel, el mismo tiene la finalidad de separar la estructura de interés.En este paso se recorre la imagen con un kernel (de lado hs) con pesos exponenciales y restar a esta ponderación el valor del pixel central, una vez recorrida la imagen tenemos el vector MS. Es importante notar que implementarlo de esta manera es poco práctico computacionalmente y tiene tiempos ordenés de magnitud superiores a la implementación que se realizó, esta implementación es equivalente a "pasar la imagen por el kernel" y fue recomendada por el tutor. Una vez calculada la MS se toma el opuesto de los valores, posteriormente transformamos los valores negativos de la imagen a 0 y después normalizamos. En esta etapa ya tenemos una imagen con mejor resolución pero podemos seguir aplicando operaciones matemáticas para seguir refinando nuestra imagen.

Figura 6: Imagen con MSSR de orden 0

Figura 7: Pasos del algoritmo MSSR

Figura 8: Imagen con MSSR de orden 1

Implementación en python

def sfMSSR(img,ampliacion,hs,order,temporal=None):


    #Procesamiento temporal
    if temporal=='mean':
        img = np.mean(img,axis=0)
    elif temporal == 'var':
        img = np.var(img,axis=0)
    elif temporal == 'median':
        img=np.median(img,axis=0)

    #Ampliamos la imagen con un factor de ampliación e interpolacion bicubica
    img = zoom(img, ampliacion, order=3)
    width , height = img.shape
    #Padeamos la imagen para poder recorrerla
    Ipad=np.pad(img,hs,'symmetric')
    #Guardamos la diferencia máxima entre el punto y el ancho de banda para normalizar
    M=np.zeros((width,height))
    for i in range(-hs,hs+1):
        for j in range(-hs,hs+1):
            if i!=0 and j!=0:
                HS=Ipad[hs+i:width+hs+i,hs+j:height+hs+j]
                M=np.maximum(M,np.abs(img-HS))

    PesosAcum=np.zeros((width,height))
    ValoresAcum=np.zeros((width,height))

    #Recorremos el filtro con la imagen(Es una optimización necesaria para no recorrer la imagen)
    for i in range(-hs,hs+1):
        for j in range(-hs,hs+1):
            if i!=0 and j!=0:
                kernelEspacial=np.exp(-(pow(i,2)+pow(j,2))/pow((hs),2))
                HS=Ipad[hs+i:width+hs+i,hs+j:height+hs+j]
                kernelIntensidad=np.exp(-pow((img-HS)/M,2))

                Pesos=kernelEspacial*kernelIntensidad
                PesosAcum=PesosAcum+Pesos
                ValoresAcum=ValoresAcum+Pesos*HS

    MS=img-(ValoresAcum/PesosAcum)
    MS[MS<0]=0
    MS[np.isnan(MS)]=0

    I0=MS/max(map(max,MS))
    I3=I0
    x3= img/max(map(max,img))

    for i in range(order):
        #Calculamos la diferencia entre la original y la imagen MS ambas normalizadas
        I4 = x3 - I3
        #Calculamos el complemento hasta el máximo
        I5 = max(map(max, I4)) - I4
        #Normalizamos
        I5 = I5/max(map(max, I5))
        #Realizamos el intensity weighting
        I6 = I5*I3
        #Normalizamos de nuevo
        I7 = I6/max(map(max, I6))
        x3 = I3
        I3 = I7
    I3[np.isnan(I3)] = 0
    IMSSR = I3*img

    return IMSSR