Upload 7 files

.gitignore

@@ -0,0 +1,7 @@
+*tmp*
+__pycache__
+node_modules
+.env
+*.pdf
+*.jpg
+*.docx

README.md

@@ -1,10 +1,3 @@
----
-title: Tableocr
-emoji: 📚
-colorFrom: pink
-colorTo: purple
-sdk: docker
-pinned: false
----
+# table_ocr
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+🎉

helper.py

@@ -0,0 +1,226 @@
+import torch
+
+from tqdm.auto import tqdm
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from matplotlib.patches import Patch
+
+import numpy as np
+from PIL import Image
+
+GREEN = "\033[92m"
+RESET = "\033[0m"
+
+class MaxResize(object):
+    def __init__(self, max_size=800):
+        self.max_size = max_size
+
+    def __call__(self, image):
+        width, height = image.size
+        current_max_size = max(width, height)
+        scale = self.max_size / current_max_size
+        resized_image = image.resize((int(round(scale*width)), int(round(scale*height))))
+
+        return resized_image
+
+# for output bounding box post-processing
+def box_cxcywh_to_xyxy(x):
+    x_c, y_c, w, h = x.unbind(-1)
+    b = [(x_c - 0.5 * w), (y_c - 0.5 * h), (x_c + 0.5 * w), (y_c + 0.5 * h)]
+    return torch.stack(b, dim=1)
+
+
+def rescale_bboxes(out_bbox, size):
+    img_w, img_h = size
+    b = box_cxcywh_to_xyxy(out_bbox)
+    b = b * torch.tensor([img_w, img_h, img_w, img_h], dtype=torch.float32)
+    return b
+
+def outputs_to_objects(outputs, img_size, id2label):
+    m = outputs.logits.softmax(-1).max(-1)
+    pred_labels = list(m.indices.detach().cpu().numpy())[0]
+    pred_scores = list(m.values.detach().cpu().numpy())[0]
+    pred_bboxes = outputs['pred_boxes'].detach().cpu()[0]
+    pred_bboxes = [elem.tolist() for elem in rescale_bboxes(pred_bboxes, img_size)]
+
+    objects = []
+    for label, score, bbox in zip(pred_labels, pred_scores, pred_bboxes):
+        class_label = id2label[int(label)]
+        if not class_label == 'no object':
+            objects.append({'label': class_label, 'score': float(score),
+                            'bbox': [float(elem) for elem in bbox]})
+
+    return objects
+
+
+def fig2img(fig):
+    """Convert a Matplotlib figure to a PIL Image and return it"""
+    import io
+    buf = io.BytesIO()
+    fig.savefig(buf)
+    buf.seek(0)
+    img = Image.open(buf)
+    return img
+
+
+def visualize_detected_tables(img, det_tables, out_path=None):
+    plt.imshow(img, interpolation="lanczos")
+    fig = plt.gcf()
+    fig.set_size_inches(20, 20)
+    ax = plt.gca()
+
+    for det_table in det_tables:
+        bbox = det_table['bbox']
+
+        if det_table['label'] == 'table':
+            facecolor = (1, 0, 0.45)
+            edgecolor = (1, 0, 0.45)
+            alpha = 0.3
+            linewidth = 2
+            hatch='//////'
+        elif det_table['label'] == 'table rotated':
+            facecolor = (0.95, 0.6, 0.1)
+            edgecolor = (0.95, 0.6, 0.1)
+            alpha = 0.3
+            linewidth = 2
+            hatch='//////'
+        else:
+            continue
+
+        rect = patches.Rectangle(bbox[:2], bbox[2]-bbox[0], bbox[3]-bbox[1], linewidth=linewidth,
+                                    edgecolor='none',facecolor=facecolor, alpha=0.1)
+        ax.add_patch(rect)
+        rect = patches.Rectangle(bbox[:2], bbox[2]-bbox[0], bbox[3]-bbox[1], linewidth=linewidth,
+                                    edgecolor=edgecolor,facecolor='none',linestyle='-', alpha=alpha)
+        ax.add_patch(rect)
+        rect = patches.Rectangle(bbox[:2], bbox[2]-bbox[0], bbox[3]-bbox[1], linewidth=0,
+                                    edgecolor=edgecolor,facecolor='none',linestyle='-', hatch=hatch, alpha=0.2)
+        ax.add_patch(rect)
+
+    plt.xticks([], [])
+    plt.yticks([], [])
+
+    legend_elements = [Patch(facecolor=(1, 0, 0.45), edgecolor=(1, 0, 0.45),
+                                label='Table', hatch='//////', alpha=0.3),
+                        Patch(facecolor=(0.95, 0.6, 0.1), edgecolor=(0.95, 0.6, 0.1),
+                                label='Table (rotated)', hatch='//////', alpha=0.3)]
+    plt.legend(handles=legend_elements, bbox_to_anchor=(0.5, -0.02), loc='upper center', borderaxespad=0,
+                    fontsize=10, ncol=2)
+    plt.gcf().set_size_inches(10, 10)
+    plt.axis('off')
+
+    if out_path is not None:
+      plt.savefig(out_path, bbox_inches='tight', dpi=150)
+
+    return fig
+
+def objects_to_crops(img, tokens, objects, class_thresholds, padding=10):
+    """
+    Process the bounding boxes produced by the table detection model into
+    cropped table images and cropped tokens.
+    """
+
+    table_crops = []
+    for obj in objects:
+        if obj['score'] < class_thresholds[obj['label']]:
+            continue
+
+        cropped_table = {}
+
+        bbox = obj['bbox']
+        bbox = [bbox[0]-padding, bbox[1]-padding, bbox[2]+padding, bbox[3]+padding]
+
+        cropped_img = img.crop(bbox)
+
+        table_tokens = [token for token in tokens if iob(token['bbox'], bbox) >= 0.5]
+        for token in table_tokens:
+            token['bbox'] = [token['bbox'][0]-bbox[0],
+                             token['bbox'][1]-bbox[1],
+                             token['bbox'][2]-bbox[0],
+                             token['bbox'][3]-bbox[1]]
+
+        # If table is predicted to be rotated, rotate cropped image and tokens/words:
+        if obj['label'] == 'table rotated':
+            cropped_img = cropped_img.rotate(270, expand=True)
+            for token in table_tokens:
+                bbox = token['bbox']
+                bbox = [cropped_img.size[0]-bbox[3]-1,
+                        bbox[0],
+                        cropped_img.size[0]-bbox[1]-1,
+                        bbox[2]]
+                token['bbox'] = bbox
+
+        cropped_table['image'] = cropped_img
+        cropped_table['tokens'] = table_tokens
+
+        table_crops.append(cropped_table)
+
+    return table_crops
+
+
+def get_cell_coordinates_by_row(table_data):
+    # Extract rows and columns
+    rows = [entry for entry in table_data if entry['label'] == 'table row']
+    columns = [entry for entry in table_data if entry['label'] == 'table column']
+
+    # Sort rows and columns by their Y and X coordinates, respectively
+    rows.sort(key=lambda x: x['bbox'][1])
+    columns.sort(key=lambda x: x['bbox'][0])
+
+    # Function to find cell coordinates
+    def find_cell_coordinates(row, column):
+        cell_bbox = [column['bbox'][0], row['bbox'][1], column['bbox'][2], row['bbox'][3]]
+        return cell_bbox
+
+    # Generate cell coordinates and count cells in each row
+    cell_coordinates = []
+
+    for row in rows:
+        row_cells = []
+        for column in columns:
+            cell_bbox = find_cell_coordinates(row, column)
+            row_cells.append({'column': column['bbox'], 'cell': cell_bbox})
+
+        # Sort cells in the row by X coordinate
+        row_cells.sort(key=lambda x: x['column'][0])
+
+        # Append row information to cell_coordinates
+        cell_coordinates.append({'row': row['bbox'], 'cells': row_cells, 'cell_count': len(row_cells)})
+
+    # Sort rows from top to bottom
+    cell_coordinates.sort(key=lambda x: x['row'][1])
+
+    return cell_coordinates
+
+def apply_ocr(cell_coordinates, cropped_table, reader):
+    # let's OCR row by row
+    data = dict()
+    max_num_columns = 0
+    for idx, row in enumerate(tqdm(cell_coordinates)):
+      row_text = []
+      for cell in row["cells"]:
+        # crop cell out of image
+        cell_image = np.array(cropped_table.crop(cell["cell"]))
+        # apply OCR
+        result = reader.readtext(np.array(cell_image))
+        if len(result) > 0:
+          # print([x[1] for x in list(result)])
+          text = " ".join([x[1] for x in result])
+          row_text.append(text)
+
+      if len(row_text) > max_num_columns:
+          max_num_columns = len(row_text)
+
+      data[idx] = row_text
+
+    # print("Max number of columns:", max_num_columns)
+
+    # pad rows which don't have max_num_columns elements
+    # to make sure all rows have the same number of columns
+    for row, row_data in data.copy().items():
+        if len(row_data) != max_num_columns:
+          row_data = row_data + ["" for _ in range(max_num_columns - len(row_data))]
+        data[row] = row_data
+
+    return data

