Upload 10 files

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+static/output/dest_highlighted.pdf filter=lfs diff=lfs merge=lfs -text
+static/output/source_highlighted.pdf filter=lfs diff=lfs merge=lfs -text
+static/uploads/2024_12_17_venubabu.bathula_F5MS214215_AM8535_F25.pdf filter=lfs diff=lfs merge=lfs -text
+static/uploads/2025_4_15_venubabu.bathula_F5MS214215_AM8535_F25.pdf filter=lfs diff=lfs merge=lfs -text
+static/uploads/2025_6_16_bzakaria_F8MS180510_AM0449_S26-1.pdf filter=lfs diff=lfs merge=lfs -text
+static/uploads/2025_9_16_venubabu.bathula_F8MS180510_AM0449_S26.pdf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,49 @@
+import os
+from flask import Flask, render_template, request, jsonify, send_from_directory
+from flask_cors import CORS
+from werkzeug.utils import secure_filename
+from pdf_logic import process_comparison
+
+app = Flask(__name__)
+CORS(app)
+
+# Configuration
+UPLOAD_FOLDER = 'static/uploads'
+OUTPUT_FOLDER = 'static/output'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(OUTPUT_FOLDER, exist_ok=True)
+
+
+@app.route('/compare', methods=['POST'])
+def compare():
+    if 'source' not in request.files or 'destination' not in request.files:
+        return jsonify({'error': 'Missing files'}), 400
+    
+    source_file = request.files['source']
+    dest_file = request.files['destination']
+    
+    s_path = os.path.join(UPLOAD_FOLDER, secure_filename(source_file.filename))
+    d_path = os.path.join(UPLOAD_FOLDER, secure_filename(dest_file.filename))
+    
+    source_file.save(s_path)
+    dest_file.save(d_path)
+    
+    try:
+        # Run the comparison logic
+        src_out, dest_out, changes, total_pages = process_comparison(s_path, d_path, OUTPUT_FOLDER)
+        
+        return jsonify({
+            'status': 'success',
+            'source_pdf': f"/static/output/{src_out}",
+            'dest_pdf': f"/static/output/{dest_out}",
+            'changes': changes,
+            'total_pages': total_pages
+        })
+    except Exception as e:
+        print(e)
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    from waitress import serve
+
+    serve(app, host="0.0.0.0", port=7860)

pdf_logic.py

