initial

app.py

@@ -0,0 +1,57 @@
+import streamlit as st
+from PIL import Image, ImageOps
+import pandas as pd
+import numpy as np
+from invoice import extract_data, extract_tables, INVOICE
+import cv2
+
+
+
+def process_image(lang, to_be_extracted, input_image):
+    data = extract_data(lang, to_be_extracted, input_image)
+    return data
+
+def main():
+    st.title("Image Processing App")
+    st.write("Upload an image and click the 'Process Image' button to process it.")
+    uploaded_image = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png","webp"])
+    
+    if uploaded_image is not None:
+        # Display the uploaded image
+        st.image(uploaded_image, caption="Uploaded Image", use_column_width=True)
+
+        lang = st.selectbox("Select Language", ["french", "english", "arabic"])
+
+        # UI for adding elements to extract list
+        st.write("Add elements to extract:")
+        extract_input = st.text_input("Add elements")
+        extract_list = st.session_state.get("extract_list", INVOICE)
+        if extract_input:
+            extract_list.append(extract_input.strip())
+            st.session_state["extract_list"] = extract_list
+
+        # Display the extract list as chips
+        st.write("Elements to extract:")
+        for item in extract_list:
+            st.write(f"`{item}`", unsafe_allow_html=True)
+
+        if st.button("Extract information"):
+            pil_image = Image.open(uploaded_image).convert('RGB')
+            numpy_image = np.array(pil_image)
+            image_info = process_image(lang, extract_list, numpy_image)
+
+            df = pd.DataFrame(list(image_info.items()), columns=["Field", "Value"])
+            st.write("Extracted information:")
+            st.dataframe(df)
+    
+        if st.button("Extract Tables"):
+            df = pd.DataFrame([])
+            csv = df.to_csv(index=False, header=False)
+            st.download_button(label="Download CSV", data=csv, file_name='data.csv', mime='text/csv')
+        
+            
+    else:
+        st.session_state['extract_list'] = INVOICE
+
+if __name__ == "__main__":
+    main()

doc.py

@@ -0,0 +1,64 @@
+import cv2
+import base64
+from utils import *
+
+CIN =  ["Nom complet", "Date de naissance", "Date de validité", "Lieu de naissance", "Numéro CIN"]
+
+
+
+def extract_face(image, scale_factor=1.2):
+    # Load the pre-trained face detector
+    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_alt.xml')
+
+
+    # Convert the image to grayscale
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+    # Detect faces in the image
+    faces = face_cascade.detectMultiScale(gray, scaleFactor=scale_factor, minNeighbors=5, minSize=(30, 30))
+    print(len(faces))
+    if len(faces) == 0:
+        print("No faces found")
+        return None
+
+    # Assume only one face in the image for simplicity
+    (x, y, w, h) = max(faces, key=lambda x: x[2])
+
+    # Expand the bounding box to include a slightly larger region
+    x -= int(0.1 * w)
+    y -= int(0.1 * h)
+    w += int(0.2 * w)
+    h += int(0.2 * h)
+
+    # Ensure the coordinates are within the image boundaries
+    x = max(x, 0)
+    y = max(y, 0)
+    w = min(w, image.shape[1])
+    h = min(h, image.shape[0])
+
+    # Extract the face region from the image
+    face = image[y:y+h, x:x+w]
+
+    # Convert the face to base64 string
+    _, encoded_image = cv2.imencode('.jpg', face)
+    encoded_image_str = base64.b64encode(encoded_image).decode('utf-8')
+
+    # Create a dictionary to store image information
+    image_info = {
+        "width": face.shape[1],
+        "height": face.shape[0],
+        "data": encoded_image_str
+    }
+
+    return image_info
+   
+
+if __name__ == '__main__':
+    lang = "french"
+    to_be_extracted = CIN
+    image_path = "./docs for ocr/CIN 2.png"
+    image = cv2.imread(image_path)
+    
+    text_data = extract_data(lang, to_be_extracted, image)
+    print(text_data)
+    face_data = extract_face(image)

