Nota: El siguiente producto lo ayudará con: Cómo emplear OpenCV para extraer información de imágenes de tablas
Muchas veces, al trabajar como científico de datos, se hallará con situaciones en las que precisará extraer información de utilidad de las imágenes.
Si estas imágenes están en formato de artículo, puede utilizar OCR y extraerlas.
Pero si son imágenes que contienen datos en forma tabular, es mucho más simple extraerlas directamente como ficheros Excel o CSV.
Para ello podemos usar OpenCV y transformarlos de manera directa a forma tabular.
El propósito de este artículo es extraer información de una imagen tabular y almacenarla de forma directa en ficheros de Excel.
Para ello, prosigue estos tres pasos:
- Advertir celdas en una imagen Recuperar situaciones de celdas Obtener texto e insertarlo en celdas
Cargando datos
Antes de pasar a la implementación, seleccionaremos la imagen de la que queremos extraer imágenes.
Elijamos una tabla simple con ciertas columnas.
La imagen que elegí se muestra a continuación.
Esta tabla tiene dentro información sobre la concentración de sal en algunos experimentos y se anotan sus resultados.
Puedes descargarlo cliqueando en el link.
Ahora importaremos las bibliotecas requeridas y cargaremos el grupo de datos.
Usaré Google+ Colab para esto, conque también montaré la unidad.
desde google plus.colab import drive drive.mount(‘/content/gdrive’) import cv2 import numpy as np import pandas as pd import matplotlib.pyplot as plt sample=r’/content/gdrive/My Drive/sample.png’ read_image = cv2.imread(exhibe,0)
Tras importar los datos y cargarlos, ahora comenzaremos con el paso inicial.
Detección de células
Para transformar una imagen a Excel, primero debemos advertir las celdas, que son las líneas horizontales y verticales que forman las celdas.
Para llevar a cabo esto, primero debemos convertir la imagen a binario y convertirla a escala de grises usando OpenCV.
convert_bin,gray_scale = cv2.threshold(image_read,128,255,cv2.THRESH_BINARY | cv2.THRESH_OTSU) grey_scale = 255-grey_scale grey)graph = plt.imshow(gray_scale,cmap=’gray’) plt.espectáculo()
Aquí hemos transformado la imagen a formato binario.
Ahora definamos dos núcleos para extraer líneas horizontales y verticales de estas celdas.
Para las líneas horizontales, haremos lo siguiente.
Primero conseguiremos las dimensiones terminadas de la imagen y después empleando la función de elementos estructurales de OpenCV conseguiremos las líneas horizontales.
longitud = por servirnos de un ejemplo, matriz (image_read). Forma[1]//100 núcleo_horizontal = cv2.getStructuringElement(cv2.MORPH_RECT, (longitud, 1))
Ahora, utilizando las funciones de erosión y incremento, aplicaremos esto a nuestra imagen y detectaremos y extraeremos las líneas horizontales.
horizontal_detect = cv2.erode(scale_gray, horizontal_kernel, iterations =3) hor_line = cv2.dilate(horizontal_detect, vertical_kernel, iterations=3) plot = plt.imshow(horizontal_detect,cmap=’gray’) plt.show()
De la misma manera, repetiremos estos pasos para detectar líneas verticales creando otro núcleo.
vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1 longitud)) vertical_detect = cv2.erode(escala de grises, vertical_kernel, iteraciones=3) ver_lines = cv2.dilate(vertical_detect, vertical_kernel, iteraciones=3) show = plt.imshow(vertical_detect , cmap=’gris’) plt.mostrar()
En el momento en que los tengamos completados, todo cuanto debemos realizar es mezclarlos y transformarlos en una composición similar a una cuadrícula para una representación tabular limpia sin contenido dentro.
Para ello, primero conectaremos las líneas verticales y horizontales y crearemos el núcleo cuadrado final.
A continuación, convertiremos la imagen de escala de grises a blanco.
final = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2)) combinar = cv2.addWeighted(ver_lines, 0.5top_line, 0.5, 0.0) Conjuntar = cv2.erode(~conjuntar, final, iteraciones=2) umbral, conjuntar = cv2.threshold(combine,128,255, cv2.THRESH_BINARY | cv2.THRESH_OTSU) convert_xor = cv2.bitwise_xor(read_image,combine) inverse = cv2.bitwise_not(convert_xor) output= plt.imshow(inverse,cmap=’gray’) plt. espectáculo()
Esto exhibe la tabla enlazada final donde están presentes las celdas.
En este momento podemos pasar al siguiente paso.
Recuperación de posiciones de celdas
En este momento que contamos lista una tabla en blanco, debemos encontrar una localización adecuada para agregar el texto.
Esta es la columna y la fila donde se debe insertar el artículo.
Para hacer esto, requerimos establecer límites en torno a cada celda.
Los contornos son la mejor forma de enfatizar líneas de celdas y definir cuadros de límites.
Ahora escribamos una función que recupere contornos y un cuadro delimitador.
Asimismo es esencial cerciorarse de que los contornos se lean en un orden específico que se almacenará en la función.
cont, _ = cv2.findContours(combine, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) def get_boxes(num, method=”left to right”): invert = False flag = 0if method == “right to left” or method == “de abajo hacia arriba”: inverso = verdadero si procedimiento == “de arriba hacia abajo” o método == “de abajo hacia arriba”: bandera = 1cajas = [cv2.boundingRect(c) for c in num](número, campos) = zip(*ordenado(zip(número, campos), clave=lambda b:b[1][i]invertir=invertir)) return (número, cajas) cd, cajas = get_boxes(cont, method=”top to bottom”)
Entonces vamos a tomar las dimensiones de cada contorno y las guardaremos.
Gracias a estos contornos y rectángulos, tendremos 4 lados.
Requerimos entablar dimensiones que dependen del usuario.
Aquí he predeterminado el ancho en 500 y la altura en 500.
Estos valores dependen del tamaño de la imagen.
caja_final = []para cw cont: s1, s2, s3, s4 = cv2.boundingRect(c) if (s3<500 and s4<500): rectángulo_img = cv2.rectangle(leer_imagen,(s1,s2),(s1+s3,s2 + s4),(0,255,0),2) caja_final.append([s1,s2,s3,s4]) gráfico = plt.imshow(rectangle_img,cmap='gray') plt.show()
Puede ver que los cuadros están destacados como se expone arriba y contamos la posición de cada celda de imagen guardada en la lista.
Pero también requerimos la localización de cada una de las celdas para lograr extraerlas en orden.
Para conseguir la localización, vamos a tomar el valor promedio de los campos, entonces les agregaremos la altura y el ancho.
Luego los ordenaremos en sus respectivas casillas y vamos a encontrar el centro de estas casillas a fin de que se puedan alinear bien.
obscuro = [boxes[i][3] for i in range(len(boxes))]avg = np.mean(dim) hor=[]ver=[]for i in range(len(campo)): if(i==0): ver.append(campo[i]) último=caja[i]en caso contrario: si (campo[i][1]<=último[1]+promedio/2): ver.append(campo[i]) último=caja[i] if(i==longitud(fotograma)-1): hor.append(ver) else: hor.append(ver) ver=[] último = caja[i] ver.append(cuadro[i]) total = 0 para y en rango (Long(pos)): sum = L(it)[i]) si suma > suma: suma = promedio suma = [int(hor[i][j][0]+hor[i][j][2]/2) para j en el rango(len(hor[i])) si[0]]mid=np.array(mid) mid.sort()
Ahora que tenemos los campos y las dimensiones adjuntado con el punto medio, ahora podemos pasar a extraer el artículo.
Pero antes de eso, nos aseguraremos de que nuestras celdas estén en el orden preciso.
Para realizar esto, siga estos pasos.
orden = []para y en la llegada (len (hor)): organizar =[]para q alcance (total): organizar.unirse([]) para j en el rango (len (hor[i])): sub = abs(centro-(fila[i][j][0]+fila[i][j][2]/4)) más bajo = min(sub) idx = lista(sub).index(más bajo) organizar[idx].append(fila[i][j]) order.join(arreglar)
Ahora vamos a usar pytesseract para realizar el OCR puesto que es compatible con OpenCV y Python.
intente: con imagen de importación PIL excepto ImportError: importar imagen importar pytesseract
Tomaremos cada cuadro y le vamos a hacer erosión y expansión, luego extraeremos la información de las celdas empleando OCR.
extracto=[]for i in range(len(orden)): for j in range(len(orden[i])): inside=”” if(len(pedir[i][j])==0): extract.append(‘ ‘) else: for k in range(len(order[i][j])): lado1, lado2, ancho, prominente = orden[i][j][k][0],orden[i][j][k][1]orden[i][j][k][2],orden[i][j][k][3]
final_extract = bitnot[side2:side2+h, side1:side1+width]final_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 1)) get_border = cv2.copyMakeBorder(final_extract,2,2,2,2cv2.BORDER_CONSTANT,value=[255,255]) redimensionar = cv2.resize(get_border, None, fx=2fi=2interpolation=cv2.INTER_CUBIC) dil = cv2.dilate(resize, final_kernel, iterations=1) ero = cv2.erode(dil, final_kernel,iterations=2) ocr = pytesseract.image_to_string(ero) if(len(ocr)==0): ocr = pytesseract.image_to_string(ero, config=’–psm 3′) inside = inside +” “+ ocr extract.append(inside)
En este momento convertiremos esta matriz extraída en un DataFrame y la guardaremos en un archivo de Excel.
a = np.array(extract) dataset = pd.DataFrame(a.reshape(len(hor), total)) dataset.to_excel(“/content/gdrive/My Drive/output1.xlsx”)
El resultado final es el próximo
Puede ver que Excel ha extraído los datos.
Más allá de que no está con perfección alineado (los números 12 y 15 no se alinean con el resto), sigue siendo bueno y también puede modificar estos valores.
Petición
En este artículo, vimos cómo usar OpenCV para convertir una imagen de tabla en una hoja de cálculo de Excel editable.
Tienen la posibilidad de ser útiles para obtener información importante de estas tablas y manipularlas de manera directa empleando formatos CSV y Excel.
~~~~~~~~📱~~~~~~~~
Fikiri.net es el sitio perfecto para encontrar las últimas novedades y comentarios sobre gadgets y aplicaciones tecnológicas, así para conseguir consejos y trucos para sacar el máximo partido de tu tecnología.