@@ -0,0 +1,440 @@
+"""
+PDF Comparison Logic with Robust Annotation Handling
+
+Key insight: PDFMiner extracts text in a "normalized" coordinate system where it applies
+the page's CTM (Current Transformation Matrix) internally. However, annotations in PDF
+need to be placed in the page's raw coordinate system (MediaBox-based).
+
+This rewrite:
+1. Uses pypdf to get the actual page MediaBox and rotation
+2. Transforms PDFMiner coordinates back to raw page coordinates for annotations
+3. Properly handles all rotation cases (0, 90, 180, 270)
+"""
+
+import difflib
+from pdfminer.high_level import extract_pages
+from pdfminer.layout import LTTextContainer, LTChar, LTAnno
+from pypdf import PdfReader, PdfWriter
+from pypdf.generic import (
+    DictionaryObject, NumberObject, FloatObject,
+    NameObject, ArrayObject
+)
+
+
+class CharComponent:
+    """Stores character data with position information."""
+
+    def __init__(self, character, font, color, bbox, page_num,
+                 pdfminer_page_width, pdfminer_page_height):
+        self.character = character
+        self.font = font
+        self.color = color
+        # Store the raw bbox from PDFMiner (x0, y0, x1, y1)
+        # x0, y0 = bottom-left; x1, y1 = top-right in PDFMiner's coordinate system
+        self.bbox = bbox  # (x0, y0, x1, y1)
+        self.page_num = page_num
+        # PDFMiner's reported page dimensions (may be rotated)
+        self.pdfminer_width = pdfminer_page_width
+        self.pdfminer_height = pdfminer_page_height
+
+    @property
+    def has_position(self):
+        """Check if this character has valid position data."""
+        return self.bbox[0] != 0 or self.bbox[1] != 0 or self.bbox[2] != 0 or self.bbox[3] != 0
+
+
+def get_page_info(page):
+    """
+    Extract page geometry information from a pypdf page.
+    Returns: (width, height, rotation, offset_x, offset_y) in raw MediaBox/CropBox coordinates
+    """
+    # Prefer CropBox as it defines the visible area which PDFMiner analyzes
+    box = page.cropbox if page.cropbox else page.mediabox
+    
+    raw_width = float(box.width)
+    raw_height = float(box.height)
+    
+    # Get offsets (usually 0,0 but can be non-zero for cropped pages)
+    offset_x = float(box.lower_left[0])
+    offset_y = float(box.lower_left[1])
+
+    # Get rotation value (0, 90, 180, or 270)
+    rotation = int(page.get('/Rotate', 0)) % 360
+
+    return raw_width, raw_height, rotation, offset_x, offset_y
+
+
+def transform_pdfminer_to_annotation_coords(bbox, pdfminer_width, pdfminer_height,
+                                             raw_page_width, raw_page_height, rotation,
+                                             offset_x=0, offset_y=0):
+    """
+    Transform coordinates from PDFMiner's coordinate system to the raw page coordinate
+    system used by PDF annotations, accounting for rotation and CropBox offsets.
+    """
+    x0, y0, x1, y1 = bbox
+    
+    # First, handle rotation transformation (PDFMiner -> Raw Page aligned at 0,0)
+    if rotation == 0:
+        tx0, ty0, tx1, ty1 = x0, y0, x1, y1
+    elif rotation == 90:
+        # 90° CW Rotation
+        # Visual x (0..H) maps to Raw y (0..H)
+        # Visual y (0..W) maps to Raw x (W..0)
+        # Raw X = Raw Width - Visual Y
+        # Raw Y = Visual X
+        tx0, ty0, tx1, ty1 = raw_page_width - y1, x0, raw_page_width - y0, x1
+
+    elif rotation == 180:
+        # 180° Rotation
+        tx0, ty0, tx1, ty1 = raw_page_width - x1, raw_page_height - y1, raw_page_width - x0, raw_page_height - y0
+
+    elif rotation == 270:
+        # 270° CW Rotation
+        # Visual x (0..H) maps to Raw y (H..0)
+        # Visual y (0..W) maps to Raw x (0..W)
+        # Raw X = Visual Y
+        # Raw Y = Raw Height - Visual X
+        tx0, ty0, tx1, ty1 = y0, raw_page_height - x1, y1, raw_page_height - x0
+    else:
+        tx0, ty0, tx1, ty1 = x0, y0, x1, y1
+
+    # Ensure coordinates are ordered min/max after rotation transform
+    rx0, ry0 = min(tx0, tx1), min(ty0, ty1)
+    rx1, ry1 = max(tx0, tx1), max(ty0, ty1)
+
+    # Finally, apply the CropBox/MediaBox offset of the raw page
+    # Annotations are placed relative to the PDF's global coordinate system origin
+    final_x0 = rx0 + offset_x
+    final_y0 = ry0 + offset_y
+    final_x1 = rx1 + offset_x
+    final_y1 = ry1 + offset_y
+
+    return (final_x0, final_y0, final_x1, final_y1)
+
+
+def create_highlight_annotation(x0, y0, x1, y1, color):
+    """
+    Create a highlight annotation with the given coordinates and color.
+
+    Args:
+        x0, y0: Bottom-left corner
+        x1, y1: Top-right corner
+        color: RGB color as [r, g, b] with values 0-1
+
+    Returns:
+        DictionaryObject representing the highlight annotation
+    """
+    # Add small padding for visibility
+    padding = 1.0
+    x0 -= padding
+    y0 -= padding
+    x1 += padding
+    y1 += padding
+
+    # Ensure coordinates are properly ordered
+    rect_x0 = min(x0, x1)
+    rect_y0 = min(y0, y1)
+    rect_x1 = max(x0, x1)
+    rect_y1 = max(y0, y1)
+
+    annotation = DictionaryObject()
+    annotation.update({
+        NameObject("/Type"): NameObject("/Annot"),
+        NameObject("/Subtype"): NameObject("/Highlight"),
+        NameObject("/F"): NumberObject(4),  # Print flag
+        NameObject("/C"): ArrayObject([FloatObject(c) for c in color]),
+        NameObject("/CA"): FloatObject(0.4),  # 40% opacity
+        NameObject("/Rect"): ArrayObject([
+            FloatObject(rect_x0), FloatObject(rect_y0),
+            FloatObject(rect_x1), FloatObject(rect_y1)
+        ]),
+        # QuadPoints: defines the quadrilateral for the highlight
+        # Order: x1,y1 (top-left), x2,y2 (top-right), x3,y3 (bottom-left), x4,y4 (bottom-right)
+        NameObject("/QuadPoints"): ArrayObject([
+            FloatObject(rect_x0), FloatObject(rect_y1),  # top-left
+            FloatObject(rect_x1), FloatObject(rect_y1),  # top-right
+            FloatObject(rect_x0), FloatObject(rect_y0),  # bottom-left
+            FloatObject(rect_x1), FloatObject(rect_y0)   # bottom-right
+        ]),
+    })
+
+    return annotation
+
+
+def extract_pdf_data(pdf_path, pdf_reader):
+    """
+    Extract text and character position data from PDF.
+
+    Args:
+        pdf_path: Path to the PDF file
+        pdf_reader: PdfReader instance for the same file (to get raw page info)
+
+    Returns:
+        (char_list, full_text, page_info_map): List of CharComponents, full text, and page info
+    """
+    char_list = []
+    full_text = ""
+
+    # Pre-compute page info from pypdf for coordinate transformation
+    page_info_cache = {}
+    for i, page in enumerate(pdf_reader.pages):
+        page_info_cache[i] = get_page_info(page)
+
+    for page_layout in extract_pages(pdf_path):
+        page_num = page_layout.pageid - 1
+        pdfminer_height = page_layout.height
+        pdfminer_width = page_layout.width
+
+        for element in page_layout:
+            if isinstance(element, LTTextContainer):
+                for text_line in element:
+                    # Handle different element types
+                    if isinstance(text_line, LTChar):
+                        char_list.append(CharComponent(
+                            text_line.get_text(),
+                            text_line.fontname,
+                            str(text_line.graphicstate.ncolor),
+                            text_line.bbox,
+                            page_num,
+                            pdfminer_width,
+                            pdfminer_height
+                        ))
+                        full_text += text_line.get_text()
+
+                    elif isinstance(text_line, LTAnno):
+                        full_text += text_line.get_text()
+                        char_list.append(CharComponent(
+                            text_line.get_text(), "Anno", "0",
+                            (0, 0, 0, 0), page_num, pdfminer_width, pdfminer_height
+                        ))
+
+                    else:
+                        # text_line is a container (LTTextLine), iterate children
+                        for char in text_line:
+                            if isinstance(char, LTChar):
+                                char_list.append(CharComponent(
+                                    char.get_text(),
+                                    char.fontname,
+                                    str(char.graphicstate.ncolor),
+                                    char.bbox,
+                                    page_num,
+                                    pdfminer_width,
+                                    pdfminer_height
+                                ))
+                                full_text += char.get_text()
+
+                            elif isinstance(char, LTAnno):
+                                full_text += char.get_text()
+                                char_list.append(CharComponent(
+                                    char.get_text(), "Anno", "0",
+                                    (0, 0, 0, 0), page_num, pdfminer_width, pdfminer_height
+                                ))
+
+    return char_list, full_text, page_info_cache
+
+
+def merge_char_components(chars):
+    """
+    Merge adjacent character components into bounding boxes to reduce annotation count.
+    Returns list of (x0, y0, x1, y1) tuples.
+    """
+    if not chars:
+        return []
+
+    # Trust the input order (reading order from PDFMiner/diff)
+    
+    merged_bboxes = []
+    
+    if not chars:
+        return []
+        
+    curr_bbox = list(chars[0].bbox)
+    
+    for i in range(1, len(chars)):
+        next_char = chars[i]
+        next_bbox = next_char.bbox
+        
+        # Check vertical alignment (same line)
+        # Calculate overlap
+        y_overlap = min(curr_bbox[3], next_bbox[3]) - max(curr_bbox[1], next_bbox[1])
+        h1 = curr_bbox[3] - curr_bbox[1]
+        h2 = next_bbox[3] - next_bbox[1]
+        min_h = min(h1, h2) if min(h1, h2) > 0 else 1
+        
+        is_same_line = (y_overlap / min_h) > 0.4 # 40% vertical overlap
+        
+        # Check horizontal proximity (gap check)
+        # Allow negative gap (slight overlap) up to distinct separation
+        x_gap = next_bbox[0] - curr_bbox[2]
+        
+        # Threshold: 20% of height or fixed small value?
+        # A space character is usually width of a char.
+        # If the gap is massive, it's a separate block.
+        # Let's say gap < height comes from a space.
+        is_close = x_gap < (min_h * 2.0)
+        
+        if is_same_line and is_close:
+            # Merge
+            curr_bbox[0] = min(curr_bbox[0], next_bbox[0])
+            curr_bbox[1] = min(curr_bbox[1], next_bbox[1])
+            curr_bbox[2] = max(curr_bbox[2], next_bbox[2])
+            curr_bbox[3] = max(curr_bbox[3], next_bbox[3])
+        else:
+            merged_bboxes.append(tuple(curr_bbox))
+            curr_bbox = list(next_bbox)
+            
+    merged_bboxes.append(tuple(curr_bbox))
+    return merged_bboxes
+
+
+def add_highlight_rect(page, bbox, color, page_info, pdfminer_w, pdfminer_h):
+    """
+    Add a highlight annotation for a specific bounding box.
+    """
+    raw_width, raw_height, rotation, offset_x, offset_y = page_info
+
+    # Transform PDFMiner coordinates to raw page coordinates
+    transformed_bbox = transform_pdfminer_to_annotation_coords(
+        bbox,
+        pdfminer_w,
+        pdfminer_h,
+        raw_width,
+        raw_height,
+        rotation,
+        offset_x,
+        offset_y
+    )
+
+    # Create the highlight annotation
+    annotation = create_highlight_annotation(
+        transformed_bbox[0], transformed_bbox[1],
+        transformed_bbox[2], transformed_bbox[3],
+        color
+    )
+
+    # Add annotation to page
+    if "/Annots" in page:
+        page["/Annots"].append(annotation)
+    else:
+        page[NameObject("/Annots")] = ArrayObject([annotation])
+
+
+def process_comparison(source_path, dest_path, output_dir):
+    """
+    Compare two PDFs and generate highlighted versions showing differences.
+
+    Args:
+        source_path: Path to source PDF
+        dest_path: Path to destination PDF
+        output_dir: Directory to save output files
+
+    Returns:
+        (src_filename, dest_filename, changes_list, total_pages)
+    """
+    # Create readers first (needed for page info during extraction)
+    src_reader = PdfReader(source_path)
+    dest_reader = PdfReader(dest_path)
+
+    # Extract text data with position info
+    src_chars, src_text, src_page_info = extract_pdf_data(source_path, src_reader)
+    dest_chars, dest_text, dest_page_info = extract_pdf_data(dest_path, dest_reader)
+
+    # Compare text using SequenceMatcher
+    matcher = difflib.SequenceMatcher(None, src_text, dest_text)
+
+    # Create writers and clone pages
+    src_writer = PdfWriter()
+    dest_writer = PdfWriter()
+
+    for page in src_reader.pages:
+        src_writer.add_page(page)
+    for page in dest_reader.pages:
+        dest_writer.add_page(page)
+
+    total_pages = max(len(src_reader.pages), len(dest_reader.pages))
+
+    # Color scheme
+    COLORS = {
+        'delete': [1.0, 0.7, 0.7],       # Light red for deletions
+        'insert': [0.7, 1.0, 0.7],       # Light green for insertions
+        'replace_src': [1.0, 0.85, 0.5], # Orange/yellow for replaced (source)
+        'replace_dest': [0.5, 0.75, 1.0] # Blue for replaced (destination)
+    }
+
+    changes_list = []
+    change_id = 1
+
+    # Process differences
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == 'equal':
+            continue
+
+        change_data = {
+            "id": change_id,
+            "type": tag.upper(),
+            "src_text": src_text[i1:i2].replace('\n', ' ').strip()[:100],
+            "dest_text": dest_text[j1:j2].replace('\n', ' ').strip()[:100],
+            "page": None
+        }
+
+        # Determine colors
+        if tag == 'replace':
+            color_src = COLORS['replace_src']
+            color_dest = COLORS['replace_dest']
+        elif tag == 'delete':
+            color_src = COLORS['delete']
+            color_dest = None
+        else:  # insert
+            color_src = None
+            color_dest = COLORS['insert']
+
+        # Highlight source document (deletions and replacements)
+        if tag in ['replace', 'delete']:
+            src_chars_to_hl = [src_chars[k] for k in range(i1, i2) if k < len(src_chars) and src_chars[k].has_position]
+            by_page = {}
+            for c in src_chars_to_hl:
+                by_page.setdefault(c.page_num, []).append(c)
+
+            for p_num, p_chars in by_page.items():
+                if p_num >= len(src_writer.pages): continue
+                if change_data['page'] is None: change_data['page'] = p_num + 1
+                
+                page = src_writer.pages[p_num]
+                page_info = src_page_info.get(p_num, (612, 792, 0, 0, 0))
+                
+                for bbox in merge_char_components(p_chars):
+                    add_highlight_rect(page, bbox, color_src, page_info, p_chars[0].pdfminer_width, p_chars[0].pdfminer_height)
+
+        # Highlight destination document (insertions and replacements)
+        if tag in ['replace', 'insert']:
+            dest_chars_to_hl = [dest_chars[k] for k in range(j1, j2) if k < len(dest_chars) and dest_chars[k].has_position]
+            by_page = {}
+            for c in dest_chars_to_hl:
+                by_page.setdefault(c.page_num, []).append(c)
+
+            for p_num, p_chars in by_page.items():
+                if p_num >= len(dest_writer.pages): continue
+                if change_data['page'] is None: change_data['page'] = p_num + 1
+                
+                page = dest_writer.pages[p_num]
+                page_info = dest_page_info.get(p_num, (612, 792, 0, 0, 0))
+                
+                for bbox in merge_char_components(p_chars):
+                    add_highlight_rect(page, bbox, color_dest, page_info, p_chars[0].pdfminer_width, p_chars[0].pdfminer_height)
+
+        # Add change to list if we found a valid page
+        if change_data['page'] is not None:
+            changes_list.append(change_data)
+            change_id += 1
+
+    # Save output files
+    src_out_name = "source_highlighted.pdf"
+    dest_out_name = "dest_highlighted.pdf"
+
+    with open(f"{output_dir}/{src_out_name}", "wb") as f:
+        src_writer.write(f)
+
+    with open(f"{output_dir}/{dest_out_name}", "wb") as f:
+        dest_writer.write(f)
+
+    return src_out_name, dest_out_name, changes_list, total_pages