invoice.py

@@ -0,0 +1,116 @@
+import cv2
+from PIL import Image
+# from ultralyticsplus import YOLO
+# from transformers import pipeline
+import pandas as pd
+import numpy as np
+import easyocr
+from utils import *
+
+INVOICE = ["Numéro de facture", "Date", "Numéro de commande", "Echéance", "Total"]
+
+# model = YOLO('keremberke/yolov8s-table-extraction')
+# model.overrides['conf'] = 0.25  # NMS confidence threshold
+# model.overrides['iou'] = 0.45  # NMS IoU threshold
+# model.overrides['agnostic_nms'] = False  # NMS class-agnostic
+# model.overrides['max_det'] = 1000  # maximum number of detections per image
+
+# pipe = pipeline("object-detection", model="bilguun/table-transformer-structure-recognition")
+
+
+def detect_tables(image):
+  # image is an np array
+  results = model.predict(image)
+  
+
+  result = results[0]
+  xyxy = result.boxes.xyxy
+  scores = result.boxes.conf
+  tables = []
+  for i in range(len(scores)):
+    if scores[i] >= 0.5:
+      table = image[int(xyxy[i,1]):int(xyxy[i,3]), int(xyxy[i,0]):int(xyxy[i,2])]
+      table = Image.fromarray(table)
+      tables.append(table)
+  return tables
+
+def insert(el, listt, pos):
+  if not listt:
+      listt.append(el)
+  else:
+      inserted = False
+      for i in range(len(listt)):
+          if el[pos] <= listt[i][pos]:
+              listt.insert(i, el)
+              inserted = True
+              break
+      if not inserted:
+          listt.append(el)
+
+def rec_table(table, reader):
+  col_row = pipe(table)
+  cols = []
+  rows = []
+  for el in col_row:
+    if el["label"] == 'table column':
+      insert(el["box"], cols, pos = "xmin")
+    elif el["label"] == 'table row':
+      insert(el["box"], rows, pos = "ymin")
+
+  table = np.array(table)
+
+  csv = []
+  for row in rows:
+    temp = []
+    for col in cols:
+      box = intersection(row, col)
+      cell = table[box['ymin']:box['ymax'], box['xmin']:box['xmax']]
+      res = get_ocr(cell,reader)
+      temp.append(get_input(res))
+    csv.append(temp)
+  
+  df = pd.DataFrame(csv)
+  return df
+
+
+def intersection(box1, box2):
+    # Extract coordinates of first bounding box
+    x1min, y1min, x1max, y1max = box1['xmin'], box1['ymin'], box1['xmax'], box1['ymax']
+
+    # Extract coordinates of second bounding box
+    x2min, y2min, x2max, y2max = box2['xmin'], box2['ymin'], box2['xmax'], box2['ymax']
+
+    # Calculate coordinates of intersection
+    xmin = max(x1min, x2min)
+    ymin = max(y1min, y2min)
+    xmax = min(x1max, x2max)
+    ymax = min(y1max, y2max)
+
+    # Check if there is no intersection
+    if xmin >= xmax or ymin >= ymax:
+        return None
+
+    # Return the coordinates of the intersection
+    return {'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax}
+
+
+def extract_tables(lang, image):
+  reader = easyocr.Reader([langs[lang]])
+  tables = detect_tables(image)
+
+  for i in range(len(tables)):
+    df = rec_table(tables[i], reader)
+    df.to_excel(f'table_{i+1}.xlsx', index=False, header=False)
+
+if __name__ == '__main__':
+    lang = "french"
+    to_be_extracted = INVOICE
+    image_path = "./docs for ocr/invoices/facture.png"
+    image = cv2.imread(image_path)
+    print(image.shape)
+    
+    text_data = extract_data(lang, to_be_extracted, image)
+    print(text_data)
+
+    # extract_tables(lang, image) # extract tables from the image and download them in excel format to the current directory
+