def img_without_bck(img, filtro=1, n=3):
#Si la imagen es a color se convierte a niveles de gris
if (len(img.shape) > 2):
img = color.rgb2gray(img)
#Imagen del fondo estimado
bck = np.zeros(img.shape)
#Imagen sin el fondo
out = np.zeros(img.shape)
#AQUÍ: Empice su código
#Convierte la imagen original a float
img = util.img_as_ubyte(img);
#Aplica el filtro para estimar el fondo
if (filtro == 1):
bck = filters.rank.mean(img, np.ones((n,n)));
elif (filtro == 2):
bck = filters.rank.median(img, np.ones((n,n)));
elif (filtro == 3):
bck = filters.rank.maximum(img, np.ones((1,n)));
elif (filtro == 4):
bck = filters.rank.maximum(img, np.ones((n,1)));
else:
print("debe ingresar un filtro valido");
return;
#Convierte la imagen original y el fondo a float
bck = util.img_as_float(bck);
img = util.img_as_float(img);
#Los valores que estén en negativos los setea como 0 y los que estén sobre 1 les pone 1
out = np.clip((bck - img), 0, 1);
#Convierte la imagen a blanco y negro
out2 = np.zeros(out.shape);
out2[out >= 0.05] = 1;
#Mostramos el resultado
skdemo.imshow_all(img, bck, out2, size=7, titles=["Original", "Fondo", "Bordes"] )
return bck, out
def img_enhance(img):
#AQUÍ: Empice su código
#Si la imagen es a color se convierte a niveles de gris
if (len(img.shape) > 2):
img = color.rgb2gray(img)
#Convierte la imagen original a float
img = util.img_as_float(img);
#Aplicamos el filtro de la mediana con una mascara de 3*3
img2 = filters.rank.median(img, np.ones((3,3), dtype=float));
#Convertimos la imagen a float
img2 = np.clip(util.img_as_float(img2), 0, 1);
#Obtener los bordes horizontales
# Creamos la mascara kernel
k1 = np.array([[1, -2, 1]]);
# Aplicamos el filtro para obtener los bordes horizontales
img3 = scipy.signal.convolve2d(img2, k1, mode='same', boundary='fill', fillvalue=0);
img3 = np.clip(img3, 0, 1);
#Obtener los bordes verticales
# Creamos la mascara kernel
k2 = np.array([[1],
[-2],
[1]]);
# Aplicamos el filtro para obtener los bordes verticales
img4 = scipy.signal.convolve2d(img2, k2, mode='same', boundary='fill', fillvalue=0);
img4 = np.clip(img4, 0, 1);
# Obtiene los pixel maximos entre las imágenes de bordes verticales y horizontales
img5 = np.maximum(img3, img4);
# Suma los bordes a la imagen original
img6 = np.clip(img + img5, 0, 1);
#Mostramos el resultado
titles = ["Original", "bordes horizontales", "bordes verticales", "Máximos entre bordes", "imagen resaltada"];
skdemo.imshow_all(img, img3, img4, img5, img6, size=7, titles=titles);
# Cargamos una de las imágenes en niveles de gris
cat = color.rgb2gray(data.chelsea())
# Revisamos el tipo de la imagen
print ("Tipo de dato de la imagen Original: ", img.dtype)
# Como la imagen es floante debemos pasarla a uint8 o untin16
# El tipo de la imagen debe cambiar porque la función solo recibe imágenes enteras
cat = util.img_as_ubyte(cat)
print ("Tipo de dato de la imagen convertida: ", img.dtype)
# Aplicamos el filtro promedio de 5x5 usando skimage
avg = filters.rank.mean(cat, np.ones((5,5)))
# Mostramos las imágenes
skdemo.imshow_all(cat, avg, titles=["Imagen Original", "Imagen Promedio"])
# Filtro de Suavizado Gaussiano¶
# El filtro Gaussiano es el filtro clásico de suavizado y es muy similar al filtro promedio. Sin embargo,
# el filtro Gaussiano no pondera de igual manera a todos los píxeles en el vecindario: los píxeles qué
# están más cerca al píxel central tienen mayor peso que aquellos que están más alejados de este.
# Creamos una matriz de zeros y cambiamos el valor del píxel central
m = np.zeros((5,5))
m[2,2] = 1
# Usamos la función del paquete filters para generar la máscara
k_gauss = filters.gaussian(m, sigma=0.5)
print("Kernel con sigma = 0.5:\n", np.array_str(k_gauss, precision=3, suppress_small=True))
def imshow_edges(image, horizontal_edge_kernel, vertical_edge_kernel):
horizontal_edges = convolve(image, horizontal_edge_kernel)
vertical_edges = convolve(image, vertical_edge_kernel)
skdemo.imshow_all(horizontal_edges, vertical_edges)
# In[2]: import skdemo from skimage import data color_image = data.chelsea() red_image = np.zeros_like(color_image) green_image = np.zeros_like(color_image) blue_image = np.zeros_like(color_image) red_image[:, :, 0] = color_image[:, :, 0] green_image[:, :, 1] = color_image[:, :, 1] blue_image[:, :, 2] = color_image[:, :, 2] skdemo.imshow_all(red_image, green_image, blue_image) # Alternatively, we can "unpack" our RGB image into red, green, and blue channels using `np.rollaxis` # In[3]: np.rollaxis(color_image, axis=-1).shape # The `axis` argument tells `rollaxis` which axis to... ahem... roll to the front. # In[4]: red_image = np.zeros_like(color_image) green_image = np.zeros_like(color_image) blue_image = np.zeros_like(color_image)
from skimage import morphology # Para crear el kernel de convolución en los filtros no lienales
# Con este nos aseguramos que las imagenes en niveles de gris, se vean como tal siempre.
plt.rcParams['image.cmap'] = 'gray'
plt.rcParams['image.interpolation'] = 'none'
# Leemos una de las imágenes de prueba de la practica
color_image = io.imread('imagenes/balloon.jpg')
# Pasamos la imagen al espacio de color Lab: L=luminancia, a y b definen el color real o tono
lab_image = color.rgb2lab(color_image)
lab_image.shape
#Observe que al cambiar el espacio de color, las dimensiones de la imagen no cambian en absoluto.
# Sin embargo, visualicemos la imagen ...
skdemo.imshow_all(color_image, lab_image, titles=["Imagen Original", "Imagen Lab"])
# La función imshow visualiza una imagen en RGB, sin embargo, las matrices de la imagen en el espacio Lab no
# se parecen en nada a las matrices de una imagen RGB.
# Dicho esto, hay un cierto parecido con la imagen en RBG. Observe, la información de cada canal:
skdemo.imshow_all(lab_image[..., 0], lab_image[..., 1], lab_image[..., 2],
titles=['L', 'a', 'b'])
# Parte de la gama de colores RGB en el espacio Lab se pueden visualizar a continuación, para valores específicos de luminancia.
# Note que la información de color es más uniforme en el espacio Lab que en el espacio RGB. Es más, estos se aproximan más a
# la forma como el ojo humano percibe los colores.
# En Skimage las funciones para los espacios de color son las siguientes:
# rgb2yiq: Convierte de RGB a YIQ
# In[2]:
import skdemo
plt.rcParams['image.cmap'] = 'spectral'
from skimage import io, segmentation as seg, color
url = '../images/spice_1.jpg'
image = io.imread(url)
# In[3]:
labels = seg.slic(image, n_segments=18, compactness=10)
skdemo.imshow_all(image, labels.astype(float) / labels.max())
print labels
# We can try to create a nicer visualization for `labels`: each segment will be represented by its average color.
# In[4]:
def mean_color(image, labels):
out = np.zeros_like(image)
for label in np.unique(labels):
indices = np.nonzero(labels == label)
out[indices] = np.mean(image[indices], axis=0)
return out
skdemo.imshow_all(image, mean_color(image, labels))
plt.rcParams['image.cmap'] = 'gray' plt.rcParams['image.interpolation'] = 'none' # We've already discussed edge filtering, using the Sobel filter, in the last section. # In[2]: import skdemo from skimage import data # Rename module so we don't shadow the builtin function import skimage.filter as filters image = data.camera() pixelated = image[::10, ::10] gradient = filters.sobel(pixelated) skdemo.imshow_all(pixelated, gradient) # With the Sobel filter, however, we get back a grayscale image, which essentially tells us the likelihood that a pixel is on the edge of an object. # # We can apply a bit more logic to *detect* an edge; i.e. we can use that filtered image to make a *decision* whether or not a pixel is on an edge. The simplest way to do that is with thresholding: # In[3]: skdemo.imshow_all(gradient, gradient > 0.4) # That approach doesn't do a great job. It's noisy and produces thick edges. Furthermore, it doesn't use our *knowledge* of how edges work: They should be thin and tend to be connected along the direction of the edge. #### Canny edge detector # The Canny edge detector combines the Sobel filter with a few other steps to give a binary edge image. The steps are as follows: # * Gaussian filter
# <codecell> import skdemo # Uncomment and press <TAB> to see available functions in `skdemo` #skdemo. # <TAB> # <codecell> # This code is just a template to get you started. red_image = np.ones((1,1)) # TODO: replace with your code green_image = np.ones((1,1)) # TODO blue_image = np.ones((1,1)) # TODO skdemo.imshow_all(color_image, red_image, green_image, blue_image) # <markdowncell> # <subslide> # Or, simply use ``matplotlib.subplots``: # <codecell> fig, axes = plt.subplots(1, 4, figsize=(10,2)) axes[0].imshow(color_image) axes[1].imshow(green_image) # etc...
print mean_kernel.sum() # Note that all the values of the kernel sum to 1. Why might that be important? Sure, a definition of a mean requires this property, but why might this be a favorable property for many image filters? #### Downsampled image # Let's consider a real image now. It'll be easier to see some of the filtering we're doing if we downsample the image a bit. We can slice into the image using the "step" argument to sub-sample it: # In[13]: from skimage import data image = data.camera() pixelated = image[::10, ::10] skdemo.imshow_all(image, pixelated) # Here we use a step of 10, giving us every tenth column and every tenth row of the original image. You can see the highly pixelated result on the right. #### Mean filter on a real image # Now we can apply the filter to this downsampled image: # In[14]: filtered = convolve(pixelated, mean_kernel) skdemo.imshow_all(pixelated, filtered) # Comparing the filtered image to the pixelated image, we can see that this filtered result is smoother: Sharp edges (which are just borders between dark and bright pixels) are smoothed because dark pixels reduce the intensity of neighboring pixels and bright pixels do the opposite.
from skimage import io
color_image = io.imread('../images/balloon.jpg')
# In[16]:
import skdemo
#skdemo. # <TAB>
# In[17]:
# This code is just a template to get you started.
red_image = np.zeros_like(color_image)
green_image = np.zeros_like(color_image)
blue_image = np.zeros_like(color_image)
skdemo.imshow_all(color_image, red_image, green_image, blue_image)
# ---
##### Combining color-slices with row/column-slices
# In the examples above, we just manipulate the last axis of the array (i.e. the color channel). As with any NumPy array, however, slicing can be applied to each axis:
# In[18]:
color_patches = color_image.copy()
# Remove green (1) & blue (2) from top-left corner.
color_patches[:100, :100, 1:] = 0
# Remove red (0) & blue (2) from bottom-right corner.
color_patches[-100:, -100:, (0, 2)] = 0
plt.imshow(color_patches)
# Filtro Mediana¶ # Este es uno de los filtros más usados para suavizar una imagen dado que preserva los bordes de la misma mientras elimina el ruido. # Al igual que con los filtros espaciales tradicionales, el filtro mediana centra el kernel de convolución en cada # pixel de la misma, reemplazando su valor por la mediana entre todos los valores que cubre el kernel. # Este filtro funciona muy bien para eliminar el ruido, especialmente el ruido de tipo impulsivo. # El siguiente ejemplo muestra cómo usar el filtro mediana en una imagen con ruido "sal y pimienta". # Además, la imagen se filtra usando un filtro gaussiano para fines de comparación. # Cargamos la imagen y le agregamos ruido img = skimage.img_as_ubyte(data.camera()) img_noisy = util.random_noise(img, "s&p") # Mostramos las imágenes skdemo.imshow_all(img, img_noisy, titles=["Imagen Original", "Imagen con Ruido S&P"]) # Kernel de convolución k = morphology.square(3) # Se aplica el filtro mediana img_median = filters.rank.median(img_noisy, k) # Se aplica el filtro gaussiano img_gauss = filters.gaussian(img_noisy, sigma=1.0) skdemo.imshow_all(img_median, img_gauss, titles=["Filtro Mediana", "Filtro Gaussiano"]); #Visualizando los detalles skdemo.imshow_all(img_median[100:200, 200:400], img_gauss[100:200, 200:400]);
# <codecell> protein, centromeres, chromosomes = image.transpose((2, 0, 1)) # <markdowncell> # Getting the centromeres is easy because the signal is so clean: # <codecell> from skimage.filter import threshold_otsu centromeres_binary = centromeres > threshold_otsu(centromeres) skdemo.imshow_all(centromeres, centromeres_binary) # <markdowncell> # But getting the chromosomes is not so easy: # <codecell> chromosomes_binary = chromosomes > threshold_otsu(chromosomes) skdemo.imshow_all(chromosomes, chromosomes_binary, cmap='gray') # <markdowncell> # Let's try using an adaptive threshold:
# <codecell>
ic = io.ImageCollection('../images/pano/DFM_*')
# <markdowncell>
# The ``ImageCollection`` class provides an easy way of
# loading and representing multiple images. Images are not
# read from disk until accessed.
# <codecell>
imshow_all(ic[0], ic[1])
# <markdowncell>
# Credit: Photographs taken in Petra, Jordan by François Malan<br/>
# License: CC-BY
# <codecell>
image0 = rgb2gray(ic[0][:, 500:500+1987, :])
image1 = rgb2gray(ic[1][:, 500:500+1987, :])
image0 = transform.rescale(image0, 0.25)
image1 = transform.rescale(image1, 0.25)
# método ISODATA # Método Otsu # Método de Yen # Método de Li (basado en entreopía) # Veamos como usar los tres primeros y veamos los resultados en ambas imágenes: # Método Adaptativo # Revise la documentación a fin de que conozca los parámetros de la función t1 = filters.threshold_local(img_1, 15, 'mean') t2 = filters.threshold_local(img_2, 81, 'gaussian') img_BW_1 = img_1 > t1 img_BW_2 = img_2 > t2 skdemo.imshow_all(img_BW_1, img_BW_2, titles=["Arroz umbral Adaptativo - Mean", "Coins umbral Adaptativo - Mean"]) # Método ISODATA # Revise la documentación a fin de que conozca los parámetros de la función t1 = filters.threshold_isodata(img_1) t2 = filters.threshold_isodata(img_2); img_BW_1 = img_1 > t1; img_BW_2 = img_2 > t2; skdemo.imshow_all(img_BW_1, img_BW_2, titles=["Arroz umbral isodata", "Coins umbral isodata"]) # Método yen # Revise la documentación a fin de que conozca los parámetros de la función
sq = morphology.square(width=3) dia = morphology.diamond(radius=1) print(sq) print(dia) # <markdowncell> # The central value of the structuring element represents the pixel being # considered, and the surrounding values are the neighbors: a 1 value means that # pixel counts as a neighbor, while a 0 value does not. So: # <codecell> skdemo.imshow_all(image, morphology.erosion(image, sq), shape=(1, 2)) # <markdowncell> # and # <codecell> skdemo.imshow_all(image, morphology.dilation(image, sq)) # <markdowncell> # and