requirements.txt

@@ -0,0 +1,7 @@
+Flask
+pdfminer.six
+pypdf
+Flask-Cors
+waitress
+uvicorn
+requests

static/output/dest_highlighted.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2a4dfc6c3d9613848d2e59ba808ba0647a56158d0e1c3525fda8bc316671348
+size 3750966

static/output/source_highlighted.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4244590d35f6fc13d1ac6cb1f4f42e056768d57524830a62f434a29637bc366
+size 3768755

static/uploads/2024_12_17_venubabu.bathula_F5MS214215_AM8535_F25.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4febe1f6f29281441ceca87133de6594b74bed65364e75a173156b9a91f9ab52
+size 3484226

static/uploads/2025_4_15_venubabu.bathula_F5MS214215_AM8535_F25.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8aa0da0c9e9d0f0005b44e1177fc25726c92a3fa0fcbc67d955df2726e95af8a
+size 3485792

static/uploads/2025_6_16_bzakaria_F8MS180510_AM0449_S26-1.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d089dfcbb6f1bcfeb12bee79afcacc8b42cebe1cc83bac697aff7f554627bc8
+size 2950920

static/uploads/2025_9_16_venubabu.bathula_F8MS180510_AM0449_S26.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17d686b18e56e09b3d2db876165338eee5ac5c13e40abada3b02a39cd3794f0b
+size 2936649