def ej2_1_y_2(): img = cv.imread("../img/sangre.jpg", cv.IMREAD_GRAYSCALE).astype(np.float16) # Se ensucia con ruido Gaussiano img_gau = func.ruidoGaussiano(img.copy(), 0, 0.05) img_limpia_g = func.filtroMediaGeometrica(img_gau.copy(), 3, 3) # Se ensucia con ruido Impulsivo img_sp = func.ruidoSalPimienta(img.copy(), 1, 0.5) img_limpia_s = func.filtroMediaContraarmonica(img_sp.copy(), -1, 3, 3) # Para graficar vuelvo a enteros sin signo img = img.astype(np.uint8) img_gau = img_gau.astype(np.uint8) img_limpia_g = img_limpia_g.astype(np.uint8) img_sp = img_sp.astype(np.uint8) img_limpia_s = img_limpia_s.astype(np.uint8) func.graficar(img, 255, 0, 'gray', 'Imagen de entrada') func.graficar(img_gau, 255, 0, 'gray', 'Imagen con ruido Gaussiano') func.graficar(img_sp, 255, 0, 'gray', 'Imagen con ruido Sal') func.graficar(img_limpia_g, 255, 0, 'gray', 'Imagen con ruido Gaussiano limpia') func.graficar(img_limpia_s, 255, 0, 'gray', 'Imagen con ruido Sal limpia')
def ej3_1(): img = cv.imread('../img/Tarjeta.jpeg', cv.IMREAD_GRAYSCALE) img = cv.resize(img, (2 * img.shape[1], 2 * img.shape[0])) ret, imgb = cv.threshold(img, 128, 255, cv.THRESH_BINARY) imgb = imgb.max() - imgb func.graficar(imgb, 255, 0, 'gray', 'Imagen cargada (binarizada en 128)') kernelcruz = cv.getStructuringElement(cv.MORPH_CROSS, (3, 3)) # Erosionar con un kernel cruz erosion1 = cv.erode(imgb, kernelcruz, iterations=1) # func.graficar(erosion1, 255, 0, 'gray', 'Imagen erosionada con cruz') # Dilatar con un kernel cruz dilat1 = cv.dilate(erosion1, kernelcruz, iterations=1) # func.graficar(dilat1, 255, 0, 'gray', 'Imagen dilatada con cruz') # Erosionar con un kernel cruz erosion2 = cv.erode(dilat1, kernelcruz, iterations=1) # func.graficar(erosion2, 255, 0, 'gray', 'Imagen erosionada con cruz 2') median = cv.medianBlur(erosion2, 5) # func.graficar(median, 255, 0, 'gray', 'Mediana') # Dilatar con un kernel cruz dilat2 = cv.dilate(median, kernelcruz, iterations=1) # func.graficar(dilat2, 255, 0, 'gray', 'Imagen dilatada 2 con cruz') imgf = dilat2 imgf = imgf.max() - imgf func.graficar(imgf, 255, 0, 'gray', 'Imagen final')
def ej4_3_rechazabanda(): img = cv.imread("../img/img_degradada.tif", cv.IMREAD_GRAYSCALE) rows, cols = img.shape # Espectro de la imagen # Shiftear en false para poder determinar el punto del espectro a anular img_fft = fun.spectrum(img, shiftear=False) # Parametros de los filtros Butterworth (dentro del pasabanda) cortes = [.04, .043] orden = 100 # Obtengo el filtro y filtro la imagen filtro = fun.filtroRechazaBanda(rows, cols, cortes, orden) img_fil = fun.filterImg(img, filtro) # Calcular el espectro para graficarlo img_fil_s = fun.spectrum(img_fil, shiftear=False) # Graficar func.graficar(img, 255, 0, 'gray', 'Imagen original') func.graficar(img_fft, 1, 0, 'gray', 'Espectro de la imagen original') func.graficar(filtro, 1, 0, 'gray', 'Filtro notch') func.graficar(img_fil, 255, 0, 'gray', 'Imagen filtrada') func.graficar(img_fil_s, 1, 0, 'gray', 'Espectro de la imagen filtrada')
def ej5(): img = cv.imread("../img/huang3_movida.tif", cv.IMREAD_GRAYSCALE) rows, cols = img.shape img_fft = fun.spectrum(img) img_fft = np.fft.ifftshift(img_fft) func.graficar(img, 255, 0, 'gray', 'imagen original') func.graficar(img_fft, 1, 0, 'gray', 'Espectro')
def ej3_5(): img = cv.imread('../img/Globulos Rojos.jpg', cv.IMREAD_GRAYSCALE) ret, imgBin = cv.threshold(img, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU) imgBin = imgBin.max() - imgBin elemEstruc = np.ones((3, 3), np.uint8) #Le saco los bordes a la original imgBordes = imgBin.copy() for i in range(2, imgBordes.shape[0] - 2): for j in range(2, imgBordes.shape[1] - 2): imgBordes[i, j] = 0 # Reconstruccion morfologica #Ciclo, se repite hasta que la img anterio sea igual a la actual imgBordesAnterior = np.zeros((imgBordes.shape[0], imgBordes.shape[1]), np.uint8) while ((imgBordes != imgBordesAnterior).max()): imgBordesAnterior = imgBordes.copy() #Diltar dilatacion = cv.dilate(imgBordesAnterior, elemEstruc, iterations=1) #And imgBordes = np.bitwise_and(dilatacion, imgBin) # LLENADO DE CENTROS imgBordesL = imgBin.copy() imgBordesL = imgBordesL.max() - imgBordesL for i in range(2, imgBordes.shape[0] - 2): for j in range(2, imgBordes.shape[1] - 2): imgBordesL[i, j] = 0 imgBordesAnterior = np.zeros((imgBordes.shape[0], imgBordes.shape[1]), np.uint8) while ((imgBordesL != imgBordesAnterior).max()): imgBordesAnterior = imgBordesL.copy() #Diltar dilatacion = cv.dilate(imgBordesAnterior, elemEstruc, iterations=1) #And imgBordesL = np.bitwise_and(dilatacion, (imgBordes.max() - imgBordes)) imgFinal = imgBordesL.max() - imgBordesL func.graficar(imgFinal, 255, 0, 'gray', 'Imagen Binaria') #Aplico la mascara imgFinal = imgFinal.max() - imgFinal imgFinal = imgFinal / imgFinal.max() Resultado = imgFinal * img
def ej3_4(): img = cv.imread('../img/lluviaEstrellas.jpg', cv.IMREAD_GRAYSCALE) img = cv.resize(img, (2 * img.shape[1], 2 * img.shape[0])) # Binarizar la imagen ret, thres = cv.threshold(img, 25, 255, cv.THRESH_BINARY) # Elemento estructurante structElem = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]], dtype=np.uint8) kernelcuadrado = np.ones((3, 3), np.uint8) # Operaciones morfológicas ero1 = cv.erode(thres, structElem, iterations=7) # La máscara tiene que tener valores 0 o 1 mask = ero1 / 255 # Multiplicar la mascara por la imagen original para extraer la estrella imgf = mask * img # func.graficar func.graficar(img, 255, 0, 'gray', 'Imagen original') func.graficar(thres, 255, 0, 'gray', 'Imagen umbralizada') func.graficar(ero1, 255, 0, 'gray', 'Imagen erosionada') func.graficar(imgf, 255, 0, 'gray', 'Estrella fugaz extraida')
def ej2_4(): img = cv.imread("../img/huang1.jpg", cv.IMREAD_GRAYSCALE) # Cantidad de filas y columnas de la imagen rows, cols = img.shape # Variables del filtro corte = 0.010 # Creo el filtro Gauss en frecuencia filtro = fun.filterGaussian(rows, cols, corte) # Filtro pasa altos # filtro = 1- filtro func.graficar(filtro, filtro.max(), 0, 'gray', 'Filtro') # Filtro la imagen en freciencia imgFiltrada = fun.filterImg(img, filtro) # Calculo el espectro de la imagen filtrada espectro = fun.spectrum(imgFiltrada) # Grafico func.graficar(img, img.max(), 0, 'gray', 'Imagen Original') func.graficar(imgFiltrada, imgFiltrada.max(), 0, 'gray', 'Imagen filtrada') func.graficar(espectro, espectro.max(), 0, 'gray', 'Espectro')
def ej3_1(): img = cv.imread("../img/huang1.jpg", cv.IMREAD_GRAYSCALE) # Cantidad de filas y columnas de la imagen rows, cols = img.shape # Variables del filtro corte = .05 # Creo el filtro Gauss en frecuencia filtro = fun.filterGaussian(rows, cols, corte) filtroPasaAlto = 1 - filtro a = 1.1 A = a * np.ones([rows, cols]) Hap = (A - 1) + filtroPasaAlto # Filtro la imagen en freciencia imgFiltrada = fun.filterImg(img, Hap) # Calculo el espectro de la imagen filtrada espectro = fun.spectrum(imgFiltrada) # Grafico func.graficar(img, img.max(), 0, 'gray', 'Imagen Original') func.graficar(filtroPasaAlto, filtroPasaAlto.max(), 0, 'gray', 'Filtro pasa alto') func.graficar(imgFiltrada, imgFiltrada.max(), 0, 'gray', 'Imagen filtrada (filtro de alta frecuencia)') func.graficar(espectro, espectro.max(), 0, 'gray', 'Espectro')
def ej3_2(show_fft = True): img = cv.imread("../img/camaleon.tif", cv.IMREAD_GRAYSCALE) # Cantidad de filas y columnas de la imagen rows, cols = img.shape # Variables del filtro corte = 0.05 # Creo el filtro Gauss en frecuencia filtro = fun.filterGaussian(rows, cols, corte) filtroPasaAlto = np.ones([rows, cols]) - filtro #Creo filtro de alta potencia a = 0.5 b = 10 filtroEAF = a + b * filtroPasaAlto # Filtro la imagen en freciencia imgFiltrada = fun.filterImg(img, filtroEAF) #TDF de la imagen original espectro = fun.spectrum(img) # TDF de la imagen filtrada espectroFiltrada = fun.spectrum(imgFiltrada) func.graficar(img, 255, 0, 'gray', 'Imagen Original') func.graficar(imgFiltrada, 255, 0, 'gray', 'Imagen Filtrada (Alta potencia frecuencial)') if show_fft: func.graficar(espectro, espectro.max(), 0, 'gray', 'TDF imagen original') func.graficar(espectroFiltrada, espectroFiltrada.max(), 0, 'gray', 'TDF Imagen Filtrada')
def ej4_7(): img = cv.imread("../img/HeadCT_degradada.tif", cv.IMREAD_GRAYSCALE) img_fft = fun.spectrum(img) img_fft = np.fft.ifftshift(img_fft) # Cantidad de filas y columnas de la imagen rows, cols = img.shape # En este caso el filtro se construye a mano, y se anulan los puntos blancos # del espectro que no tienen nada que ver con su entorno filtro = np.ones((rows, cols)) filtro[40, 40] = 0 filtro[20, 0] = 0 filtro[0, 10] = 0 filtro[492, 0] = 0 mascara = filtro * img_fft # Aplico el filtro filtrada = fun.filterImg(img, filtro) # Graficar func.graficar(img, 255, 0, 'gray', 'Imagen original') func.graficar(img_fft, 1, 0, 'gray', 'Espectro') func.graficar(filtrada, 255, 0, 'gray', 'filtrada') func.graficar(mascara, 1, 0, 'gray', 'mascara')
def ej2_2(): img = cv.imread("../img/huang1.jpg", cv.IMREAD_GRAYSCALE) #Cantidad de filas y columnas de la imagen rows, cols = img.shape #Variables del filtro corte = 0.02 order = 5 #Creo el filtro Butterworth pasa bajos en frecuencia filtro = fun.filterButterworth(rows, cols, corte, order) # Lo convierto a pasa altos # filtro = 1 - filtro func.graficar(filtro, filtro.max(), 0, 'gray', 'Filtro') #Filtro la imagen en freciencia imgFiltrada = fun.filterImg(img, filtro) #Calculo el espectro de la imagen filtrada espectro = fun.spectrum(imgFiltrada) #Grafico func.graficar(img, img.max(), 0, 'gray', 'Imagen Original') func.graficar(imgFiltrada, imgFiltrada.max(), 0, 'gray', 'Imagen filtrada Corte: 0.02. Orden: 5.') func.graficar(espectro, espectro.max(), 0, 'gray', 'Espectro')
def ej3_8(): img = cv.imread('../img/Cuerpos.jpg', cv.IMREAD_GRAYSCALE) ret, imgBin = cv.threshold(img, 200, 255, cv.THRESH_BINARY) imgBin = imgBin.max() - imgBin #Dilato para llenar los huecos B = np.ones((3, 3), np.uint8) dilatacion = cv.dilate(imgBin, B, iterations=4) #Erociono para que vuelva al tamaño original erosion = cv.erode(dilatacion, B, iterations=4) #Ahora a sacar esqueletosss Sk = np.zeros((erosion.shape[0], erosion.shape[1]), np.uint8) Paso1 = cv.erode(erosion, B, iterations=1) while (Paso1.max() != 0): Paso2 = func.cierre(Paso1, B) Sk = Sk + (Paso1 - Paso2) Paso1 = cv.erode(Paso1, B, iterations=1) func.graficar(img, 255, 0, 'gray', 'Imagen de entrada') func.graficar(imgBin, 255, 0, 'gray', 'Imagen umbralizada') func.graficar(erosion, 255, 0, 'gray', 'Dilatada') func.graficar(Sk, 255, 0, 'gray', 'Skeleton')
def ej3_3(): img = cv.imread("../img/camaleon.tif", cv.IMREAD_GRAYSCALE) # Defino el filtro en el espacio n = 5 filtered = cv.filter2D(img, -1, np.ones((n, n), np.float32) / (n * n)) # Coeficiente del filtro de alta potencia A = 2.0 # Filtro de alta potencia img2 = cv.subtract(A * img, filtered.astype(np.float)) func.graficar(img2, 255, 0, 'gray', 'Imagen filtrada (Alta potencia espacial)') # Filtro de alta potencia en frecuencia ej3_2(show_fft = False)
def ej1_1(): # Implementación de distintos tipos de ruido: Descomentar la gráfica del que sea de interés # Cargar imagen img = cv.imread("../img/cameraman.tif", cv.IMREAD_GRAYSCALE) # Ruidos (copiar imagen y generar ruido) salYpimienta = img.copy() salYpimienta = func.ruidoSalPimienta(salYpimienta, 0.5, 0.03) gauss = img.copy() gauss = func.ruidoGaussiano(gauss, 0, 0.02) raileigh = img.copy() raileigh = func.ruidoRayleigh(raileigh, 0.5) uniforme = img.copy() uniforme = func.ruidoUniforme(uniforme, 0, 0.5) exponencial = img.copy() exponencial = func.ruidoExponencial(exponencial, 0.09) gamma = img.copy() gamma = func.ruidoGamma(gamma, 1, 0.2) # Graficar func.graficar(img, 255, 0, 'gray', 'Imagen de entrada') func.histograma(img, 'Imagen de entrada') # func.graficar(salYpimienta, 255, 0, 'gray', 'Ruido Sal y pimienta') # func.histograma(salYpimienta, 'Ruido sal y pimienta') # func.graficar(gauss, 255, 0, 'gray', 'Ruido Gaussiano') # func.histograma(gauss, 'Ruido gaussiano') # func.graficar(raileigh, 255, 0, 'gray', 'Ruido Raileigh') # func.histograma(raileigh, 'Ruido Raileigh') # func.graficar(uniforme, 255, 0, 'gray', 'Ruido Uniforme') # func.histograma(uniforme, 'Ruido Uniforme') # func.graficar(exponencial, 255, 0, 'gray', 'Ruido Exponencial') # func.histograma(exponencial, 'Ruido Exponencial') func.graficar(gamma, 255, 0, 'gray', 'Ruido Gamma') func.histograma(gamma, 'Ruido Gamma')
def ej6_B(): # Analisis de B imgB = cv.imread("../img/FAMILIA_b.jpg", cv.IMREAD_GRAYSCALE) func.graficar(imgB, 255, 0, 'gray', 'Original B') # Extraigo la subimagen que quiero segmentar de cada imagen a analizar sub_imgB = sub_image("../img/FAMILIA_b.jpg") sub_imgB = cv.cvtColor(sub_imgB, cv.COLOR_BGR2GRAY) # Analizo el histograma de sub imagen func.histograma(sub_imgB, "Histograma B") #Calculo los parametros estadisticos para cada sub imagen mediaB = np.mean(sub_imgB) varianzaB = np.var(sub_imgB) print mediaB, varianzaB #La imagen B tiene ruido uniforme y gausiano sub_imgB_midPoint = func.filter_midPoint3(sub_imgB) imgB_midPoint = func.filter_midPoint3(imgB) mediaB_midPoint = np.mean(sub_imgB_midPoint) varianzaB_midPoint = np.var(sub_imgB_midPoint) print mediaB_midPoint, varianzaB_midPoint func.histograma(sub_imgB_midPoint, "B Despues de filtro de punto medio") sub_imgB_adaptative = func.filter_adaptative(sub_imgB, varianzaB) imgB_adaptative = func.filter_adaptative(imgB, varianzaB) mediaB_adaptative = np.mean(sub_imgB_adaptative) varianzaB_adaptative = np.var(sub_imgB_adaptative) print mediaB_adaptative, varianzaB_adaptative func.histograma(sub_imgB_adaptative, "B Despues de filtro adaptativo") # Grafico resultados func.graficar(imgB, 255, 0, 'gray', 'Original B') func.graficar(sub_imgB, 255, 0, 'gray', 'zona homogenea de B') func.graficar(imgB_midPoint, 255, 0, 'gray', 'B con filtro de punto medio') func.graficar(imgB_adaptative, 255, 0, 'gray', 'B con filtro adaptativo')
def ej3_7v2(): img = cv.imread('../img/Melanoma.jpg', cv.IMREAD_GRAYSCALE) img_o = cv.imread('../img/Melanoma.jpg') ret, imgBin = cv.threshold(img, 170, 255, cv.THRESH_BINARY) # Filtro pasa bajos n = 15 img_fpb = cv.blur(img, (n, n)) # Umbral ret, umbral = cv.threshold(img_fpb, 164, 255, cv.THRESH_BINARY) ret_img, contours, hierarchy = cv.findContours(umbral, 2, 1) cnt = contours[0] hull = cv.convexHull(cnt, returnPoints=False) defects = cv.convexityDefects(cnt, hull) # imgn = cv.drawContours(img_o, contours, -1, [255, 0, 0]) func.graficar(img_o[:, :, ::-1], 255, 0, 'gray', 'Contorno') for i in range(defects.shape[0]): s, e, f, d = defects[i, 0] start = tuple(cnt[s][0]) end = tuple(cnt[e][0]) plt.plot(start, end, 'ro-') # cv.line(img, start, end, [0, 255, 0], 2) plt.figure() # points = np.transpose(np.where(umbral)) # hull = scipy.spatial.ConvexHull(points) # Graficar func.graficar(img, 255, 0, 'gray', 'Imagen de entrada') func.graficar(umbral, 255, 0, 'gray', 'Imagen umbralizada')
def ej2(): """ cv2.HoughLines(): First parameter, Input image should be a binary image, so apply threshold or use canny edge detection before finding applying hough transform. Second and third parameters are \rho and \theta accuracies respectively. Fourth argument is the threshold, which means minimum vote it should get for it to be considered as a line. """ img_o = cv.imread("../img/letras1.tif") img_p = img_o.copy() img = cv.cvtColor(img_o, cv.COLOR_BGR2GRAY) func.graficar(img, 255, 0, 'gray', 'Bordes') bordes = cv.Canny(img, 20, 30) func.graficar(bordes, 255, 0, 'gray', 'Bordes') lines = cv.HoughLines(bordes, 1, np.pi / 180, 90) for linea in lines: for rho, theta in linea: a = np.cos(theta) b = np.sin(theta) x0 = a * rho y0 = b * rho x1 = int(x0 + 1000 * (-b)) y1 = int(y0 + 1000 * (a)) x2 = int(x0 - 1000 * (-b)) y2 = int(y0 - 1000 * (a)) cv.line(img_o, (x1, y1), (x2, y2), (0, 0, 255), 2) func.graficar(img_o[:, :, ::-1], 255, 0, 'gray', 'Hough') """ cv2.HoughLinesP(): In the hough transform, you can see that even for a line with two arguments, it takes a lot of computation. Probabilistic Hough Transform is an optimization of Hough Transform we saw. It doesn’t take all the points into consideration, instead take only a random subset of points and that is sufficient for line detection. Just we have to decrease the threshold. See below image which compare Hough Transform and Probabilistic Hough Transform in hough space. """ minLineLength = 100 maxLineGap = 10 lines = cv.HoughLinesP(bordes, 1, np.pi / 180, 100, minLineLength, maxLineGap) for line in lines: cv2.line(img_p, (line[0][0], line[0][1]), (line[0][2], line[0][3]), (0, 0, 255), 6) func.graficar(img_p[:, :, ::-1], 255, 0, 'gray', 'HoughP')
def ej3_7(): img = cv.imread('../img/Melanoma.jpg', cv.IMREAD_GRAYSCALE) ret, imgBin = cv.threshold(img, 170, 255, cv.THRESH_BINARY) imgBin = cv.medianBlur(imgBin, 31) imgBin = imgBin.max() - imgBin # #imgBin = cv.adaptiveThreshold(img, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 11, 2) # #Elementos estructurantes B1 = np.array(([1, 0, 0], [1, 0, 0], [1, 0, 0]), dtype="uint8") B2 = np.array(([1, 1, 1], [0, 0, 0], [0, 0, 0]), dtype="uint8") B3 = np.array(([0, 0, 1], [0, 0, 1], [0, 0, 1]), dtype="uint8") B4 = np.array(([0, 0, 0], [0, 0, 0], [1, 1, 1]), dtype="uint8") # # # FUNCION IMPORTANTEEEEEEE!!! GUARDAR BIEN (HIT OR MISS) # # cv.morphologyEx(input_image, cv.MORPH_HITMISS, kernel) # imgAnterior = np.zeros((imgBin.shape[0], imgBin.shape[1]), np.uint8) convexHull = imgBin.copy() while ((convexHull != imgAnterior).max()): imgAnterior = convexHull.copy() x1 = cv.morphologyEx(convexHull, cv.MORPH_HITMISS, B1) x2 = cv.morphologyEx(convexHull, cv.MORPH_HITMISS, B2) x3 = cv.morphologyEx(convexHull, cv.MORPH_HITMISS, B3) x4 = cv.morphologyEx(convexHull, cv.MORPH_HITMISS, B4) convexHull = np.bitwise_or(convexHull, x1) convexHull = np.bitwise_or(convexHull, x2) convexHull = np.bitwise_or(convexHull, x3) convexHull = np.bitwise_or(convexHull, x4) func.graficar(imgBin, 255, 0, 'gray', 'Imagen original') func.graficar(convexHull, convexHull.max(), 0, 'gray', 'Convex Hull')
def ej1_3(): cols = 512 rows = 512 linea_horizontal = np.zeros([512, 512], dtype=np.uint8) linea_horizontal[256, 0:512] = 255 M = cv.getRotationMatrix2D((cols / 2, rows / 2), 20, 1) linea_horizontal_r = cv.warpAffine(linea_horizontal, M, (cols, rows)) lh_rec = linea_horizontal[128:382,128:382] lh_rec_r = linea_horizontal_r[128:382,128:382] func.graficar(lh_rec, 255, 0, 'gray', 'Linea Horizontal Recortada') func.graficar(lh_rec_r, 255, 0, 'gray', 'Linea Horizontal Recortada Rotada') lh_fft = fun.spectrum(lh_rec) lh_r_fft = fun.spectrum(lh_rec_r) func.graficar(lh_fft, lh_fft.max(), 0, 'gray', 'Linea Horizontal Transformada') func.graficar(lh_r_fft, lh_r_fft.max(), 0, 'gray', 'Linea Horizontal Transformada')
def ej6_C(): # Analisis de C imgC = cv.imread("../img/FAMILIA_c.jpg", cv.IMREAD_GRAYSCALE) sub_imgC = sub_image("../img/FAMILIA_c.jpg") # Analizo el histograma de cada sub imagen func.histograma(sub_imgC, "Histograma C") # Calculo los parametros estadisticos para cada sub imagen mediaC = np.mean(sub_imgC) varianzaC = np.var(sub_imgC) print mediaC, varianzaC # La imagen C tiene ruido sal y pimienta, y ruido gausiano sub_imgC_Mediana5x5 = cv.medianBlur(sub_imgC, 5) imgCMediana5x5 = cv.medianBlur(imgC, 5) mediaC_Mediana5x5 = np.mean(sub_imgC_Mediana5x5) varianzaC_Mediana5x5 = np.var(sub_imgC_Mediana5x5) print 'mediana 5x5' print mediaC_Mediana5x5, varianzaC_Mediana5x5 func.histograma(sub_imgC_Mediana5x5, "C Despues de mediana 5x5") # Mediana 9x9 sub_imgC_Mediana9x9 = cv.medianBlur(sub_imgC, 9) imgCMediana9x9 = cv.medianBlur(imgC, 9) mediaC_Mediana9x9 = np.mean(sub_imgC_Mediana9x9) varianzaC_Mediana9x9 = np.var(sub_imgC_Mediana9x9) print 'mediana 9x9' print mediaC_Mediana9x9, varianzaC_Mediana9x9 func.histograma(sub_imgC_Mediana9x9, "C Despues de mediana 9x9") # Grafico resultados func.graficar(imgC, 255, 0, 'gray', 'Original C') func.graficar(sub_imgC, 255, 0, 'gray', 'Zona homogenea de C') func.graficar(imgCMediana5x5, 255, 0, 'gray', 'C despues de mediana 5x5') func.graficar(imgCMediana9x9, 255, 0, 'gray', 'C despues de mediana 9x9')
def ej4_4(): img = cv.imread("../img/img_degradada.tif", cv.IMREAD_GRAYSCALE) rows, cols = img.shape # Espectro de la imagen # Shiftear en false para poder determinar el punto del espectro a anular img_fft = fun.spectrum(img, shiftear=False) # Elegir puntos a filtrar con clic punto1 = func.elegir_punto(img_fft) fNotch1 = fun.filtroNotch(rows, cols, punto1, pixel=True) img_fil = fun.filterImg(img, fNotch1) # Calcular el espectro para graficarlo img_fil_s = fun.spectrum(img_fil, shiftear=False) # Graficar func.graficar(img, 255, 0, 'gray', 'Imagen original') func.graficar(img_fft, 1, 0, 'gray', 'Espectro de la imagen original') func.graficar(img_fil, 255, 0, 'gray', 'Imagen filtrada') func.graficar(img_fil_s, 1, 0, 'gray', 'Espectro de la imagen filtrada')
def ej3_3(): img = cv.imread('../img/estrellas.jpg', cv.IMREAD_GRAYSCALE) # imgBin = cv.adaptiveThreshold(img, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 11, 2) ret, imgBin = cv.threshold(img, 100, 255, cv.THRESH_BINARY) # ret, imgBin = cv.threshold(img,0,255,cv.THRESH_BINARY+cv.THRESH_OTSU) #Creo kernel cuadrado kernelCuad = np.ones((3, 3), np.uint8) #Erosiono erosionada = cv.erode(imgBin, kernelCuad, iterations=1) func.graficar(erosionada, 255, 0, 'gray', 'Erosion') # Enmascaro mascara = erosionada / erosionada.max() final = mascara * img func.graficar(img, 255, 0, 'gray', 'Imagen original') func.graficar(final, 255, 0, 'gray', 'Imagen Final')
def ej3_2(): img = cv.imread('../img/Caracteres.jpeg', cv.IMREAD_GRAYSCALE) img = cv.resize(img, (2 * img.shape[1], 2 * img.shape[0])) ret, imgb = cv.threshold(img, 128, 255, cv.THRESH_BINARY) imgb = imgb.max() - imgb func.graficar(img, 255, 0, 'gray', 'Imagen cargada (binarizada en 128)') kernelcruz = cv.getStructuringElement(cv.MORPH_CROSS, (3, 3)) # Erosionar con un kernel cruz erosion1 = cv.erode(imgb, kernelcruz, iterations=1) # func.graficar(erosion1, 255, 0, 'gray', 'Imagen erosionada con cruz') # Dilatar con un kernel cruz dilat1 = cv.dilate(erosion1, kernelcruz, iterations=1) # func.graficar(dilat1, 255, 0, 'gray', 'Imagen dilatada con cruz') # Erosionar con un kernel cruz erosion2 = cv.erode(dilat1, kernelcruz, iterations=1) # func.graficar(erosion2, 255, 0, 'gray', 'Imagen erosionada con cruz 2') median = cv.medianBlur(erosion2, 5) # func.graficar(median, 255, 0, 'gray', 'Mediana') # Erosionar con un kernel cuadrado kernelcuadrado = np.ones((3, 3), np.uint8) erosion2 = cv.dilate(median, kernelcuadrado, iterations=1) # func.graficar(erosion2, 255, 0, 'gray', 'Imagen erosionada con cuadrado') imgf = erosion2 imgf = imgf.max() - imgf func.graficar(imgf, 255, 0, 'gray', 'Imagen final') # Hasta acá se extraen las letras grandes.. # Ahora se extraen los simbolos simbolos = img * imgf erosion3 = cv.erode(simbolos, kernelcruz, iterations=1) func.graficar(erosion3, 255, 0, 'gray', 'Simbolos')
def ej4(): #Filtrado Homomorfico img_o = cv.imread("../img/reunion.tif", cv.IMREAD_GRAYSCALE) img = np.array(img_o, dtype=np.float32) rows, cols = img.shape # Logaritmo de la imagen original img_log = np.log(1+img) # Variables del filtro corte = 0.01 order = 5 gL = 0.5 gH = 0.6 # Filtro que voy a usar en frecuencia (basado en el gaussiano) filtro = func.filterHomomorfico(rows, cols, corte, gL, gH, order) # Filtro la imagen imgFiltrada = fun.filterImg(img_log, filtro) # Saco el logaritmo imgFinal = np.exp(imgFiltrada - imgFiltrada.min()) imgFinal = 255 * imgFinal/imgFinal.max() # La imagen se abrió como flotante para poder manipular sus números con mayor precisión # Luego de operar, se debe volver a 8 bits entero sin signo . img = np.array(img, dtype=np.uint8) imgFinal = np.array(imgFinal, dtype=np.uint8) # Ecualizacion (Ver si mejora) imgeq = cv.equalizeHist(imgFinal) # Graficar func.graficar(img, 255, 0, 'gray', 'Imagen original') func.graficar(imgFinal, 255, 0, 'gray', 'Imagen Final') func.graficar(imgeq, 255, 0, 'gray', 'Imagen Final ecualizada')
#func.graficar(maskFoco,'mascara circular de lente camara') # ============================================================================= # ############################################################################# # ############################################################################# # ------------------------------ SEGMENTACIÓN --------------------------------- # ############################################################################# # ############################################################################# # ============================================================================= # # Se convierte la imagen a escala de grises img_g=cv.cvtColor(img, cv.COLOR_BGR2GRAY) func.graficar(img_g,'imagen original en gris') # Filtro de medias no locales img_g= cv.fastNlMeansDenoising(img_g,None) # Observación de histograma por si hay datos interesantes func.histograma(img_g,grafico='true',titulo='histograma gray del lunar') # Se obtiene máscara óptima ret, img_mod_tresh = cv.threshold(img_g, 0, 255, cv.THRESH_BINARY_INV+cv.THRESH_OTSU) print("umbral optimo de otsu",ret) # Se mejora la máscara con morfologia kernelelipse = cv.getStructuringElement(cv.MORPH_ELLIPSE, (5, 5)) img_mod = funcEmi.apertura(img_mod_tresh,kernelelipse) kernelelipse = cv.getStructuringElement(cv.MORPH_CROSS, (3, 3))
def ej1_4(): img1 = cv.imread("../img/imagenB.tif", cv.IMREAD_GRAYSCALE) img2 = cv.imread("../img/cameraman.tif", cv.IMREAD_GRAYSCALE) img3 = cv.imread("../img/hubble.tif", cv.IMREAD_GRAYSCALE) img4 = cv.imread("../img/chairs.jpg", cv.IMREAD_GRAYSCALE) sp1 = fun.spectrum(img1) sp2 = fun.spectrum(img2) sp3 = fun.spectrum(img3) sp4 = fun.spectrum(img4) func.graficar(img1, img1.max(), 0, 'gray', 'Original: imagenB.tif') func.graficar(sp1, sp1.max(), 0, 'gray', 'FFT: imagenB.tif') func.graficar(img2, img2.max(), 0, 'gray', 'Original: cameraman.tif') func.graficar(sp2, sp2.max(), 0, 'gray', 'FFT: cameraman.tif') func.graficar(img3, img3.max(), 0, 'gray', 'Original: hubble.tif') func.graficar(sp3, sp3.max(), 0, 'gray', 'FFT: hubble.tif') func.graficar(img4, img4.max(), 0, 'gray', 'Original: chairs.jpg') func.graficar(sp4, sp4.max(), 0, 'gray', 'FFT: chairs.jpg')
def ej3_6(): img = cv.imread('../img/Rio.jpeg') rows, cols = img.shape[0:2] # ret, imgBin = cv.threshold(img, 114, 255, cv.THRESH_BINARY) img_hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV) H = img_hsv[:, :, 0] S = img_hsv[:, :, 1] V = img_hsv[:, :, 2] # La idea es ir segmentando por partes (y luego sumar esas partes), empezando por # lo más fácil, que es el río. Su H está alrededor de 112. h_rio, tol1 = 112, 25 ret, mask_rio1 = cv.threshold(H, h_rio - tol1, 255, cv.THRESH_BINARY) mask_rio1 = cv.medianBlur(mask_rio1, 9) mask_rio1 = cv.blur(mask_rio1, (15, 15)) ret, mask_rio1 = cv.threshold(mask_rio1, 85, 255, cv.THRESH_BINARY) # Ahora saco los afluentes, para ello primero umbralizo en S. Luego veo que zonas grandes # quedaron y comparo con la informacion de la mascara 1, ya que las zonas grandes deben tener # un color similar. s_aflu = 128 ret, mask_rio2 = cv.threshold(S, s_aflu, 255, cv.THRESH_BINARY) mask_rio2 = 255 - mask_rio2 # Obtengo de esta mascara las zonas grandes (mediana) y mediante la resta con la mascara 1 mask_rio3 = cv.medianBlur(mask_rio2, 47) mask_rio4 = mask_rio3 - mask_rio1 # La diferencia entre la máscara 3 y la 4, es que la 3 contiene partes del río que sí # corresponden, mientras que la 4 tiene zonas homogeneas grandes que no corresponden. ret, mask_rio4 = cv.threshold(mask_rio4, 200, 255, cv.THRESH_BINARY) mask_rio4 = (255 - mask_rio4) / 255 # Elimino de la máscara 2 lo que no va: mask_rio2 = mask_rio2 * mask_rio4 # Componentes conectadas de la mascara 2 output = cv.connectedComponentsWithStats(mask_rio2, 4, cv.CV_32S) labels = output[1] # Tengo muchas componentes conectadas, como 5000, por lo tanto, ubico cual es la que me # interesa y al resto la anulo o las dejo como estan labels[np.where(labels > 208)] = 0 # Para poder umbralizar tengo que cambiar el tipo de entero labels = labels.astype(np.uint8) # umbralizo en el label que me interesa ret, mask_rio2 = cv.threshold(labels, 190, 255, cv.THRESH_BINARY) # sumo las mascaras mask_rio = mask_rio1 + mask_rio2 # Para multiplicarla, convierto los valores distintos de cero a 1 mask_rio[np.where(mask_rio != 0)] = 1 # Dilato para conectar un poco mask_rio = cv.dilate(mask_rio, np.ones(5, dtype=np.uint8), iterations=3) # Aplico la mascara a la imagen original solorio = img.copy() solorio[:, :, 0] = img[:, :, 0] * mask_rio solorio[:, :, 1] = img[:, :, 1] * mask_rio solorio[:, :, 2] = img[:, :, 2] * mask_rio # todo mejorar: Aplicar desenfoque a la máscara, eliminar partes de la mascara que sean G en la img func.graficar(img[:, :, ::-1], 255, 0, 'gray', 'Imagen de entrada') # func.graficar(H, 255, 0, 'gray', 'Canal H') # func.graficar(S, 255, 0, 'gray', 'Canal S') # func.graficar(V, 255, 0, 'gray', 'Canal V') # func.graficar(mask_rio1, 255, 0, 'gray', 'Mascara 1') # func.graficar(mask_rio2, 255, 0, 'gray', 'Mascara 2') # func.graficar(mask_rio3, 255, 0, 'gray', 'Mascara 3') # func.graficar(mask_rio4, 1, 0, 'gray', 'Mascara 4') # func.graficar(mask_rio, 255, 0, 'gray', 'Suma') func.graficar(solorio[:, :, ::-1], 255, 0, 'gray', 'Solo rio')
def ej1_1y1_2(): linea_vertical = np.zeros([512,512],dtype=np.uint8) linea_vertical[0:512,256] = 255 linea_horizontal = np.zeros([512,512],dtype=np.uint8) linea_horizontal[256, 0:512] = 255 circulo = np.zeros([512,512],dtype=np.uint8) cv.circle(circulo, (256,256), 50, 255, -1) cv.circle(circulo, (256,256), 49, 0, -1) rectangulo = np.zeros([512,512],dtype=np.uint8) cv.rectangle(rectangulo, (156,206), (356, 306), 255,3) rectanguloC = np.zeros([512, 512], dtype=np.uint8) cv.rectangle(rectanguloC, (100, 206), (300, 306), 255, 3) cuadrado = np.zeros([512,512],dtype=np.uint8) cv.rectangle(cuadrado, (206,206), (306, 306), 255,3) lv_fft = fun.spectrum(linea_vertical) lh_fft = fun.spectrum(linea_horizontal) cr_fft = fun.spectrum(circulo) rc_fft = fun.spectrum(rectangulo) rc_fft2 = fun.spectrum(rectanguloC) cd_fft = fun.spectrum(cuadrado) func.graficar(linea_vertical, 255, 0, 'gray', 'Linea Vertical') func.graficar(lv_fft, lv_fft.max(), 0, 'gray', 'Linea Vertical Transformada') func.graficar(linea_horizontal, 255, 0, 'gray', 'Linea Horizontal') func.graficar(lh_fft, lh_fft.max(), 0, 'gray', 'Linea Horizontal Transformada') func.graficar(circulo, 255, 0, 'gray', 'Circulo') func.graficar(cr_fft, cr_fft.max(), 0, 'gray', 'Circulo Transformada') func.graficar(rectangulo, 255, 0, 'gray', 'Rectangulo') func.graficar(rc_fft, rc_fft.max(), 0, 'gray', 'Rectangulo Transformada') func.graficar(rectanguloC, 255, 0, 'gray', 'Rectangulo corrido') func.graficar(rc_fft2, rc_fft2.max(), 0, 'gray', 'Rectangulo Transformada Corrida') func.graficar(cuadrado, 255, 0, 'gray', 'Cuadrado') func.graficar(cd_fft, cd_fft.max(), 0, 'gray', 'Cuadrado Transformada')
def ej2_1(): img = cv.imread("../img/huang1.jpg", cv.IMREAD_GRAYSCALE) rows, cols = img.shape # Filtros pasa altos: Para que funcionen, comentar los pasa bajos. # imgf1 = fun.filterImg(img, 1-fun.filterIdeal(rows,cols,0.08)) # spec1 = fun.spectrum(fun.filterImg(img,fun.filterIdeal(rows,cols,0.15))) # # imgf2 = fun.filterImg(img, 1-fun.filterIdeal(rows,cols,0.15)) # spec2 = fun.spectrum(fun.filterImg(img, fun.filterIdeal(rows,cols,0.15))) # # imgf3 = fun.filterImg(img, 1-fun.filterIdeal(rows,cols,0.6)) # spec3 = fun.spectrum(fun.filterImg(img, fun.filterIdeal(rows,cols,0.6))) # Filtros pasa bajos imgf1 = fun.filterImg(img, fun.filterIdeal(rows,cols,0.08)) spec1 = fun.spectrum(fun.filterImg(img,fun.filterIdeal(rows,cols,0.15))) imgf2 = fun.filterImg(img, fun.filterIdeal(rows,cols,0.15)) spec2 = fun.spectrum(fun.filterImg(img, fun.filterIdeal(rows,cols,0.15))) imgf3 = fun.filterImg(img, fun.filterIdeal(rows,cols,0.6)) spec3 = fun.spectrum(fun.filterImg(img, fun.filterIdeal(rows,cols,0.6))) func.graficar(imgf1, imgf1.max(), 0, 'gray', 'Imagen para 0.1') func.graficar(spec1, (spec1).max(), 0, 'gray', 'Espectro para 0.08') func.graficar(imgf2, imgf2.max(), 0, 'gray', 'Imagen para 0.15') func.graficar(spec2, (spec2).max(), 0, 'gray', 'Espectro para 0.15') func.graficar(imgf3, imgf3.max(), 0, 'gray', 'Imagen para 0.6') func.graficar(spec3, (spec3).max(), 0, 'gray', 'Espectro para 6')
def ej2(): img = cv.imread('../img/ej2.png', cv.IMREAD_GRAYSCALE) func.graficar(img, 255, 0, 'gray', 'Imagen cargada') ret, img = cv.threshold(img, 128, 255, cv.THRESH_BINARY) # Kernel que voy a usar para ambas operaciones kernelcuadrado = np.ones((3, 3), np.uint8) # func.apertura con un kernel cuadrado salida = func.apertura(img, kernelcuadrado) func.graficar(salida, 255, 0, 'gray', 'Operacion func.apertura') # func.cierre con un kernel cuadrado salida = func.cierre(img, kernelcuadrado) func.graficar(salida, 255, 0, 'gray', 'Operacion func.cierre') # Probando otros elementos estructurantes kernelcruz = cv.getStructuringElement(cv.MORPH_CROSS, (3, 3)) kernelelipse = cv.getStructuringElement(cv.MORPH_ELLIPSE, (3, 3)) salidacruzap = func.apertura(img, kernelcruz) salidaelipseap = func.apertura(img, kernelelipse) func.graficar(salidacruzap, 255, 0, 'gray', 'Operacion func.apertura con cruz') func.graficar(salidaelipseap, 255, 0, 'gray', 'Operacion func.apertura con elipse') salidacruzci = func.cierre(img, kernelcruz) salidaelipseci = func.cierre(img, kernelelipse) func.graficar(salidacruzci, 255, 0, 'gray', 'Operacion func.cierre con cruz') func.graficar(salidaelipseci, 255, 0, 'gray', 'Operacion func.cierre con elipse')