main.py

@@ -0,0 +1,82 @@
+# import io
+import os
+
+from fastapi import FastAPI, File, HTTPException, UploadFile
+from fastapi.responses import JSONResponse
+from starlette.responses import FileResponse
+from starlette.middleware.cors import CORSMiddleware
+
+# From PIL import Image
+from pdftoword import convertPDFtoWORD
+
+# from model import inference
+
+
+app = FastAPI()
+
+origins = ["http://localhost:3000"]  # Replace with your frontend origin URL
+
+app.add_middleware(
+CORSMiddleware,
+allow_origins=["*"], # Allows all origins
+allow_credentials=True,
+allow_methods=["*"], # Allows all methods
+allow_headers=["*"], # Allows all headers
+)
+
+
+@app.post("/upload")
+async def extract_table_data(image: UploadFile = File(...)):
+    return f"table ocr is disabled 😔"
+    # try:
+    #     # Read image data
+    #     image_data = await image.read()
+
+    #     # Open image in memory
+    #     image = Image.open(io.BytesIO(image_data))
+    #     rgb_img = image.convert("RGB")
+    #     rgb_img.save('output.jpg')
+    #     image = Image.open('output.jpg')
+
+    #     table_fram= inference(image)
+    #     if table_fram.empty:
+    #         return "<h2 style=\"color: darkslategrey;\">💡 the image has no tables 💡</h2>"
+
+    #     return table_fram.to_html(escape=True,border=1,index=False).replace('\n', '')
+
+    # except Exception as e:
+    #     # Handle and log exceptions appropriately
+    #     print(f"Error processing image: {e}")
+    #     raise HTTPException(status_code=500, detail="Internal server error")
+
+
+
+@app.post("/convert")
+async def convert_pdf(docxFile: UploadFile = File(...)):
+    uploaded_file = docxFile
+    try:
+        if not uploaded_file.content_type.startswith("application/pdf"):
+            raise HTTPException(415, detail="Unsupported file format. Please upload a PDF file.")
+
+        # Create uploads directory if it doesn't exist
+        os.makedirs("uploads", exist_ok=True)
+
+        # Save the uploaded file
+        pdf_file_path = os.path.join("uploads", uploaded_file.filename)  
+        with open(pdf_file_path, "wb+") as file_object:
+            file_object.write(uploaded_file.file.read())
+
+        # Process the PDF 
+        docx_path = convertPDFtoWORD(pdf_file_path)
+
+        # remove the uploaded pdf
+        os.unlink(pdf_file_path)
+
+        return FileResponse(docx_path, media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document", filename="converted_document.docx")
+
+    except FileNotFoundError as e:
+        # Handle case where conversion fails (e.g., missing converter)
+        return JSONResponse({"error": "Conversion failed. Please check the converter or file."}, status_code=500)
+    except Exception as e:
+        # Catch any unexpected errors
+        return JSONResponse({"error": f"An unexpected error occurred: {str(e)}"}, status_code=500)

model.py

@@ -0,0 +1,84 @@
+import torch
+from torchvision import transforms
+
+from transformers import AutoModelForObjectDetection
+from transformers import TableTransformerForObjectDetection
+
+import easyocr
+import pandas as pd
+
+from helper import *
+
+reader = easyocr.Reader(['en']) # this needs to run only once to load the model into memory
+
+model = AutoModelForObjectDetection.from_pretrained("microsoft/table-transformer-detection", revision="no_timm")
+
+model.config.id2label
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model.to(device)
+crop_padding = 5
+
+structure_model = TableTransformerForObjectDetection.from_pretrained("microsoft/table-structure-recognition-v1.1-all")
+structure_model.to(device)
+structure_transform = transforms.Compose([
+    MaxResize(1000),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+detection_class_thresholds = {
+    "table": 0.5,
+    "table rotated": 0.5,
+    "no object": 1000
+}
+
+detection_transform = transforms.Compose([
+    MaxResize(800),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+# update id2label to include "no object"
+id2label = model.config.id2label
+id2label[len(model.config.id2label)] = "no object"
+
+
+def inference(image):
+    print(f"{GREEN}>>> inference started{RESET}")
+
+    pixel_values = detection_transform(image).unsqueeze(0)
+    pixel_values = pixel_values.to(device)
+
+    with torch.no_grad():
+        outputs = model(pixel_values)
+
+
+    objects = outputs_to_objects(outputs, image.size, id2label)
+
+    tokens = []
+    tables_crops = objects_to_crops(image, tokens, objects, detection_class_thresholds, padding=crop_padding)
+    if len(tables_crops)==0:
+        return pd.DataFrame()
+    cropped_table = tables_crops[0]['image'].convert("RGB")
+
+
+    pixel_values = structure_transform(cropped_table).unsqueeze(0)
+    pixel_values = pixel_values.to(device)
+
+    with torch.no_grad():
+        outputs = structure_model(pixel_values)
+
+    structure_id2label = structure_model.config.id2label
+    structure_id2label[len(structure_id2label)] = "no object"
+
+    cells = outputs_to_objects(outputs, cropped_table.size, structure_id2label)
+
+    cell_coordinates = get_cell_coordinates_by_row(cells)
+
+    data = apply_ocr(cell_coordinates, cropped_table, reader)
+    tf= pd.DataFrame(data).T
+
+    return tf
+
+

pdftoword.py

@@ -0,0 +1,9 @@
+# Import the required modules
+from pdf2docx import Converter
+
+def convertPDFtoWORD(pdfpath: str)->str:
+    docx_file = pdfpath.split('.pdf')[0]+'.docx'
+    converter = Converter(pdfpath)
+    converter.convert(docx_file)
+    converter.close()
+    return docx_file

requirements.txt

@@ -0,0 +1,18 @@
+pdf2docx
+
+fastapi
+uvicorn[standard]
+
+# matplotlib
+# Pillow
+# pandas
+# joblib
+# scipy
+# numpy
+ 
+# easyocr
+
+# tqdm
+# torch
+# torchvision
+# transformers