| """Headless renderer for visual answers (SVG / HTML / canvas / three.js) with objective checks. | |
| render(kind, source, png_path) opens the page in headless Chrome (the installed browser, via playwright) at 1024x768, | |
| waits for it to settle and returns a report: | |
| errors JavaScript exceptions and console errors (messages) | |
| failed network requests that failed (e.g. a wrong library URL) | |
| blank the screenshot is (almost) a single colour | |
| overflow the page is wider than the viewport (horizontal scroll) | |
| animated two screenshots 0.7 s apart differ (for animation tasks) | |
| coverage share of the viewport that is not background colour | |
| parse_error for SVG: the XML does not parse | |
| The screenshot is saved to png_path. Used by the visual benchmark and by the render-check-repair module. | |
| """ | |
| import io | |
| import os | |
| import re | |
| import tempfile | |
| import xml.dom.minidom | |
| import numpy as np | |
| from PIL import Image | |
| from playwright.sync_api import sync_playwright | |
| W, H = 1024, 768 | |
| TMP = os.path.join(tempfile.gettempdir(), "lfm3_render") | |
| os.makedirs(TMP, exist_ok=True) | |
| SVG_PAGE = """<!doctype html><html><head><meta charset="utf-8"><style>html,body{margin:0;background:#fff} | |
| #c{width:1024px;height:768px;display:flex;align-items:center;justify-content:center} | |
| #c>svg{max-width:1024px;max-height:768px;width:100%;height:100%}</style></head><body><div id="c">__SVG__</div></body></html>""" | |
| def _stats(png): | |
| a = np.asarray(Image.open(io.BytesIO(png)).convert("RGB")).astype(np.int16) | |
| flat = a.reshape(-1, 3) | |
| vals, counts = np.unique(flat[::7], axis=0, return_counts=True) | |
| bg = vals[counts.argmax()] | |
| diff = np.abs(a - bg).sum(axis=2) > 24 | |
| return a, float(diff.mean()) | |
| def extract(text, kind): | |
| if text is None: | |
| return None | |
| blocks = re.findall(r"```(\w*)\s*\n(.*?)```", text, re.S) | |
| for lang, body in reversed(blocks): | |
| if kind == "svg" and ("<svg" in body): | |
| return body[body.index("<svg"):].strip() | |
| if kind == "html" and ("<html" in body.lower() or "<body" in body.lower() or "<canvas" in body or "<script" in body): | |
| return body.strip() | |
| if kind == "svg": | |
| m = re.search(r"<svg.*</svg>", text, re.S) | |
| return m.group(0) if m else None | |
| m = re.search(r"<!doctype html.*</html>|<html.*</html>", text, re.S | re.I) | |
| return m.group(0) if m else None | |
| class Renderer: | |
| def __init__(self, channel="chrome"): | |
| self.pw = sync_playwright().start() | |
| self.browser = self.pw.chromium.launch(channel=channel, headless=True, | |
| args=["--use-angle=swiftshader", "--enable-unsafe-swiftshader"]) | |
| def close(self): | |
| self.browser.close() | |
| self.pw.stop() | |
| def render(self, kind, source, png_path, wait_ms=1500): | |
| rep = {"errors": [], "failed": [], "parse_error": None} | |
| if kind == "svg": | |
| try: | |
| xml.dom.minidom.parseString(source.encode("utf-8")) | |
| except Exception as e: | |
| rep["parse_error"] = str(e)[:200] | |
| html = SVG_PAGE.replace("__SVG__", source) | |
| else: | |
| html = source | |
| path = os.path.join(TMP, f"page_{os.getpid()}_{abs(hash(png_path)) % 10**8}.html") | |
| with open(path, "w", encoding="utf-8") as f: | |
| f.write(html) | |
| page = self.browser.new_page(viewport={"width": W, "height": H}) | |
| page.on("pageerror", lambda e: rep["errors"].append(f"Uncaught {e.name}: {e.message}"[:300])) | |
| page.on("console", lambda m: rep["errors"].append(("console.error: " + m.text)[:300]) if m.type == "error" else None) | |
| page.on("requestfailed", lambda r: rep["failed"].append(r.url[:200])) | |
| try: | |
| page.goto("file:///" + path.replace("\\", "/"), wait_until="load", timeout=20000) | |
| page.wait_for_timeout(wait_ms) | |
| png1 = page.screenshot() | |
| page.wait_for_timeout(700) | |
| png2 = page.screenshot() | |
| rep["overflow"] = bool(page.evaluate("document.documentElement.scrollWidth > window.innerWidth + 2")) | |
| rep["page_height"] = int(page.evaluate("document.documentElement.scrollHeight")) | |
| except Exception as e: | |
| rep["errors"].append(f"page failed to load: {str(e)[:200]}") | |
| png1 = png2 = page.screenshot() if not page.is_closed() else None | |
| rep["overflow"], rep["page_height"] = False, 0 | |
| finally: | |
| page.close() | |
| try: | |
| os.remove(path) | |
| except OSError: | |
| pass | |
| if png1 is None: | |
| rep.update(blank=True, coverage=0.0, animated=False) | |
| return rep | |
| with open(png_path, "wb") as f: | |
| f.write(png2) | |
| a1, cov = _stats(png1) | |
| a2, _ = _stats(png2) | |
| rep["coverage"] = round(cov, 4) | |
| rep["blank"] = cov < 0.003 | |
| rep["animated"] = bool((np.abs(a1 - a2).sum(axis=2) > 24).mean() > 0.0005) | |
| return rep | |
| if __name__ == "__main__": | |
| import json | |
| import sys | |
| r = Renderer() | |
| kind, src, out = sys.argv[1], open(sys.argv[2], encoding="utf-8").read(), sys.argv[3] | |
| print(json.dumps(r.render(kind, src, out), ensure_ascii=False)) | |
| r.close() | |