diff --git a/annotating.py b/annotating.py index 88a0106..4a4ecfc 100644 --- a/annotating.py +++ b/annotating.py @@ -2,6 +2,8 @@ import sys import os import json import glob +from pathlib import Path +import subprocess from PIL import Image MARGIN_LEFT = 300 @@ -81,6 +83,22 @@ def make_dictionary(root_dir): return result_data +def make_base_image(pdf_path): + pages = convert_from_path(pdf_path) + + # Calculate total dimensions + total_h = sum(page.height for page in pages) + max_w = max(page.width for page in pages) + + # Create concatenated base image + base_img = Image.new("RGBA", (max_w, total_h), "white") + + current_y = 0 + for page in pages: + base_img.paste(page.convert("RGBA"), (0, current_y)) + current_y += page.height + return (base_img, total_h, max_w) + import io import shutil from pdf2image import convert_from_path @@ -111,7 +129,6 @@ def normalize_mathtext(text): text = re.sub('\u0010', "", text) return text -import re def wrap_latex_text(text, width_chars): """ Wraps text but keeps LaTeX math blocks ($...$) intact. @@ -178,8 +195,6 @@ def render_latex_text(text, width_px, bg_color=(255, 255, 255, 255), max_lines=N fig = plt.figure(figsize=(fig_width, fig_height), dpi=dpi) - # print(wrapped_text) - # print("\n\n") # NOTE: wrap=False because we did it ourselves plt.text(0.01, 0.95, wrapped_text, fontsize=fontsize, verticalalignment='top', horizontalalignment='left', @@ -199,74 +214,129 @@ def render_latex_text(text, width_px, bg_color=(255, 255, 255, 255), max_lines=N final_img.alpha_composite(img) return final_img -def add_local_fb(fb, draw, final_img, hmin, image_offset_y, last_text_bottom): - # raw_pos = fb.get('pos') - box = fb.get('box_2d') - if not box or len(box) < 4: - return +def compose_label_image(base_img, label, result, hmin, + render_fn=render_latex_text, + draw_callback=None): + """ + Composes the final image with annotations. - ymin, xmin, ymax, xmax = box[0], box[1], box[2], box[3] + Args: + base_img: The source PDF converted to image. + label: Label name (e.g. "Ex1"). + result: The JSON result object (score, feedbacks). + hmin: Vertical offset coordinate. + render_fn: Function to render text to image (allows threading injection). + draw_callback: Optional function(type, draw_obj, position_dict, data_dict) + called when elements are placed. Used for checkboxes. + """ + score = result.get('score', 0) + error = result.get('error', "") + feedbacks = result.get('feedback', []) - target_ymin = (ymin - hmin) + image_offset_y - target_ymax = (ymax - hmin) + image_offset_y - target_xmin = xmin + MARGIN_LEFT - target_xmax = xmax + MARGIN_LEFT + # Filter deleted items (used by reading_annotations.py) + feedbacks = [f for f in feedbacks if "to_delete" not in f] - # Draw Rectangle - draw.rectangle([target_xmin, target_ymin, target_xmax, target_ymax], outline="red", width=3) + global_fb = [f for f in feedbacks if not f.get('box_2d')] + local_fb = [f for f in feedbacks if f.get('box_2d')] + local_fb.sort(key=lambda x: x['box_2d'][0]) - # Render Text with transparent red background - # (255, 0, 0, 50) is transparent red - txt_img = render_latex_text( - fb['text'], - width_px=ANNOT_WIDTH, - bg_color=(255, 200, 200, 180), # Light Red semi-transparent - max_lines=3 - ) + # 1. Prepare Headers + header_elements = [] - # Calculate placement - txt_h = txt_img.height - center_y = (target_ymin + target_ymax) / 2 - paste_y = center_y - (txt_h / 2) + # Score + score_text = f"{label} ; Note : {score}" + if error and error != "null": score_text += f" | Error: {error}" - paste_y = max(paste_y, image_offset_y) + img_score = render_fn(score_text, base_img.width // 2, fontsize=18) + header_elements.append({"type": "score", "img": img_score, "data": result}) - # Prevent overlap with previous text - if paste_y < last_text_bottom: - paste_y = last_text_bottom + 5 # Move down + padding + # Global Feedbacks + for idx, fb in enumerate(global_fb): + img_fb = render_fn(fb['text'], base_img.width) + header_elements.append({"type": "global_fb", "img": img_fb, "data": fb, "index": idx}) - # Check for overflow and resize if necessary - required_height = int(paste_y + txt_h + 20) # +20 for bottom padding - if required_height > final_img.height: - # Create a new taller image - new_final = Image.new("RGB", (final_img.width, required_height), "white") - # Paste the current image content onto the new one - new_final.paste(final_img, (0, 0)) - final_img = new_final - # Re-initialize the draw object for the new image so subsequent rectangles are drawn correctly - draw = ImageDraw.Draw(final_img, "RGBA") + # Calculate Header Height + header_height = sum(el["img"].height for el in header_elements) + total_height = base_img.height + header_height + # Create Canvas + final_img = Image.new("RGB", (base_img.width + MARGIN_LEFT, total_height), "white") - # Paste in the left margin - final_img.paste(txt_img, (10, int(paste_y)), mask=txt_img) - last_text_bottom = paste_y + txt_h - return (draw, final_img, last_text_bottom) - -def make_base_image(pdf_path): - pages = convert_from_path(pdf_path) - - # Calculate total dimensions - total_h = sum(page.height for page in pages) - max_w = max(page.width for page in pages) - - # Create concatenated base image - base_img = Image.new("RGBA", (max_w, total_h), "white") - + # Draw Headers current_y = 0 - for page in pages: - base_img.paste(page.convert("RGBA"), (0, current_y)) - current_y += page.height - return (base_img, total_h, max_w) + draw = ImageDraw.Draw(final_img, "RGBA") + + for el in header_elements: + final_img.paste(el["img"], (0, current_y)) + + if draw_callback: + # Hook for checkboxes + draw_callback("header_item", draw, + {"x": 0, "y": current_y, "w": el["img"].width, "h": el["img"].height}, + el) + current_y += el["img"].height + + # Paste Base Image + image_offset_y = current_y + final_img.paste(base_img, (MARGIN_LEFT, image_offset_y)) + + # 2. Draw Local Annotations + draw = ImageDraw.Draw(final_img, "RGBA") # Refresh draw object + last_text_bottom = 0 + + for idx, fb in enumerate(local_fb): + box = fb.get('box_2d') + ymin, xmin, ymax, xmax = box + + target_ymin = (ymin - hmin) + image_offset_y + target_ymax = (ymax - hmin) + image_offset_y + target_xmin = xmin + MARGIN_LEFT + target_xmax = xmax + MARGIN_LEFT + + # Draw Rectangle (if not suppressed) + if "norectangle" not in fb: + draw.rectangle([target_xmin, target_ymin, target_xmax, target_ymax], outline="red", width=3) + + if draw_callback: + draw_callback("local_rect", draw, + {"box": [target_xmin, target_ymin, target_xmax, target_ymax]}, + {"data": fb, "index": idx}) + + # Render Text + txt_img = render_fn(fb['text'], width_px=ANNOT_WIDTH, + bg_color=(255, 200, 200, 180), max_lines=3) + + # Calculate Position + center_y = (target_ymin + target_ymax) / 2 + paste_y = center_y - (txt_img.height / 2) + paste_y = max(paste_y, image_offset_y) + + if paste_y < last_text_bottom: + paste_y = last_text_bottom + 5 + + # Resize canvas if needed + required_height = int(paste_y + txt_img.height + 20) + if required_height > final_img.height: + new_final = Image.new("RGB", (final_img.width, required_height), "white") + new_final.paste(final_img, (0, 0)) + final_img = new_final + draw = ImageDraw.Draw(final_img, "RGBA") + + # Paste Text + final_img.paste(txt_img, (10, int(paste_y)), mask=txt_img) + + if draw_callback: + draw_callback("local_text", draw, + {"x": 10, "y": int(paste_y), "w": txt_img.width, "h": txt_img.height}, + {"data": fb, "index": idx}) + + last_text_bottom = paste_y + txt_img.height + + return final_img + +def natural_key(text): + return [int(c) if c.isdigit() else c.lower() for c in re.split(r'(\d+)', str(text))] + def process_correction(root_dir, data, all_labels, overwrite=False): for student_id, labels in data.items(): @@ -274,8 +344,6 @@ def process_correction(root_dir, data, all_labels, overwrite=False): # Prepare output directory: Dir/Anot_CopieID output_dir = os.path.join(root_dir, "Anot", f"Copie{student_id}") - # output_dir = os.path.join(root_dir, f"Anot_Copie{student_id}") - # Check if already processed (Concat.jpg exists) concat_path = os.path.join(output_dir, "Concat.jpg") if os.path.exists(concat_path) and not overwrite: @@ -290,8 +358,11 @@ def process_correction(root_dir, data, all_labels, overwrite=False): os.makedirs(output_dir) d_notes = dict.fromkeys(all_labels,"") + label_images = [] - for label, content in labels.items(): + labels = sorted(list(labels.items()), key=natural_key) + + for label, content in labels: # 1. Find PDF path copie_folder = f"Copie{student_id}" pdf_rel_path = os.path.join(copie_folder, f"{label}.pdf") @@ -303,114 +374,37 @@ def process_correction(root_dir, data, all_labels, overwrite=False): # 2. Convert PDF to Image try: - (base_img, total_h, max_w) = annotating.make_base_image(pdf_full_path) + (base_img, _, _) = make_base_image(pdf_full_path) except Exception as e: print(f"Error converting {pdf_full_path}: {e}") continue - coordinates = content.get('coordinates', (0, 0)) # (hmin, hmax) - hmin = coordinates[0] result = content.get('result', {}) + coordinates = content.get('coordinates', (0, 0)) # (hmin, hmax) score = result.get('score', 0) - error = result.get('error', "") - feedbacks = result.get('feedback', []) - - # Organize feedbacks - global_fb = [f for f in feedbacks if not f.get('box_2d')] - local_fb = [f for f in feedbacks if f.get('box_2d')] - # Sort local feedback by Y position - local_fb.sort(key=lambda x: x['box_2d'][0]) - - # --- PREPARE HEADERS --- - header_elements = [] - score_text = f"{label} ; Note : {score}" d_notes[label] = str(score) - if error and error != "null": - score_text += f" | Error: {error}" - # Render Row 1 - row1_img = render_latex_text(score_text, base_img.width,fontsize=18) - header_elements.append(row1_img) - - # --- OTHER HEADERS - # Render Global Feedbacks (Rows 2+) - for fb in global_fb: - fb_img = render_latex_text(fb['text'], base_img.width) - header_elements.append(fb_img) - - # Calculate total new height - header_height = sum(img.height for img in header_elements) - total_height = base_img.height + header_height - - # Create Canvas - final_img = Image.new("RGB", (base_img.width + MARGIN_LEFT, total_height), "white") - - # Paste Headers - current_y = 0 - for elem in header_elements: - final_img.paste(elem, (0, current_y)) - current_y += elem.height - - # Paste Original Image - # Note: current_y is now the offset for the actual image content - image_offset_y = current_y - final_img.paste(base_img, (MARGIN_LEFT, image_offset_y)) - - # --- DRAW LOCAL ANNOTATIONS --- - draw = ImageDraw.Draw(final_img, "RGBA") - - last_text_bottom = 0 - - for fb in local_fb: - (draw, final_img, last_text_bottom) = add_local_fb(fb, draw, final_img, hmin, image_offset_y, last_text_bottom) + final_img = compose_label_image(base_img, label, result, coordinates[0]) # 7. Save Image save_path = os.path.join(output_dir, f"{label}.jpg") final_img.save(save_path) + label_images.append(final_img) - json_path = os.path.join(output_dir, "score.json") - with open(json_path, "w") as f: + # Save scores + with open(os.path.join(output_dir, "score.json"), "w") as f: json.dump(d_notes, f, indent=4) - concat_display_image(output_dir) - - - -from pathlib import Path -import subprocess - -def concat_display_image(subdir): - subdir = Path(subdir) - # Find valid images, excluding previous concatenations - images = sorted([ - f for f in subdir.glob("*.jpg") - if f.name != "Concat.jpg" - ]) - - if not images: - return - images.sort(key=lambda f: [int(n) for n in re.findall(r'\d+', str(f))]) - - - # Load images - opened_imgs = [Image.open(img) for img in images] - - # Calculate dimensions (max width, sum of heights) - max_w = max(i.width for i in opened_imgs) - total_h = sum(i.height for i in opened_imgs) - - # Create canvas and paste vertically - canvas = Image.new('RGB', (max_w, total_h)) - current_y = 0 - for img in opened_imgs: - canvas.paste(img, (0, current_y)) - current_y += img.height - - # Save - save_path = subdir / "Concat.jpg" - canvas.save(save_path) - print(f"Saved: {save_path}") - # subprocess.call(('xdg-open', save_path)) + # Concatenate + if label_images: + max_w = max(i.width for i in label_images) + total_h = sum(i.height for i in label_images) + canvas = Image.new('RGB', (max_w, total_h)) + cy = 0 + for img in label_images: + canvas.paste(img, (0, cy)) + cy += img.height + canvas.save(concat_path) import argparse if __name__ == "__main__": diff --git a/annotating_with_checks.py b/annotating_with_checks.py index 2fa7e0f..10835ae 100644 --- a/annotating_with_checks.py +++ b/annotating_with_checks.py @@ -37,145 +37,62 @@ def draw_checkbox(draw, x, y, size=BOX_SIZE, label=None, fill="white"): return [x, y, x + size, y + size] -def safe_render_latex(text, **kwargs): +def safe_render_latex(*args, **kwargs): """Thread-safe wrapper for latex rendering.""" with LATEX_LOCK: - return annotating.render_latex_text(text, **kwargs) + return annotating.render_latex_text(*args, **kwargs) -def render_header(label, score, feedbacks, base_width): - """Generates the score line and global feedback elements.""" - elements = [] +class CheckboxRenderer: + def __init__(self, label_name): + self.label = label_name + self.checkboxes = [] # List of {type, box, etc.} - # Score Line - score_text_img = safe_render_latex(f"{label} ; Note : {score}", width_px=base_width // 2, fontsize=18) - score_line_h = max(score_text_img.height, SCORE_BOX_SIZE + 10) - score_line_img = Image.new("RGBA", (base_width, score_line_h), (255, 255, 255, 0)) - score_line_img.paste(score_text_img, (0, 0)) + def callback(self, kind, draw, pos, meta): + """ + Called by compose_label_image during rendering. + pos contains {x, y, w, h} or {box}. + meta contains {data, index, etc.} + """ + if kind == "header_item": + # meta['data'] is either result object (for score) or feedback object + if meta.get("type") == "score": + # Draw score boxes + start_x = pos['w'] + 20 + for val in SCORES: + box = draw_checkbox(draw, start_x, pos['y'] + 5, BOX_SIZE, str(val)) + self.checkboxes.append({ + "type": "score", "label": self.label, "value": val, + "rel_box": box # Will be adjusted for global Y later + }) + start_x += BOX_SIZE + 60 + elif meta.get("type") == "global_fb": + # Draw delete box for global feedback + bx = pos['w'] - BOX_SIZE - 5 + by = pos['y'] + 5 + box = draw_checkbox(draw, bx, by, BOX_SIZE) + self.checkboxes.append({ + "type": "del_global", "label": self.label, "index": meta["index"], + "rel_box": box, "text_preview": meta["data"]["text"][:20] + }) - draw_score = ImageDraw.Draw(score_line_img) - start_x = score_text_img.width + 20 - local_boxes = [] + elif kind == "local_rect": + # Delete rect checkbox + b = pos['box'] # [xmin, ymin, xmax, ymax] + box = draw_checkbox(draw, b[2] - BOX_SIZE, b[1], BOX_SIZE) + self.checkboxes.append({ + "type": "del_local_rect", "label": self.label, "index": meta["index"], + "final_box": box, "text_preview": meta["data"]["text"][:20] + }) - for val in SCORES: - box = draw_checkbox(draw_score, start_x, 5, SCORE_BOX_SIZE, str(val)) - local_boxes.append({ - "type": "score", "label": label, "value": val, - "rel_box": box, "elem_y": 0 - }) - start_x += SCORE_BOX_SIZE + 60 - elements.append((score_line_img, local_boxes)) - - # Global Feedback - for i, fb in enumerate(feedbacks): - fb_img = safe_render_latex(fb['text'], width_px=base_width) - draw_fb = ImageDraw.Draw(fb_img) - bx = fb_img.width - BOX_SIZE - 5 - by = 5 - box = draw_checkbox(draw_fb, bx, by, BOX_SIZE) - - elements.append((fb_img, [{ - "type": "del_global", "label": label, "index": i, - "text_preview": fb['text'][:20], "rel_box": box, "elem_y": 0 - }])) - - return elements - -def process_label(root_dir, student_id, label, content): - """Processes a single label (PDF) -> Annotated Image + Checkboxes.""" - copie_folder = f"Copie{student_id}" - pdf_path = os.path.join(root_dir, copie_folder, f"{label}.pdf") - - if not os.path.exists(pdf_path): - return None, [] - base_img, total_h, max_w = annotating.make_base_image(pdf_path) - if not base_img: - return None, [] - - # Extract Data - coordinates = content.get('coordinates', (0, 0)) - hmin = coordinates[0] - result = content.get('result', {}) - score = result.get('score', 0) - feedbacks = result.get('feedback', []) - - global_fb = [f for f in feedbacks if not f.get('box_2d')] - local_fb = [f for f in feedbacks if f.get('box_2d')] - local_fb.sort(key=lambda x: x['box_2d'][0]) - - checkbox_map = [] - - # 1. Render Header - header_elements = render_header(label, score, global_fb, base_img.width) - header_height = sum(x[0].height for x in header_elements) - - # 2. Assemble Base + Header - total_height = base_img.height + header_height - final_img = Image.new("RGB", (base_img.width + MARGIN_LEFT, total_height), "white") - - current_y = 0 - for img, boxes in header_elements: - final_img.paste(img, (0, current_y)) - for b in boxes: - b['final_box'] = [b['rel_box'][0], b['rel_box'][1] + current_y, - b['rel_box'][2], b['rel_box'][3] + current_y] - checkbox_map.append(b) - current_y += img.height - - image_offset_y = current_y - final_img.paste(base_img, (MARGIN_LEFT, image_offset_y)) - - # 3. Draw Local Annotations - draw = ImageDraw.Draw(final_img, "RGBA") - last_text_bottom = 0 - - for i, fb in enumerate(local_fb): - box = fb.get('box_2d') - if not box: continue - - ymin, xmin, ymax, xmax = box - target_ymin = (ymin - hmin) + image_offset_y - target_ymax = (ymax - hmin) + image_offset_y - target_xmin = xmin + MARGIN_LEFT - target_xmax = xmax + MARGIN_LEFT - - draw.rectangle([target_xmin, target_ymin, target_xmax, target_ymax], outline="red", width=3) - - rect_cb_box = draw_checkbox(draw, target_xmax - BOX_SIZE, target_ymin, BOX_SIZE) - checkbox_map.append({ - "type": "del_local_rect", "label": label, "index": i, - "text_preview": fb['text'][:20], "final_box": rect_cb_box - }) - - txt_img_raw = safe_render_latex(fb['text'], width_px=ANNOT_WIDTH, - bg_color=(255, 200, 200, 180), max_lines=3) - container_h = max(txt_img_raw.height, BOX_SIZE) - txt_img = Image.new("RGBA", (ANNOT_WIDTH, container_h), (255, 255, 255, 0)) - txt_img.paste(txt_img_raw, (0, 0)) - - d_txt = ImageDraw.Draw(txt_img) - draw_checkbox(d_txt, ANNOT_WIDTH - BOX_SIZE, 0, BOX_SIZE) - - center_y = (target_ymin + target_ymax) / 2 - paste_y = max(center_y - (txt_img.height / 2), image_offset_y) - if paste_y < last_text_bottom: - paste_y = last_text_bottom + 5 - - req_h = int(paste_y + txt_img.height + 20) - if req_h > final_img.height: - new_final = Image.new("RGB", (final_img.width, req_h), "white") - new_final.paste(final_img, (0,0)) - final_img = new_final - draw = ImageDraw.Draw(final_img, "RGBA") - - final_img.paste(txt_img, (10, int(paste_y)), mask=txt_img) - checkbox_map.append({ - "type": "del_local", "label": label, "index": i, - "text_preview": fb['text'][:20], - "final_box": [10 + ANNOT_WIDTH - BOX_SIZE, int(paste_y), 10 + ANNOT_WIDTH, int(paste_y) + BOX_SIZE] - }) - last_text_bottom = paste_y + txt_img.height - - return final_img, checkbox_map + elif kind == "local_text": + # Delete whole local feedback checkbox + bx = pos['x'] + pos['w'] - BOX_SIZE + by = pos['y'] + box = draw_checkbox(draw, bx, by, BOX_SIZE) + self.checkboxes.append({ + "type": "del_local", "label": self.label, "index": meta["index"], + "final_box": box, "text_preview": meta["data"]["text"][:20] + }) import re def natural_key(text): @@ -192,19 +109,31 @@ def process_student(args): os.makedirs(output_dir) label_images = [] - student_checkboxes = [] - processed_labels_order = [] + all_checkboxes = [] + sorted_labels = sorted(labels.items(), key=lambda x: natural_key(x[0])) - for label, content in sorted(labels.items(), key=lambda x: natural_key(x[0])): - img, boxes = process_label(root_dir, student_id, label, content) - if img: - label_images.append(img) - student_checkboxes.append(boxes) - processed_labels_order.append(label) + for label, content in sorted_labels: + pdf_path = content['pdf_path'] + if not os.path.exists(pdf_path): continue - if not label_images: - return + base_img, _, _ = annotating.make_base_image(pdf_path) + # Initialize the hook + cb_renderer = CheckboxRenderer(label) + + # Render using the shared engine + final_img = annotating.compose_label_image( + base_img, label, content['result'], content['coordinates'][0], + render_fn=safe_render_latex, + draw_callback=cb_renderer.callback + ) + + label_images.append(final_img) + all_checkboxes.append(cb_renderer.checkboxes) + + if not label_images: return + + # Concatenate max_w = max(i.width for i in label_images) total_h = sum(i.height for i in label_images) concat_img = Image.new("RGB", (max_w, total_h), "white") @@ -212,11 +141,14 @@ def process_student(args): final_json_map = [] current_y = 0 - for label_name, img, boxes in zip(processed_labels_order, label_images, student_checkboxes): + for img, boxes in zip(label_images, all_checkboxes): concat_img.paste(img, (0, current_y)) + # Adjust coordinates for concatenated image for item in boxes: - b = item['final_box'] + # item might have 'rel_box' (header) or 'final_box' (local) + # Both were relative to the label image. We just add current_y. + b = item.get('final_box') or item.get('rel_box') item['global_box'] = [b[0], b[1] + current_y, b[2], b[3] + current_y] final_json_map.append(item) @@ -254,7 +186,6 @@ def process_student(args): # concat_img.save(os.path.join(output_dir, "Concat.pdf"), "PDF", resolution=72.0) # concat_img.save(os.path.join(output_dir, "Reference.jpg")) - if __name__ == "__main__": if len(sys.argv) < 2: print("Usage: python annotating_with_checks.py ") diff --git a/reading_annotations.py b/reading_annotations.py index d213ca3..d27f932 100644 --- a/reading_annotations.py +++ b/reading_annotations.py @@ -136,11 +136,7 @@ def detect_checks_and_notes(output_dir): notes.putalpha(Image.fromarray(final_alpha)) - # Debuging : Issues - # - The artifacts increase as we go lower in the image - # - Tous les rectangles sont présents - # - - notes.show() + # notes.show() return actions, notes @@ -172,7 +168,6 @@ def apply_actions_and_regenerate(root_dir, data, student_id, actions, notes_laye actions_by_label[l].append(a) for label, acts in sorted(actions_by_label.items(), key=lambda x: natural_key(x[0])): - # print(label) if label not in labels: continue content = labels[label] @@ -222,91 +217,22 @@ def apply_actions_and_regenerate(root_dir, data, student_id, actions, notes_laye # We use a temporary modified dictionary temp_data = {student_id: labels} - # Run the original process (but we need to intercept it to not save, or just let it save) - - # Hijack the output dir in logic or copy code? - # Let's just implement the rendering loop here to be safe and clean, - # overlaying the notes at the end. - output_dir = os.path.join(root_dir, "Bnot", f"Copie{student_id}") - - # ... (Reuse rendering logic from annotating.py exactly) ... - # See below for condensed integration - final_concats = [] - for label, content in sorted(labels.items(), key=lambda x: natural_key(x[0])): + sorted_labels = sorted(labels.items(), key=lambda x: natural_key(x[0])) + for label, content in sorted_labels: # ... [PDF to Image Conversion] ... copie_folder = f"Copie{student_id}" pdf_path = os.path.join(root_dir, copie_folder, f"{label}.pdf") if not os.path.exists(pdf_path): continue - (base_img, total_h, max_w) = annotating.make_base_image(pdf_path) + (base_img, _total_h, _max_w) = annotating.make_base_image(pdf_path) + img = annotating.compose_label_image( + base_img, label, content['result'], content['coordinates'][0] + ) - # ... [Draw Header/Margin (Clean)] ... - margin_left = MARGIN_LEFT - result = content['result'] - coordinates = content.get('coordinates', (0,0)) - hmin = coordinates[0] - - score_text = f"{label} ; Note : {result.get('score', 0)}" - if result.get('error') and result.get('error') != "null": score_text += f" | Error: {result.get('error')}" - - header_imgs = [(annotating.render_latex_text(score_text, base_img.width, fontsize=18), True)] - - feedbacks = result.get('feedback', []) - # Separate again (now cleaned) - global_fb = [f for f in feedbacks if not f.get('box_2d')] - local_fb = [f for f in feedbacks if f.get('box_2d')] - local_fb.sort(key=lambda x: x['box_2d'][0]) - - for fb in global_fb: - render = annotating.render_latex_text(fb['text'], base_img.width) - header_imgs.append((render, "to_delete" not in fb)) - - total_h = base_img.height + sum(i.height for (i,_) in header_imgs) - label_img = Image.new("RGB", (base_img.width + margin_left, total_h), "white") - - cy = 0 - for (i, keep) in header_imgs: - if keep: - label_img.paste(i, (0, cy)) - else: - blank = Image.new("RGB", (i.width, i.height), "white") - label_img.paste(blank, (0, cy)) - cy+=i.height - img_offset_y = cy - label_img.paste(base_img, (margin_left, img_offset_y)) - - draw = ImageDraw.Draw(label_img, "RGBA") - last_bot = 0 - for fb in local_fb: - box = fb['box_2d'] - - ymin, xmin, ymax, xmax = box - t_ymin = (ymin - hmin) + img_offset_y - t_ymax = (ymax - hmin) + img_offset_y - if "norectangle" not in fb: - draw.rectangle([xmin+margin_left, t_ymin, xmax+margin_left, t_ymax], - outline="red", width=3) - - txt = annotating.render_latex_text(fb['text'], ANNOT_WIDTH, - (255,200,200,180), max_lines=3) - py = max((t_ymin+t_ymax)/2 - txt.height/2, img_offset_y) - if py < last_bot: - py = last_bot + 5 - - if py + txt.height + 20 > label_img.height: - new_l = Image.new("RGB", (label_img.width, int(py+txt.height+20)), "white") - new_l.paste(label_img, (0,0)) - label_img = new_l - draw = ImageDraw.Draw(label_img, "RGBA") - - if not "to_delete" in fb: - label_img.paste(txt, (10, int(py)), mask=txt) - last_bot = py + txt.height - - final_concats.append(label_img) + final_concats.append(img) # Concatenate Labels if not final_concats: return @@ -321,19 +247,11 @@ def apply_actions_and_regenerate(root_dir, data, student_id, actions, notes_laye # 3. Overlay Manual Notes if notes_layer: - # Notes layer might be different size if regenerated image size changed (e.g. deleted comments reduced height) - # However, usually reducing content reduces height, so we align top-left. - # But `notes_layer` is based on the "Reference.png" which had boxes. - # The new `full_clean_img` does NOT have boxes. The dimensions should be identical - # unless removing a feedback at the very bottom shrinks the image. - - # We paste notes_layer on top. full_clean_img.paste(notes_layer, (0,0), mask=notes_layer) # Save final Concat.jpg - final_path = os.path.join(output_dir, "Concat.jpg") - full_clean_img.save(final_path) - print(f"Saved regenerated: {final_path}") + full_clean_img.save(os.path.join(output_dir, "Concat.jpg")) + print(f"Saved regenerated: {os.path.join(output_dir, 'Concat.jpg')}") if __name__ == "__main__": if len(sys.argv) < 2: