Update app.py

app.py

@@ -5,7 +5,7 @@ import numpy as np
 # Load lightweight CPU model
 model = ocr_predictor(det_arch='db_resnet50', reco_arch='crnn_vgg16_bn', pretrained=True)
 
-def extract_intelligent_table(image):
+def extract_aligned_table(image):
     if image is None:
         return "Please upload an image."
     
@@ -15,28 +15,23 @@ def extract_intelligent_table(image):
     
     markdown_rows = []
     
+    # Define Column Boundaries (Adjusted for typical Accountancy Layouts)
+    # These are percentages of the page width (0.0 to 1.0)
+    col_bounds = [0.25, 0.65, 0.85] # Boundaries between Col 1|2, 2|3, 3|4
+
     for page in json_export['pages']:
         words_list = []
         for block in page['blocks']:
             for line in block['lines']:
                 for word in line['words']:
-                    # Calculate center Y and start/end X
                     y_center = (word['geometry'][0][1] + word['geometry'][1][1]) / 2
                     x_start = word['geometry'][0][0]
-                    x_end = word['geometry'][1][0]
-                    words_list.append({
-                        'text': word['value'],
-                        'y': y_center,
-                        'x_start': x_start,
-                        'x_end': x_end
-                    })
+                    words_list.append({'text': word['value'], 'y': y_center, 'x': x_start})
         
         if not words_list: continue
             
-        # 1. Sort vertically by Y
+        # 1. Sort and Group into Rows
         words_list.sort(key=lambda w: w['y'])
-        
-        # 2. Group into rows
         rows = []
         current_row = [words_list[0]]
         for i in range(1, len(words_list)):
@@ -47,43 +42,37 @@ def extract_intelligent_table(image):
                 current_row = [words_list[i]]
         rows.append(current_row)
         
-        # 3. Process each row with smart horizontal grouping
+        # 2. Assign words to specific Column "Buckets"
         for row in rows:
-            row.sort(key=lambda w: w['x_start'])
-            
-            row_cells = []
-            if not row: continue
+            # Create 4 empty slots for [Acc Num, Acc Name, Debit, Credit]
+            slots = ["", "", "", ""]
             
-            current_cell_text = row[0]['text']
-            
-            for j in range(1, len(row)):
-                # Calculate the gap between the end of the last word and start of this one
-                gap = row[j]['x_start'] - row[j-1]['x_end']
-                
-                # If the gap is small (e.g., < 3% of page width), keep in same cell
-                if gap < 0.03:
-                    current_cell_text += " " + row[j]['text']
+            for w in row:
+                x = w['x']
+                if x < col_bounds[0]:
+                    slots[0] += w['text'] + " "
+                elif x < col_bounds[1]:
+                    slots[1] += w['text'] + " "
+                elif x < col_bounds[2]:
+                    slots[2] += w['text'] + " "
                 else:
-                    # Large gap indicates a new column
-                    row_cells.append(current_cell_text)
-                    current_cell_text = row[j]['text']
-            
-            row_cells.append(current_cell_text)
+                    slots[3] += w['text'] + " "
             
-            # Join cells with pipe for Markdown
-            markdown_rows.append("| " + " | ".join(row_cells) + " |")
+            # Clean up extra spaces and add to markdown
+            clean_slots = [s.strip() for s in slots]
+            markdown_rows.append("| " + " | ".join(clean_slots) + " |")
 
     return "\n".join(markdown_rows)
 
-# UI Setup
+# UI with JS-based Copy
 with gr.Blocks() as demo:
-    gr.Markdown("## 📑 Accountancy Table Extractor (Smart Cell Grouping)")
-    gr.Markdown("This version detects gaps between words to keep phrases in a single cell.")
+    gr.Markdown("## 📑 Accountancy Aligned Table Extractor")
+    gr.Markdown("This version uses fixed columns to prevent Debit and Credit from merging.")
     
     with gr.Row():
         with gr.Column():
-            img_in = gr.Image(type="pil", label="Upload Paper")
-            btn = gr.Button("Extract Structured Table", variant="primary")
+            img_in = gr.Image(type="pil", label="Upload Trial Balance")
+            btn = gr.Button("Extract with Columns", variant="primary")
         with gr.Column():
             out = gr.Textbox(label="Result", lines=20, elem_id="out_box")
             copy_btn = gr.Button("📋 Copy Table")
@@ -92,10 +81,10 @@ with gr.Blocks() as demo:
                 () => {
                     const text = document.querySelector('#out_box textarea').value;
                     navigator.clipboard.writeText(text);
-                    alert('Copied! Cells are now correctly grouped.');
+                    alert('Table copied! Empty cells are now preserved.');
                 }
             """)
 
-    btn.click(extract_intelligent_table, inputs=img_in, outputs=out)
+    btn.click(extract_aligned_table, inputs=img_in, outputs=out)
 
 demo.launch()